本文章来自于msdn，对想做自动代码生成器的朋友有好处！

    1. using System;
    2. using System.Reflection;
    3. using System.IO;
    4. using System.CodeDom;
    5. using System.CodeDom.Compiler;
    6. using Microsoft.CSharp;
    8. namespace SampleCodeDom
    9. {
    10.     /// <summary>
    11.     /// This code example creates a graph using a CodeCompileUnit and  
    12.     /// generates source code for the graph using the CSharpCodeProvider.
    13.     /// </summary>
    14.     class Sample
    15.     {
    16.         /// <summary>
    17.         /// Define the compile unit to use for code generation. 
    18.         /// </summary>
    19.         CodeCompileUnit targetUnit;
    21.         /// <summary>
    22.         /// The only class in the compile unit. This class contains 2 fields,
    23.         /// 3 properties, a constructor, an entry point, and 1 simple method. 
    24.         /// </summary>
    25.         CodeTypeDeclaration targetClass;
    27.         /// <summary>
    28.         /// The name of the file to contain the source code.
    29.         /// </summary>
    30.         private const string outputFileName = "SampleCode.cs";
    32.         /// <summary>
    33.         /// Define the class.
    34.         /// </summary>
    35.         public Sample()
    36.         {
    37.             targetUnit = new CodeCompileUnit();
    38.             CodeNamespace samples = new CodeNamespace("CodeDOMSample");
    39.             samples.Imports.Add(new CodeNamespaceImport("System"));
    40.             targetClass = new CodeTypeDeclaration("CodeDOMCreatedClass");
    41.             targetClass.IsClass = true;
    42.             targetClass.TypeAttributes =
    43.                 TypeAttributes.Public | TypeAttributes.Sealed;
    44.             samples.Types.Add(targetClass);
    45.             targetUnit.Namespaces.Add(samples);
    46.         }
    48.         /// <summary>
    49.         /// Adds two fields to the class.
    50.         /// </summary>
    51.         public void AddFields()
    52.         {
    53.             // Declare the widthValue field.
    54.             CodeMemberField widthValueField = new CodeMemberField();
    55.             widthValueField.Attributes = MemberAttributes.Private;
    56.             widthValueField.Name = "widthValue";
    57.             widthValueField.Type = new CodeTypeReference(typeof(System.Double));
    58.             widthValueField.Comments.Add(new CodeCommentStatement(
    59.                 "The width of the object."));
    60.             targetClass.Members.Add(widthValueField);
    62.             // Declare the heightValue field
    63.             CodeMemberField heightValueField = new CodeMemberField();
    64.             heightValueField.Attributes = MemberAttributes.Private;
    65.             heightValueField.Name = "heightValue";
    66.             heightValueField.Type =
    67.                 new CodeTypeReference(typeof(System.Double));
    68.             heightValueField.Comments.Add(new CodeCommentStatement(
    69.                 "The height of the object."));
    70.             targetClass.Members.Add(heightValueField);
    71.         }
    72.         /// <summary>
    73.         /// Add three properties to the class.
    74.         /// </summary>
    75.         public void AddProperties()
    76.         {
    77.             // Declare the read-only Width property.
    78.             CodeMemberProperty widthProperty = new CodeMemberProperty();
    79.             widthProperty.Attributes =
    80.                 MemberAttributes.Public | MemberAttributes.Final;
    81.             widthProperty.Name = "Width";
    82.             widthProperty.HasGet = true;
    83.             widthProperty.Type = new CodeTypeReference(typeof(System.Double));
    84.             widthProperty.Comments.Add(new CodeCommentStatement(
    85.                 "The Width property for the object."));
    86.             widthProperty.GetStatements.Add(new CodeMethodReturnStatement(
    87.                 new CodeFieldReferenceExpression(
    88.                     new CodeThisReferenceExpression(), "widthValue")));
    89.             targetClass.Members.Add(widthProperty);
    91.             // Declare the read-only Height property.
    92.             CodeMemberProperty heightProperty = new CodeMemberProperty();
    93.             heightProperty.Attributes =
    94.                 MemberAttributes.Public | MemberAttributes.Final;
    95.             heightProperty.Name = "Height";
    96.             heightProperty.HasGet = true;
    97.             heightProperty.Type = new CodeTypeReference(typeof(System.Double));
    98.             heightProperty.Comments.Add(new CodeCommentStatement(
    99.                 "The Height property for the object."));
    100.             heightProperty.GetStatements.Add(new CodeMethodReturnStatement(
    101.                 new CodeFieldReferenceExpression(
    102.                     new CodeThisReferenceExpression(), "heightValue")));
    103.             targetClass.Members.Add(heightProperty);
    105.             // Declare the read only Area property.
    106.             CodeMemberProperty areaProperty = new CodeMemberProperty();
    107.             areaProperty.Attributes =
    108.                 MemberAttributes.Public | MemberAttributes.Final;
    109.             areaProperty.Name = "Area";
    110.             areaProperty.HasGet = true;
    111.             areaProperty.Type = new CodeTypeReference(typeof(System.Double));
    112.             areaProperty.Comments.Add(new CodeCommentStatement(
    113.                 "The Area property for the object."));
    115.             // Create an expression to calculate the area for the get accessor 
    116.             // of the Area property.
    117.             CodeBinaryOperatorExpression areaExpression =
    118.                 new CodeBinaryOperatorExpression(
    119.                 new CodeFieldReferenceExpression(
    120.                     new CodeThisReferenceExpression(), "widthValue"),
    121.                 CodeBinaryOperatorType.Multiply,
    122.                 new CodeFieldReferenceExpression(
    123.                     new CodeThisReferenceExpression(), "heightValue"));
    124.             areaProperty.GetStatements.Add(
    125.                 new CodeMethodReturnStatement(areaExpression));
    126.             targetClass.Members.Add(areaProperty);
    127.         }
    129.         /// <summary>
    130.         /// Adds a method to the class. This method multiplies values stored 
    131.         /// in both fields.
    132.         /// </summary>
    133.         public void AddMethod()
    134.         {
    135.             // Declaring a ToString method
    136.             CodeMemberMethod toStringMethod = new CodeMemberMethod();
    137.             toStringMethod.Attributes =
    138.                 MemberAttributes.Public | MemberAttributes.Override;
    139.             toStringMethod.Name = "ToString";
    140.             toStringMethod.ReturnType =
    141.                 new CodeTypeReference(typeof(System.String));
    143.             CodeFieldReferenceExpression widthReference =
    144.                 new CodeFieldReferenceExpression(
    145.                 new CodeThisReferenceExpression(), "Width");
    146.             CodeFieldReferenceExpression heightReference =
    147.                 new CodeFieldReferenceExpression(
    148.                 new CodeThisReferenceExpression(), "Height");
    149.             CodeFieldReferenceExpression areaReference =
    150.                 new CodeFieldReferenceExpression(
    151.                 new CodeThisReferenceExpression(), "Area");
    153.             // Declaring a return statement for method ToString.
    154.             CodeMethodReturnStatement returnStatement =
    155.                 new CodeMethodReturnStatement();
    157.             // This statement returns a string representation of the width,
    158.             // height, and area.
    159.             string formattedOutput = "The object:" + Environment.NewLine +
    160.                 " width = {0}," + Environment.NewLine +
    161.                 " height = {1}," + Environment.NewLine +
    162.                 " area = {2}";
    163.             returnStatement.Expression =
    164.                 new CodeMethodInvokeExpression(
    165.                 new CodeTypeReferenceExpression("System.String"), "Format",
    166.                 new CodePrimitiveExpression(formattedOutput),
    167.                 widthReference, heightReference, areaReference);
    168.             toStringMethod.Statements.Add(returnStatement);
    169.             targetClass.Members.Add(toStringMethod);
    170.         }
    171.         /// <summary>
    172.         /// Add a constructor to the class.
    173.         /// </summary>
    174.         public void AddConstructor()
    175.         {
    176.             // Declare the constructor
    177.             CodeConstructor constructor = new CodeConstructor();
    178.             constructor.Attributes =
    179.                 MemberAttributes.Public | MemberAttributes.Final;
    181.             // Add parameters.
    182.             constructor.Parameters.Add(new CodeParameterDeclarationExpression(
    183.                 typeof(System.Double), "width"));
    184.             constructor.Parameters.Add(new CodeParameterDeclarationExpression(
    185.                 typeof(System.Double), "height"));
    187.             // Add field initialization logic
    188.             CodeFieldReferenceExpression widthReference =
    189.                 new CodeFieldReferenceExpression(
    190.                 new CodeThisReferenceExpression(), "widthValue");
    191.             constructor.Statements.Add(new CodeAssignStatement(widthReference,
    192.                                                                new CodeArgumentReferenceExpression("width")));
    193.             CodeFieldReferenceExpression heightReference =
    194.                 new CodeFieldReferenceExpression(
    195.                 new CodeThisReferenceExpression(), "heightValue");
    196.             constructor.Statements.Add(new CodeAssignStatement(heightReference,
    197.                                                                new CodeArgumentReferenceExpression("height")));
    198.             targetClass.Members.Add(constructor);
    199.         }
    201.         /// <summary>
    202.         /// Add an entry point to the class.
    203.         /// </summary>
    204.         public void AddEntryPoint()
    205.         {
    206.             CodeEntryPointMethod start = new CodeEntryPointMethod();
    207.             CodeObjectCreateExpression objectCreate =
    208.                 new CodeObjectCreateExpression(
    209.                 new CodeTypeReference("CodeDOMCreatedClass"),
    210.                 new CodePrimitiveExpression(5.3),
    211.                 new CodePrimitiveExpression(6.9));
    213.             // Add the statement:
    214.             // "CodeDOMCreatedClass testClass = 
    215.             //     new CodeDOMCreatedClass(5.3, 6.9);"
    216.             start.Statements.Add(new CodeVariableDeclarationStatement(
    217.                 new CodeTypeReference("CodeDOMCreatedClass"), "testClass",
    218.                 objectCreate));
    220.             // Creat the expression:
    221.             // "testClass.ToString()"
    222.             CodeMethodInvokeExpression toStringInvoke =
    223.                 new CodeMethodInvokeExpression(
    224.                 new CodeVariableReferenceExpression("testClass"), "ToString");
    226.             // Add a System.Console.WriteLine statement with the previous 
    227.             // expression as a parameter.
    228.             start.Statements.Add(new CodeMethodInvokeExpression(
    229.                 new CodeTypeReferenceExpression("System.Console"),
    230.                 "WriteLine", toStringInvoke));
    231.             targetClass.Members.Add(start);
    232.         }
    233.         /// <summary>
    234.         /// Generate CSharp source code from the compile unit.
    235.         /// </summary>
    236.         /// <param name="filename">Output file name</param>
    237.         public void GenerateCSharpCode(string fileName)
    238.         {
    239.             CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
    240.             CodeGeneratorOptions options = new CodeGeneratorOptions();
    241.             options.BracingStyle = "C";
    242.             using (StreamWriter sourceWriter = new StreamWriter(fileName))
    243.             {
    244.                 provider.GenerateCodeFromCompileUnit(
    245.                     targetUnit, sourceWriter, options);
    246.             }
    247.         }
    249.         /// <summary>
    250.         /// Create the CodeDOM graph and generate the code.
    251.         /// </summary>
    252.         static void Main()
    253.         {
    254.             Sample sample = new Sample();
    255.             sample.AddFields();
    256.             sample.AddProperties();
    257.             sample.AddMethod();
    258.             sample.AddConstructor();
    259.             sample.AddEntryPoint();
    260.             sample.GenerateCSharpCode(outputFileName);
    261.         }
    262.     }
    263. }