Click here to Skip to main content
11,412,526 members (75,492 online)
Click here to Skip to main content

Anonymous Method Serialization

, 12 Feb 2009 CPOL
Rate this:
Please Sign up or sign in to vote.
Anonymous method serialization

Introduction

Anonymous methods cannot be serialized in C# (unless they do not reference any stack variables). The most simple solution would be to add the [Serializable] attribute to the anonymous class generated for the method, but since this is (as far as I know) not possible yet, we have to use this "hack".

This is an updated version of Jeremy Thomas' version that can be found here, with the improvement that this also supports nested delegates, and any delegate.

Please note that this code is not very well tested.  Also note that anything you reference inside the anonymous method also gets serialized, including this. This means that, if you serialize a delegate referencing this and then deserialize it again and run it, then this will refer to a new copy of the object.

Using the Code 

formater.Serialize(stream, new SerializeDelegate(myDelegate));

Code

[Serializable]
public class SerializeDelegate : ISerializable
{
    internal SerializeDelegate(Delegate delegate_)
    {
        this.delegate_ = delegate_;
    }

    internal SerializeDelegate(SerializationInfo info, StreamingContext context)
    {
        Type delType = (Type)info.GetValue("delegateType", typeof(Type));

        //If it's a "simple" delegate we just read it straight off
        if (info.GetBoolean("isSerializable"))
            this.delegate_ = (Delegate)info.GetValue("delegate", delType);

        //otherwise, we need to read its anonymous class
        else
        {
            MethodInfo method = (MethodInfo)info.GetValue("method", typeof(MethodInfo));

            AnonymousClassWrapper w = 
                (AnonymousClassWrapper)info.GetValue
			("class", typeof(AnonymousClassWrapper));

            delegate_ = Delegate.CreateDelegate(delType, w.obj, method);
        }
    }

    void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue("delegateType", delegate_.GetType());

        //If it's an "simple" delegate we can serialize it directly
        if ((delegate_.Target == null ||
            delegate_.Method.DeclaringType
                .GetCustomAttributes(typeof(SerializableAttribute), false).Length > 0) &&
            delegate_ != null)
        {
            info.AddValue("isSerializable", true);
            info.AddValue("delegate", delegate_);
        }

        //otherwise, serialize anonymous class
        else
        {
            info.AddValue("isSerializable", false);
            info.AddValue("method", delegate_.Method);
            info.AddValue("class", 
                new AnonymousClassWrapper
		(delegate_.Method.DeclaringType, delegate_.Target));
        }
    }

    public Delegate Delegate { get { return delegate_; } }

    Delegate delegate_;

    [Serializable]
    class AnonymousClassWrapper : ISerializable
    {
        internal AnonymousClassWrapper(Type bclass, object bobject)
        {
            this.type = bclass;
            this.obj = bobject;
        }

        internal AnonymousClassWrapper(SerializationInfo info, StreamingContext context)
        {
            Type classType = (Type)info.GetValue("classType", typeof(Type));
            obj = Activator.CreateInstance(classType);

            foreach (FieldInfo field in classType.GetFields())
            {
                //If the field is a delegate
                if (typeof(Delegate).IsAssignableFrom(field.FieldType))
                    field.SetValue(obj,
                        ((SerializeDelegate)info.GetValue
				(field.Name, typeof(SerializeDelegate)))
                            .Delegate);
                //If the field is an anonymous class
                else if(!field.FieldType.IsSerializable)
                    field.SetValue(obj,
                        ((AnonymousClassWrapper)info.GetValue
				(field.Name, typeof(AnonymousClassWrapper)))
                            .obj);
                //otherwise
                else
                    field.SetValue(obj, info.GetValue(field.Name, field.FieldType));
            }
        }

        void ISerializable.GetObjectData
		(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("classType", type);

            foreach (FieldInfo field in type.GetFields())
            {
                //See corresponding comments above
                if (typeof(Delegate).IsAssignableFrom(field.FieldType))
                    info.AddValue(field.Name, new SerializeDelegate
					((Delegate)field.GetValue(obj)));
                else if (!field.FieldType.IsSerializable)
                    info.AddValue(field.Name, new AnonymousClassWrapper
				(field.FieldType, field.GetValue(obj)));
                else
                    info.AddValue(field.Name, field.GetValue(obj));
            }
        }

        public Type type; 
        public object obj;
    }
}

History

  • 12th February, 2009: Initial post

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Fredrik Norén
CEO Keldyn Interactive
Sweden Sweden
No Biography provided

Comments and Discussions

 
Questionwhat do i pass to SerializeDelegate() ? Pin
serpiccio at 25-Apr-13 1:38
memberserpiccio25-Apr-13 1:38 
GeneralUnable to deserialize Pin
padanfain at 16-Jun-09 7:21
memberpadanfain16-Jun-09 7:21 
GeneralRe: Unable to deserialize Pin
chot at 19-Aug-09 12:40
memberchot19-Aug-09 12:40 
GeneralA question... Pin
Marc Clifton at 23-Feb-09 2:37
protectorMarc Clifton23-Feb-09 2:37 
GeneralSerializing/reconstituting delegates Pin
supercat9 at 12-Feb-09 17:11
membersupercat912-Feb-09 17:11 
GeneralRe: Serializing/reconstituting delegates Pin
chot at 13-Feb-09 1:27
memberchot13-Feb-09 1:27 
GeneralRe: Serializing/reconstituting delegates Pin
supercat9 at 13-Feb-09 13:21
membersupercat913-Feb-09 13:21 
GeneralRe: Serializing/reconstituting delegates Pin
chot at 13-Feb-09 15:34
memberchot13-Feb-09 15:34 
Well first of, maybe RPC wasn't quite the right word since actually, in most of my calls I don't expect a result. If you do need to handle a result, you can simply send it back with a new anonymous delegate (this is why it supports nested delegates):
Send(ep1, idOfep1Object, (ep1Object) => 
{
   var result = ep1Object.DoSomeWork();
   Send(ep2, idOfep2Object, (ep2Object) => ep2Object.HandleResultOfWork(result));
});
And I make sure I never reference the this pointer, but rather supply the object as an argument to the delegate. Also, I need to supply an id to the object, which is used on the receiving end to look up to the object and supply it as an argument to the delegate. In my version of SerializeDelegate, I actually have some code which detects a this references and throws an exception.

Just to clarify; normally in network communication (which is for what I am using this) you send messages, and normally the first byte or string or whatever decides what should be done and after that follows some arguments. This is basically the same thing(a method and arguments) just that I don't specify the protocol explicitly. Also this way makes it a bit easier (at least for me) to think about it, you can see what will happen right there.

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web03 | 2.8.150427.1 | Last Updated 12 Feb 2009
Article Copyright 2009 by Fredrik Norén
Everything else Copyright © CodeProject, 1999-2015
Layout: fixed | fluid