using System;

using System.Collections.Generic;

using System.Linq;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.IO;

​

    public interface IViz<T> : ISerializable

    {

        IEnumerable<SelectedValue> SelectedValues { get; }

    };

​

    [Serializable]

    public abstract class GroupViz<T, TIn, TOut> : IViz<T> 

    {

        // Added necessary default and streaming constructors

        public GroupViz() { }

​

        protected GroupViz(SerializationInfo info, StreamingContext context) { }

​

        // Allocated the list

        private IList<SelectedValue> selectedValues = new List<SelectedValue>();

​

        public abstract void GetObjectData(SerializationInfo info, StreamingContext context);

​

        public IEnumerable<SelectedValue> SelectedValues

        {

            get { return selectedValues.Cast<SelectedValue>(); }

        }

        public void Value(SelectedValue @value)

        {

            this.AddValue(@value.Value, @value.Operator);

        }

        private void AddValue(object @value, object vizOperator)

        {

            SelectedValue<TOut> selectedValue = new SelectedValue<TOut>((TOut)value, vizOperator);

            if (!this.selectedValues.Any(sv => sv.Equals(selectedValue)))

                this.selectedValues.Add(selectedValue);

        }

    }

​

    public abstract class ValueGroupViz<T, TIn> : GroupViz<T, TIn, TIn>

    {

        // Added necessary default and streaming constructors

        public ValueGroupViz() : base() { }

​

        protected ValueGroupViz(SerializationInfo info, StreamingContext context) : base(info, context) { }

    }

​

    [Serializable]

    public class EntityValueGroupViz<TEntity, TKey> : ValueGroupViz<TEntity, TKey>

    {

        // Added necessary default and streaming constructors

        public EntityValueGroupViz() : base() { }

​

        protected EntityValueGroupViz(SerializationInfo info, StreamingContext context) : base(info, context)

        {

            foreach (SerializationEntry entry in info)

            {

                switch (entry.Name)

                {

                    case "SelectedValues":

                        foreach (SelectedValue sv in (IEnumerable<SelectedValue>)entry.Value)

                            this.Value(sv);

                        break;

                }

            }

        }

        public override void GetObjectData(SerializationInfo info, StreamingContext context)

        {

            info.AddValue("SelectedValues", SelectedValues);

        }

    }

​

    [Serializable]

    public abstract class SelectedValue : ISerializable

    {       

        protected object @value;

        private object vizOperator;

​

        #region Properties

​

        public object Value

        {

            get

            {

                return @value;

            }

​

            set

            {

                this.@value = value;

            }

        }

​

        public object Operator

        {

            get

            {

                return vizOperator;

            }

​

            set

            {

                vizOperator = value;

            }

        }

​

        #endregion

        public SelectedValue(object value, object vizOperator)

        {

            this.value = value;

            this.vizOperator = vizOperator;

        }

        public SelectedValue(SerializationInfo info, StreamingContext context)

        {

            foreach (SerializationEntry entry in info)

            {

                switch (entry.Name)

                {

                    case "Value":

                        Value = entry.Value;

                        break;

                    case "Operator":

                        Operator = entry.Value;

                        break;

               }

            }

        }

        #region System.Runtime.Serialization.ISerializable overridings

​

        public void GetObjectData(SerializationInfo info, StreamingContext context)

        {

            info.AddValue("Value", Value);

            info.AddValue("Operator", Operator);

        }

​

        #endregion

    }

​

    [Serializable]

    public class SelectedValue<T> : SelectedValue, ISerializable

    {

        #region Properties

​

        public new T Value

        {

            get

            {

                return (T)value;

            }

​

            set

            {

                this.value = value;

            }

        }

​

        #endregion

​

        public SelectedValue(T value, object vizOperator)

            : base(value, vizOperator)

        {

        }

​

        public SelectedValue(SerializationInfo info, StreamingContext context)

            : base(info, context)

        {

        }

    }

​

    [Serializable]

    public class BOEntity { }       

​

    public class TestClass

    {

        public static void Test()

        {

            var test = new EntityValueGroupViz<BOEntity, BOEntity>();

            test.Value(new SelectedValue<BOEntity>(new BOEntity(), "1"));

            test.Value(new SelectedValue<BOEntity>(new BOEntity(), "2"));

            Console.WriteLine("Dump of original EntityValueGroupViz<BOEntity, BOEntity>: ");

            test.Dump();

            var bytes = BinaryFormatterHelper.ToBinary(test);

            var test2 = BinaryFormatterHelper.FromBinary<EntityValueGroupViz<BOEntity, BOEntity>>(bytes);

            Console.WriteLine("Dump of serialized and deserialized EntityValueGroupViz<BOEntity, BOEntity>: ");

            test2.Dump();

        }

    }

    public class Program

    {

        public static void Main()

        {

            try

            {

                TestClass.Test();

            }

            catch (Exception ex)

            {

                Console.WriteLine(ex);

            }

        }

    }

​

    public static partial class BinaryFormatterHelper

    {

        public static byte[] ToBinary<T>(T obj)

        {

            using (var stream = new MemoryStream())

            {

                new BinaryFormatter().Serialize(stream, obj);

                return stream.ToArray();

            }

        }

​

        public static T FromBinary<T>(byte[] data)

        {

            using (var stream = new MemoryStream(data))

            {

                var formatter = new BinaryFormatter();

                var obj = formatter.Deserialize(stream);

                if (obj is T)

                    return (T)obj;

                return default(T);

            }

        }

    }

​