private CodeExpression SerializeInstanceDescriptor(IDesignerSerializationManager manager, InstanceDescriptor descriptor)
        {
            CodeExpression expression = null;
            MemberInfo     member     = descriptor.MemberInfo;
            CodeExpression target     = new CodeTypeReferenceExpression(member.DeclaringType);

            if (member is PropertyInfo)
            {
                expression = new CodePropertyReferenceExpression(target, member.Name);
            }
            else if (member is FieldInfo)
            {
                expression = new CodeFieldReferenceExpression(target, member.Name);
            }
            else if (member is MethodInfo)
            {
                CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(target, member.Name);
                manager.Context.Push(new ExpressionContext(methodInvoke, methodInvoke.GetType(), null, null));
                if (descriptor.Arguments != null && descriptor.Arguments.Count > 0)
                {
                    methodInvoke.Parameters.AddRange(SerializeParameters(manager, descriptor.Arguments));
                }
                manager.Context.Pop();
                expression = methodInvoke;
            }
            else if (member is ConstructorInfo)
            {
                CodeObjectCreateExpression createExpr = new CodeObjectCreateExpression(member.DeclaringType);
                manager.Context.Push(new ExpressionContext(createExpr, createExpr.GetType(), null, null));
                if (descriptor.Arguments != null && descriptor.Arguments.Count > 0)
                {
                    createExpr.Parameters.AddRange(SerializeParameters(manager, descriptor.Arguments));
                }
                manager.Context.Pop();
                expression = createExpr;
            }

            return(expression);
        }
        protected virtual object SerializeCollection(IDesignerSerializationManager manager, CodeExpression targetExpression,
                                                     Type targetType, ICollection originalCollection, ICollection valuesToSerialize)
        {
            if (valuesToSerialize == null)
            {
                throw new ArgumentNullException("valuesToSerialize");
            }
            if (originalCollection == null)
            {
                throw new ArgumentNullException("originalCollection");
            }
            if (targetType == null)
            {
                throw new ArgumentNullException("targetType");
            }
            if (manager == null)
            {
                throw new ArgumentNullException("manager");
            }

            if (valuesToSerialize.Count == 0)
            {
                return(null);
            }

            MethodInfo method = null;

            try {
                object      sampleParam = null;
                IEnumerator e           = valuesToSerialize.GetEnumerator();
                e.MoveNext();
                sampleParam = e.Current;
                // try to find a method matching the type of the sample parameter.
                // Assuming objects in the collection are from the same base type
                method = GetExactMethod(targetType, "Add", new object [] { sampleParam });
            } catch {
                Console.WriteLine("SerializeCollection: No compatible Add method found in " + targetType);
            }

            if (method == null)
            {
                return(null);
            }

            CodeStatementCollection statements = new CodeStatementCollection();

            foreach (object value in valuesToSerialize)
            {
                CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression();
                methodInvoke.Method = new CodeMethodReferenceExpression(targetExpression, "Add");

                manager.Context.Push(new ExpressionContext(methodInvoke, methodInvoke.GetType(), null, originalCollection));
                CodeExpression expression = base.SerializeToExpression(manager, value);
                if (expression == null)
                {
                    Console.WriteLine("SerializeCollection: Unable to serialize " + value);
                    methodInvoke = null;
                }
                else
                {
                    methodInvoke.Parameters.AddRange(new CodeExpression[] { expression });
                }
                manager.Context.Pop();

                if (methodInvoke != null)
                {
                    statements.Add(methodInvoke);
                }
            }

            return(statements);
        }