How to: Create a Class Using CodeDOM

The following procedures illustrate how to create and compile a CodeDOM graph that generates a class containing two fields, three properties, a method, a constructor, and an entry point.

  1. Create a console application that will use CodeDOM code to generate the source code for a class.

    In this example, the generating class is named Sample, and the generated code is a class named CodeDOMCreatedClass in a file named SampleCode.

  2. In the generating class, initialize the CodeDOM graph and use CodeDOM methods to define the members, constructor, and entry point (Main method) of the generated class.

    In this example, the generated class has two fields, three properties, a constructor, a method, and a Main method.

  3. In the generating class, create a language-specific code provider and call its GenerateCodeFromCompileUnit method to generate the code from the graph.

  4. Compile and execute the application to generate the code.

    In this example, the generated code is in a file named SampleCode. Compile and execute that code to see the sample output.

To create the application that will execute the CodeDOM code

  • Create a console application class to contain the CodeDOM code. Define the global fields that are to be used in the class to reference the assembly (CodeCompileUnit) and class (CodeTypeDeclaration), specify the name of the generated source file, and declare the Main method.

    using System;
    using System.Reflection;
    using System.IO;
    using System.CodeDom;
    using System.CodeDom.Compiler;
    using Microsoft.CSharp;
    
    namespace SampleCodeDom
    {
        class Sample
        {
            CodeCompileUnit targetUnit;
            CodeTypeDeclaration targetClass;
            private const string outputFileName = "SampleCode.cs";
            static void Main(string[] args)
            {
            }
        }
    }
    

To initialize the CodeDOM graph

  • In the constructor for the console application class, initialize the assembly and class, and add the appropriate declarations to the CodeDOM graph.

    public Sample()
    {
        targetUnit = new CodeCompileUnit();
        CodeNamespace samples = new CodeNamespace("CodeDOMSample");
        samples.Imports.Add(new CodeNamespaceImport("System"));
        targetClass = new CodeTypeDeclaration("CodeDOMCreatedClass");
        targetClass.IsClass = true;
        targetClass.TypeAttributes =
            TypeAttributes.Public | TypeAttributes.Sealed;
        samples.Types.Add(targetClass);
        targetUnit.Namespaces.Add(samples);
    }
    

