using System;

using System.Collections.Generic;

using System.IO;

using System.Runtime.Serialization.Formatters.Binary;

​

[Serializable]

public struct SerializableDelegate<T> where T : class

{

    private Object target;

    private string methodName;

    [NonSerialized] // Comment this out if you want to see it break

    public T cachedDelegate;

    static SerializableDelegate() {

        if (!typeof(T).IsSubclassOf(typeof(Delegate))) {

            throw new InvalidOperationException(typeof(T).Name + " is not a delegate type.");

        }

    }

    public SerializableDelegate(T action) {

        cachedDelegate = action;

        if (action == null) {

            target = null;

            methodName = null;

            return;

        }

        var _delegate = action as Delegate;

        if (_delegate == null) {

            throw new InvalidOperationException(typeof(T).Name + " is not a delegate type.");

        }

        target = _delegate.Target as Object;

        if (target != null) {

            methodName = _delegate.Method.Name;

        } else {

            methodName = _delegate.Method.Name;

        }

    }

    public T GetDelegate() {

        if (cachedDelegate != null) {

            return cachedDelegate;

        }

        if (methodName == null || methodName == "") {

            return null;

        }

        return cachedDelegate = Delegate.CreateDelegate(typeof(T), target, methodName) as T;

    }

}

​

public class Program

{

    [Serializable]

    public class Foo

    {

        public int x = 1;

        public SerializableDelegate<Action> BarDelegate;

        public SerializableDelegate<Func<int>> BarFunc;

        public Foo()

        {

            BarDelegate = new SerializableDelegate<Action>(Bar);

        }

        public void Bar()

        {

            Console.WriteLine($"{this.GetHashCode(),-10}{(x)}");

        }

        public void Bar2()

        {

            Console.WriteLine($"{this.GetHashCode(),-10}{(x * 2)}");

        }

        public int Bar3()

        {

            return 42;

        }

    }

    public static void Main()

    {

        var foo1 = new Foo();

        foo1.x = 2;

        var foo2 = new Foo();

        foo2.x = 3;

        foo2.BarDelegate = new SerializableDelegate<Action>(foo2.Bar2);

        var foo3 = new Foo();

        foo3.x = 5;

        foo3.BarDelegate = new SerializableDelegate<Action>(foo2.Bar); // Note that this is calling foo2's function.

        foo3.BarFunc = new SerializableDelegate<Func<int>>(foo1.Bar3);

        var foos = new List<Foo>();

        foos.Add(foo1); // 2

        foos.Add(foo2); // 6

        foos.Add(foo3); // 3!

        foos.Add(foo1); // 2

        foos.Add(foo1); // 2 // This should return true when we check for equality

        foos.Add(foo2); // 6

        // Serialize into a byte array

        byte[] data;

        using (var stream = new MemoryStream())

        {

            var formatter = new BinaryFormatter();

​

            formatter.Serialize(stream, foos);

            stream.Flush();

​

            data = stream.ToArray();

        }

        // Deserialize from the byte array

        using (var stream = new MemoryStream(data))

        {

            var formatter = new BinaryFormatter();

            var deserializedFoos = formatter.Deserialize(stream) as List<Foo>;

            Foo previous = null;

            foreach (var foo in deserializedFoos)

            {

                Console.Write($"BarDelegate: {foo.Equals(previous).ToString(),-10}");

                foo.BarDelegate.GetDelegate().Invoke();

                Console.WriteLine("BarFunc: " + foo.BarFunc.GetDelegate()?.Invoke());

                Console.WriteLine();

                previous = foo;

            }

        }

    }

}