Hi Schneider,

I got a reply from an expert in the WinForm design time field.

He said that to control the code generation of a root object like a form,
we need to derive from the TypeCodeDomSerializer class to implement the
code generation we like. Then add a DesignerSerializerAttribute to the form
with a second parameter of TypeCodeDomSerializer. For example:

[DesignerSerializer(typeof(MyTypeSerializer),
typeof(TypeCodeDomSerializer))]
public class MyCustomForm : Form {
}

class MyTypeSerializer:TypeCodeDomSerializer
{}

TypeCodeDomSerializer does most of what you want, so you can simply derive
from it.  The one thing it doesn't know about is "InitializeComponent".  
You would have to add support for that. The following is a sample:

internal class ComponentTypeCodeDomSerializer : TypeCodeDomSerializer {
       private static object _initMethodKey = new object();
       private const string _initMethodName = "InitializeComponent";
       private static ComponentTypeCodeDomSerializer _default;

       internal new static ComponentTypeCodeDomSerializer Default {
           get {
               if (_default == null) {
                   _default = new ComponentTypeCodeDomSerializer();
               }

               return _default;
           }
       }

       /// <include file='doc\ComponentTypeCodeDomSerializer.uex'
path='docs/doc[@for="ComponentTypeCodeDomSerializer.GetInitializeMethod"]/*'
/>
       /// <devdoc>
       ///    This method returns the method to emit all of the
initialization code to for the given member.  
       ///    The default implementation returns an empty constructor.
       /// </devdoc>
       protected override CodeMemberMethod
GetInitializeMethod(IDesignerSerializationManager manager,
CodeTypeDeclaration typeDecl, object value) {
           if (manager == null) {
               throw new ArgumentNullException("manager");
           }

           if (typeDecl == null) {
               throw new ArgumentNullException("typeDecl");
           }

           if (value == null) {
               throw new ArgumentNullException("value");
           }

           CodeMemberMethod method = typeDecl.UserData[_initMethodKey] as
CodeMemberMethod;

           if (method == null) {
               method = new CodeMemberMethod();
               method.Name = _initMethodName;
               method.Attributes = MemberAttributes.Private;
               typeDecl.UserData[_initMethodKey] = method;

               // Now create a ctor that calls this method.
               CodeConstructor ctor = new CodeConstructor();

               ctor.Statements.Add(new CodeMethodInvokeExpression(new
CodeThisReferenceExpression(), _initMethodName));
               typeDecl.Members.Add(ctor);
           }

           return method;
       }

       /// <include file='doc\ComponentTypeCodeDomSerializer.uex'
path='docs/doc[@for="ComponentTypeCodeDomSerializer.GetInitializeMethods"]/*
' />
       /// <devdoc>
       ///    This method returns an array of methods that need to be
interpreted during deserialization.  
       ///    The default implementation returns a single element array
with the constructor in it.
       /// </devdoc>
       protected override CodeMemberMethod[]
GetInitializeMethods(IDesignerSerializationManager manager,
CodeTypeDeclaration typeDecl) {
           if (manager == null) {
               throw new ArgumentNullException("manager");
           }

           if (typeDecl == null) {
               throw new ArgumentNullException("typeDecl");
           }

           foreach (CodeTypeMember member in typeDecl.Members) {
               CodeMemberMethod method = member as CodeMemberMethod;

               // Note: the order is important here for performance!
               // method.Parameters causes OnMethodPopulateParameters
callback and therefore it is much more
               // expensive than method.Name.Equals

               if (method != null && method.Name.Equals(_initMethodName)
&& method.Parameters.Count == 0 ) {
                   return new CodeMemberMethod[] { method };
               }
           }

           return new CodeMemberMethod[0];
       }
   }

You'd have to do something similar in your own custom TypeCodeDomSerializer.

Hope this helps.

Sincerely,
Linda Liu
Microsoft Online Community Support

Delighting our customers is our #1 priority. We welcome your comments and
suggestions about how we can improve the support we provide to you. Please
feel free to let my manager know what you think of the level of service
provided. You can send feedback directly to my manager at:
msdnmg@microsoft.com.

This posting is provided "AS IS" with no warranties, and confers no rights.