To add members to the CodeDOM graph

  • Add fields to the CodeDOM graph by adding CodeMemberField objects to the Members property of the class.

    public void AddFields()
    {
        // Declare the widthValue field.
        CodeMemberField widthValueField = new CodeMemberField();
        widthValueField.Attributes = MemberAttributes.Private;
        widthValueField.Name = "widthValue";
        widthValueField.Type = new CodeTypeReference(typeof(System.Double));
        widthValueField.Comments.Add(new CodeCommentStatement(
            "The width of the object."));
        targetClass.Members.Add(widthValueField);
    
        // Declare the heightValue field
        CodeMemberField heightValueField = new CodeMemberField();
        heightValueField.Attributes = MemberAttributes.Private;
        heightValueField.Name = "heightValue";
        heightValueField.Type =
            new CodeTypeReference(typeof(System.Double));
        heightValueField.Comments.Add(new CodeCommentStatement(
            "The height of the object."));
        targetClass.Members.Add(heightValueField);
    }
    
  • Add properties to the CodeDOM graph by adding CodeMemberProperty objects to the Members property of the class.

    public void AddProperties()
    {
        // Declare the read-only Width property.
        CodeMemberProperty widthProperty = new CodeMemberProperty();
        widthProperty.Attributes =
            MemberAttributes.Public | MemberAttributes.Final;
        widthProperty.Name = "Width";
        widthProperty.HasGet = true;
        widthProperty.Type = new CodeTypeReference(typeof(System.Double));
        widthProperty.Comments.Add(new CodeCommentStatement(
            "The Width property for the object."));
        widthProperty.GetStatements.Add(new CodeMethodReturnStatement(
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "widthValue")));
        targetClass.Members.Add(widthProperty);
    
        // Declare the read-only Height property.
        CodeMemberProperty heightProperty = new CodeMemberProperty();
        heightProperty.Attributes =
            MemberAttributes.Public | MemberAttributes.Final;
        heightProperty.Name = "Height";
        heightProperty.HasGet = true;
        heightProperty.Type = new CodeTypeReference(typeof(System.Double));
        heightProperty.Comments.Add(new CodeCommentStatement(
            "The Height property for the object."));
        heightProperty.GetStatements.Add(new CodeMethodReturnStatement(
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "heightValue")));
        targetClass.Members.Add(heightProperty);
    
        // Declare the read only Area property.
        CodeMemberProperty areaProperty = new CodeMemberProperty();
        areaProperty.Attributes =
            MemberAttributes.Public | MemberAttributes.Final;
        areaProperty.Name = "Area";
        areaProperty.HasGet = true;
        areaProperty.Type = new CodeTypeReference(typeof(System.Double));
        areaProperty.Comments.Add(new CodeCommentStatement(
            "The Area property for the object."));
    
        // Create an expression to calculate the area for the get accessor  
        // of the Area property.
        CodeBinaryOperatorExpression areaExpression =
            new CodeBinaryOperatorExpression(
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "widthValue"),
            CodeBinaryOperatorType.Multiply,
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "heightValue"));
        areaProperty.GetStatements.Add(
            new CodeMethodReturnStatement(areaExpression));
        targetClass.Members.Add(areaProperty);
    }
    
  • Add a method to the CodeDOM graph by adding a CodeMemberMethod object to the Members property of the class.

    public void AddMethod()
    {
        // Declaring a ToString method
        CodeMemberMethod toStringMethod = new CodeMemberMethod();
        toStringMethod.Attributes =
            MemberAttributes.Public | MemberAttributes.Override;
        toStringMethod.Name = "ToString";
        toStringMethod.ReturnType =
            new CodeTypeReference(typeof(System.String));
    
        CodeFieldReferenceExpression widthReference =
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "Width");
        CodeFieldReferenceExpression heightReference =
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "Height");
        CodeFieldReferenceExpression areaReference =
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "Area");
    
        // Declaring a return statement for method ToString.
        CodeMethodReturnStatement returnStatement =
            new CodeMethodReturnStatement();
    
        // This statement returns a string representation of the width, 
        // height, and area. 
        string formattedOutput = "The object:" + Environment.NewLine +
            " width = {0}," + Environment.NewLine +
            " height = {1}," + Environment.NewLine +
            " area = {2}";
        returnStatement.Expression =
            new CodeMethodInvokeExpression(
            new CodeTypeReferenceExpression("System.String"), "Format",
            new CodePrimitiveExpression(formattedOutput),
            widthReference, heightReference, areaReference);
        toStringMethod.Statements.Add(returnStatement);
        targetClass.Members.Add(toStringMethod);
    }
    
  • Add a constructor to the CodeDOM graph by adding a CodeConstructor object to the Members property of the class.

    public void AddConstructor()
    {
        // Declare the constructor
        CodeConstructor constructor = new CodeConstructor();
        constructor.Attributes =
            MemberAttributes.Public | MemberAttributes.Final;
    
        // Add parameters.
        constructor.Parameters.Add(new CodeParameterDeclarationExpression(
            typeof(System.Double), "width"));
        constructor.Parameters.Add(new CodeParameterDeclarationExpression(
            typeof(System.Double), "height"));
    
        // Add field initialization logic
        CodeFieldReferenceExpression widthReference =
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "widthValue");
        constructor.Statements.Add(new CodeAssignStatement(widthReference,
            new CodeArgumentReferenceExpression("width")));
        CodeFieldReferenceExpression heightReference =
            new CodeFieldReferenceExpression(
            new CodeThisReferenceExpression(), "heightValue");
        constructor.Statements.Add(new CodeAssignStatement(heightReference,
            new CodeArgumentReferenceExpression("height")));
        targetClass.Members.Add(constructor);
    }
    
  • Add an entry point to the CodeDOM graph by adding a CodeEntryPointMethod object to the Members property of the class.

    public void AddEntryPoint()
    {
        CodeEntryPointMethod start = new CodeEntryPointMethod();
        CodeObjectCreateExpression objectCreate =
            new CodeObjectCreateExpression(
            new CodeTypeReference("CodeDOMCreatedClass"),
            new CodePrimitiveExpression(5.3),
            new CodePrimitiveExpression(6.9));
    
        // Add the statement: 
        // "CodeDOMCreatedClass testClass =  
        //     new CodeDOMCreatedClass(5.3, 6.9);"
        start.Statements.Add(new CodeVariableDeclarationStatement(
            new CodeTypeReference("CodeDOMCreatedClass"), "testClass",
            objectCreate));
    
        // Creat the expression: 
        // "testClass.ToString()"
        CodeMethodInvokeExpression toStringInvoke =
            new CodeMethodInvokeExpression(
            new CodeVariableReferenceExpression("testClass"), "ToString");
    
        // Add a System.Console.WriteLine statement with the previous  
        // expression as a parameter.
        start.Statements.Add(new CodeMethodInvokeExpression(
            new CodeTypeReferenceExpression("System.Console"),
            "WriteLine", toStringInvoke));
        targetClass.Members.Add(start);
    }
    

