using System;

using System.CodeDom;

using System.CodeDom.Compiler;

using System.ComponentModel;

using System.ComponentModel.Design.Serialization;

using System.Collections.Generic;

using System.Reflection;

public class Program

{

    public static void Main()

    {

        var value = new KeyValuePair<int, string>[] { new KeyValuePair<int, string>(-21, "ab") };

        var expression = CodeDomUtility.Serialize(value);

        var unit = TestField(expression, value.GetType());

        DumpCode(unit, new Microsoft.CSharp.CSharpCodeProvider());

        DumpCode(unit, new Microsoft.VisualBasic.VBCodeProvider());

    }

    static CodeCompileUnit TestField(CodeExpression expression, Type fieldType)

    {

        var unit = new CodeCompileUnit();

        var ns = new CodeNamespace("Sample");

        ns.Imports.Add(new CodeNamespaceImport("System"));

        ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));

        unit.Namespaces.Add(ns);

​

        var class1 = new CodeTypeDeclaration("Foo");

        ns.Types.Add(class1);

​

        var field = new CodeMemberField(fieldType, "Bar") { InitExpression = expression };

        class1.Members.Add(field);

        return unit;

    }

    static void DumpCode(CodeCompileUnit unit, CodeDomProvider provider)

    {

        Console.WriteLine(provider.ToString());

​

        var tw = new IndentedTextWriter(Console.Out, "    ");

        provider.GenerateCodeFromCompileUnit(unit, tw, new CodeGeneratorOptions());

    }

}

​

static partial class CodeDomUtility

{

    static CodeExpression _SerializeArray(Array arr)

    {

        // TODO: Spitting out garbage on empty SZ arrays in VB, with spurious -1's in the code

        // of the array declaration and i have no idea why.

        if (1 == arr.Rank && 0 == arr.GetLowerBound(0))

        {

            var result = new CodeArrayCreateExpression( arr.GetType());

            foreach (var elem in arr)

                result.Initializers.Add(Serialize(elem));

            return result;

        }

        throw new NotSupportedException("Only SZArrays can be serialized to code.");

    }

    public static CodeExpression Serialize(object val)

    {

        if (null == val)

            return new CodePrimitiveExpression(null);

        if (val is bool || 

            val is string || 

            val is short || 

            val is ushort || 

            val is int || 

            val is uint || 

            val is ulong || 

            val is long || 

            val is byte || 

            val is sbyte || 

            val is float || 

            val is double || 

            val is decimal ||

            val is char)

        {

            return new CodePrimitiveExpression(val);

        }

        if (val is Array && 1 == ((Array)val).Rank && 0 == ((Array)val).GetLowerBound(0))

        {

            return _SerializeArray((Array)val);

        }

        var conv = TypeDescriptor.GetConverter(val);

        if (null != conv)

        {

            if (conv.CanConvertTo(typeof(InstanceDescriptor)))

            {

                var desc = conv.ConvertTo(val, typeof(InstanceDescriptor)) as InstanceDescriptor;

                if (!desc.IsComplete)

                    throw new NotSupportedException(string.Format("The type \"{0}\" could not be serialized.", val.GetType().FullName));

                var ctor = desc.MemberInfo as ConstructorInfo;

                if (null != ctor)

                {

                    var result = new CodeObjectCreateExpression(ctor.DeclaringType);

                    foreach (var arg in desc.Arguments)

                        result.Parameters.Add(Serialize(arg));

                    return result;

                }

                throw new NotSupportedException(string.Format("The instance descriptor for type \"{0}\" is not supported.", val.GetType().FullName));

            }

            else

            { 

                // we special case for KeyValuePair types.

                // TODO: research a better way to do this

                var valType = val.GetType();

                if (valType.IsGenericType && valType.GetGenericTypeDefinition() == typeof(KeyValuePair<,>))

                {

                    // TODO: Find out what needs to happen to make it work with VB

                    var kvpType = new CodeTypeReference(typeof(KeyValuePair<,>));

                    foreach (var arg in val.GetType().GetGenericArguments())

                        kvpType.TypeArguments.Add(arg);

                    var result = new CodeObjectCreateExpression(kvpType);

                    for(int ic= kvpType.TypeArguments.Count,i = 0;i<ic;++i)

                    {

                        var prop = val.GetType().GetProperty(0==i?"Key":"Value");

                        result.Parameters.Add(Serialize(prop.GetValue(val)));

                    }

                    return result;

                }

                throw new NotSupportedException(string.Format("The type \"{0}\" could not be serialized.", val.GetType().FullName));

            }

        }

        else

            throw new NotSupportedException(string.Format("The type \"{0}\" could not be serialized.", val.GetType().FullName));

    }

}