To generate the code from the CodeDOM graph

  • Generate source code from the CodeDOM graph by calling the GenerateCodeFromCompileUnit method.

    public void GenerateCSharpCode(string fileName)
    {
        CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
        CodeGeneratorOptions options = new CodeGeneratorOptions();
        options.BracingStyle = "C";
        using (StreamWriter sourceWriter = new StreamWriter(fileName))
        {
            provider.GenerateCodeFromCompileUnit(
                targetUnit, sourceWriter, options);
        }
    }
    

To create the graph and generate the code

  1. Add the methods created in the preceding steps to the Main method defined in the first step.

    static void Main()
    {
        Sample sample = new Sample();
        sample.AddFields();
        sample.AddProperties();
        sample.AddMethod();
        sample.AddConstructor();
        sample.AddEntryPoint();
        sample.GenerateCSharpCode(outputFileName);
    }
    
  2. Compile and execute the generating class.

The following code example shows the code from the preceding steps.

using System;
using System.Reflection;
using System.IO;
using System.CodeDom;
using System.CodeDom.Compiler;
using Microsoft.CSharp;

namespace SampleCodeDom
{
    /// <summary> 
    /// This code example creates a graph using a CodeCompileUnit and   
    /// generates source code for the graph using the CSharpCodeProvider. 
    /// </summary> 
    class Sample
    {
        /// <summary> 
        /// Define the compile unit to use for code generation.  
        /// </summary>
        CodeCompileUnit targetUnit;

        /// <summary> 
        /// The only class in the compile unit. This class contains 2 fields, 
        /// 3 properties, a constructor, an entry point, and 1 simple method.  
        /// </summary>
        CodeTypeDeclaration targetClass;

        /// <summary> 
        /// The name of the file to contain the source code. 
        /// </summary> 
        private const string outputFileName = "SampleCode.cs";

        /// <summary> 
        /// Define the class. 
        /// </summary> 
        public Sample()
        {
            targetUnit = new CodeCompileUnit();
            CodeNamespace samples = new CodeNamespace("CodeDOMSample");
            samples.Imports.Add(new CodeNamespaceImport("System"));
            targetClass = new CodeTypeDeclaration("CodeDOMCreatedClass");
            targetClass.IsClass = true;
            targetClass.TypeAttributes =
                TypeAttributes.Public | TypeAttributes.Sealed;
            samples.Types.Add(targetClass);
            targetUnit.Namespaces.Add(samples);
        }

        /// <summary> 
        /// Adds two fields to the class. 
        /// </summary> 
        public void AddFields()
        {
            // Declare the widthValue field.
            CodeMemberField widthValueField = new CodeMemberField();
            widthValueField.Attributes = MemberAttributes.Private;
            widthValueField.Name = "widthValue";
            widthValueField.Type = new CodeTypeReference(typeof(System.Double));
            widthValueField.Comments.Add(new CodeCommentStatement(
                "The width of the object."));
            targetClass.Members.Add(widthValueField);

            // Declare the heightValue field
            CodeMemberField heightValueField = new CodeMemberField();
            heightValueField.Attributes = MemberAttributes.Private;
            heightValueField.Name = "heightValue";
            heightValueField.Type =
                new CodeTypeReference(typeof(System.Double));
            heightValueField.Comments.Add(new CodeCommentStatement(
                "The height of the object."));
            targetClass.Members.Add(heightValueField);
        }
        /// <summary> 
        /// Add three properties to the class. 
        /// </summary> 
        public void AddProperties()
        {
            // Declare the read-only Width property.
            CodeMemberProperty widthProperty = new CodeMemberProperty();
            widthProperty.Attributes =
                MemberAttributes.Public | MemberAttributes.Final;
            widthProperty.Name = "Width";
            widthProperty.HasGet = true;
            widthProperty.Type = new CodeTypeReference(typeof(System.Double));
            widthProperty.Comments.Add(new CodeCommentStatement(
                "The Width property for the object."));
            widthProperty.GetStatements.Add(new CodeMethodReturnStatement(
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "widthValue")));
            targetClass.Members.Add(widthProperty);

            // Declare the read-only Height property.
            CodeMemberProperty heightProperty = new CodeMemberProperty();
            heightProperty.Attributes =
                MemberAttributes.Public | MemberAttributes.Final;
            heightProperty.Name = "Height";
            heightProperty.HasGet = true;
            heightProperty.Type = new CodeTypeReference(typeof(System.Double));
            heightProperty.Comments.Add(new CodeCommentStatement(
                "The Height property for the object."));
            heightProperty.GetStatements.Add(new CodeMethodReturnStatement(
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "heightValue")));
            targetClass.Members.Add(heightProperty);

            // Declare the read only Area property.
            CodeMemberProperty areaProperty = new CodeMemberProperty();
            areaProperty.Attributes =
                MemberAttributes.Public | MemberAttributes.Final;
            areaProperty.Name = "Area";
            areaProperty.HasGet = true;
            areaProperty.Type = new CodeTypeReference(typeof(System.Double));
            areaProperty.Comments.Add(new CodeCommentStatement(
                "The Area property for the object."));

            // Create an expression to calculate the area for the get accessor  
            // of the Area property.
            CodeBinaryOperatorExpression areaExpression =
                new CodeBinaryOperatorExpression(
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "widthValue"),
                CodeBinaryOperatorType.Multiply,
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "heightValue"));
            areaProperty.GetStatements.Add(
                new CodeMethodReturnStatement(areaExpression));
            targetClass.Members.Add(areaProperty);
        }

        /// <summary> 
        /// Adds a method to the class. This method multiplies values stored  
        /// in both fields. 
        /// </summary> 
        public void AddMethod()
        {
            // Declaring a ToString method
            CodeMemberMethod toStringMethod = new CodeMemberMethod();
            toStringMethod.Attributes =
                MemberAttributes.Public | MemberAttributes.Override;
            toStringMethod.Name = "ToString";
            toStringMethod.ReturnType =
                new CodeTypeReference(typeof(System.String));

            CodeFieldReferenceExpression widthReference =
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "Width");
            CodeFieldReferenceExpression heightReference =
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "Height");
            CodeFieldReferenceExpression areaReference =
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "Area");

            // Declaring a return statement for method ToString.
            CodeMethodReturnStatement returnStatement =
                new CodeMethodReturnStatement();

            // This statement returns a string representation of the width, 
            // height, and area. 
            string formattedOutput = "The object:" + Environment.NewLine +
                " width = {0}," + Environment.NewLine +
                " height = {1}," + Environment.NewLine +
                " area = {2}";
            returnStatement.Expression =
                new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("System.String"), "Format",
                new CodePrimitiveExpression(formattedOutput),
                widthReference, heightReference, areaReference);
            toStringMethod.Statements.Add(returnStatement);
            targetClass.Members.Add(toStringMethod);
        }
        /// <summary> 
        /// Add a constructor to the class. 
        /// </summary> 
        public void AddConstructor()
        {
            // Declare the constructor
            CodeConstructor constructor = new CodeConstructor();
            constructor.Attributes =
                MemberAttributes.Public | MemberAttributes.Final;

            // Add parameters.
            constructor.Parameters.Add(new CodeParameterDeclarationExpression(
                typeof(System.Double), "width"));
            constructor.Parameters.Add(new CodeParameterDeclarationExpression(
                typeof(System.Double), "height"));

            // Add field initialization logic
            CodeFieldReferenceExpression widthReference =
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "widthValue");
            constructor.Statements.Add(new CodeAssignStatement(widthReference,
                new CodeArgumentReferenceExpression("width")));
            CodeFieldReferenceExpression heightReference =
                new CodeFieldReferenceExpression(
                new CodeThisReferenceExpression(), "heightValue");
            constructor.Statements.Add(new CodeAssignStatement(heightReference,
                new CodeArgumentReferenceExpression("height")));
            targetClass.Members.Add(constructor);
        }

        /// <summary> 
        /// Add an entry point to the class. 
        /// </summary> 
        public void AddEntryPoint()
        {
            CodeEntryPointMethod start = new CodeEntryPointMethod();
            CodeObjectCreateExpression objectCreate =
                new CodeObjectCreateExpression(
                new CodeTypeReference("CodeDOMCreatedClass"),
                new CodePrimitiveExpression(5.3),
                new CodePrimitiveExpression(6.9));

            // Add the statement: 
            // "CodeDOMCreatedClass testClass =  
            //     new CodeDOMCreatedClass(5.3, 6.9);"
            start.Statements.Add(new CodeVariableDeclarationStatement(
                new CodeTypeReference("CodeDOMCreatedClass"), "testClass",
                objectCreate));

            // Creat the expression: 
            // "testClass.ToString()"
            CodeMethodInvokeExpression toStringInvoke =
                new CodeMethodInvokeExpression(
                new CodeVariableReferenceExpression("testClass"), "ToString");

            // Add a System.Console.WriteLine statement with the previous  
            // expression as a parameter.
            start.Statements.Add(new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("System.Console"),
                "WriteLine", toStringInvoke));
            targetClass.Members.Add(start);
        }
        /// <summary> 
        /// Generate CSharp source code from the compile unit. 
        /// </summary> 
        /// <param name="filename">Output file name</param>
        public void GenerateCSharpCode(string fileName)
        {
            CodeDomProvider provider = CodeDomProvider.CreateProvider("CSharp");
            CodeGeneratorOptions options = new CodeGeneratorOptions();
            options.BracingStyle = "C";
            using (StreamWriter sourceWriter = new StreamWriter(fileName))
            {
                provider.GenerateCodeFromCompileUnit(
                    targetUnit, sourceWriter, options);
            }
        }

        /// <summary> 
        /// Create the CodeDOM graph and generate the code. 
        /// </summary> 
        static void Main()
        {
            Sample sample = new Sample();
            sample.AddFields();
            sample.AddProperties();
            sample.AddMethod();
            sample.AddConstructor();
            sample.AddEntryPoint();
            sample.GenerateCSharpCode(outputFileName);
        }
    }
}

When the preceding example is compiled and executed, it produces the following source code.

//-------------------------------------------------------------------------- 
// <auto-generated> 
//     This code was generated by a tool. 
//     Runtime Version:2.0.50727.42 
// 
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated. 
// </auto-generated> 
//-------------------------------------------------------------------------- 

namespace CodeDOMSample
{
    using System;


    public sealed class CodeDOMCreatedClass
    {

        // The width of the object. 
        private double widthValue;

        // The height of the object. 
        private double heightValue;

        public CodeDOMCreatedClass(double width, double height)
        {
            this.widthValue = width;
            this.heightValue = height;
        }

        // The Width property for the object. 
        public double Width
        {
            get
            {
                return this.widthValue;
            }
        }

        // The Height property for the object. 
        public double Height
        {
            get
            {
                return this.heightValue;
            }
        }

        // The Area property for the object. 
        public double Area
        {
            get
            {
                return (this.widthValue * this.heightValue);
            }
        }

        public override string ToString()
        {
            return string.Format(
                "The object:\r\n width = {0},\r\n height = {1},\r\n area = {2}", 
                this.Width, this.Height, this.Area);
        }

        public static void Main()
        {
            CodeDOMCreatedClass testClass = new CodeDOMCreatedClass(5.3, 6.9);
            System.Console.WriteLine(testClass.ToString());
        }
    }
}

The generated source code produces the following output when compiled and executed.

The object:
 width = 5.3,
 height = 6.9,
 area = 36.57

  • This code example requires the FullTrust permission set to execute successfully.

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft