使用codeDom ---namespace 动态的生成.net代码

using System;

using System.CodeDom;

using System.CodeDom.Compiler;

using System.Reflection;

using System.IO;

using Microsoft.CSharp;

using Microsoft.VisualBasic;

namespace CodeDomPartOne

{

///

/// Summary description for Briefcase.

///

public class Briefcase

{

// Member Variables

private string m_strFileName;

private string m_Suffix = " .cs " ;

public Briefcase( string strFileName)

{

m_strFileName = strFileName;

}

public static void Main()

{

Briefcase dd = new Briefcase( " my " );

dd.CreateCodeDomBriefcase();

}

public void CreateCodeDomBriefcase()

{

// Initialize CodeDom Variables

Stream s = File.Open( " c:\\ " + m_strFileName + m_Suffix, FileMode.Create);

StreamWriter sw = new StreamWriter(s);

CSharpCodeProvider cscProvider = new CSharpCodeProvider();

ICodeGenerator cscg = cscProvider.CreateGenerator(sw);

CodeGeneratorOptions cop = new CodeGeneratorOptions();

// Create Class Using Statements

CodeSnippetCompileUnit csu1 = new CodeSnippetCompileUnit( " using System " );

CodeSnippetCompileUnit csu2 = new CodeSnippetCompileUnit( " using System.IO " );

cscg.GenerateCodeFromCompileUnit(csu1, sw, cop);

cscg.GenerateCodeFromCompileUnit(csu2, sw, cop);

sw.WriteLine();

// Create Class Namespaces

CodeNamespace cnsCodeDom = new CodeNamespace( " CodeDom " );

// Create Class Declaration

CodeTypeDeclaration ctd = new CodeTypeDeclaration();

ctd.IsClass = true ;

ctd.Name = " Briefcase " ;

ctd.TypeAttributes = TypeAttributes.Public;

// Create Class Member Fields

sw.WriteLine();

CodeMemberField cmfBriefcaseName = new CodeMemberField( " string " , " m_BriefcaseName " );

cmfBriefcaseName.Attributes = MemberAttributes.Private;

ctd.Members.Add(cmfBriefcaseName);

CodeMemberField cmfBriefcaseTitle = new CodeMemberField( " string " , " m_BriefcaseTitle " );

cmfBriefcaseTitle.Attributes = MemberAttributes.Private;

ctd.Members.Add(cmfBriefcaseTitle);

CodeMemberField cmfBriefcaseID = new CodeMemberField( " int " , " m_cmfBriefcaseID " );

cmfBriefcaseID.Attributes = MemberAttributes.Private;

ctd.Members.Add(cmfBriefcaseID);

CodeMemberField cmfBriefcaseSectionID = new CodeMemberField( " int " , " m_BriefcaseSectionID " );

cmfBriefcaseSectionID.Attributes = MemberAttributes.Private;

ctd.Members.Add(cmfBriefcaseSectionID);

CodeMemberField cmfBriefcaseFolderID = new CodeMemberField( " int " , " m_BriefcaseFolderID " );

cmfBriefcaseFolderID.Attributes = MemberAttributes.Private;

ctd.Members.Add(cmfBriefcaseFolderID);

CodeMemberField cmfBriefcaseItemID = new CodeMemberField( " int " , " m_BriefcaseItemID " );

cmfBriefcaseItemID.Attributes = MemberAttributes.Private;

ctd.Members.Add(cmfBriefcaseItemID);

// Create Class Constructor

CodeConstructor ccon = new CodeConstructor();

ccon.Attributes = MemberAttributes.Public;

ccon.Statements.Add( new CodeSnippetStatement( " // " ));

ccon.Statements.Add( new CodeSnippetStatement( " // TODO: Add constructor logic here " ));

ccon.Statements.Add( new CodeSnippetStatement( " // " ));

ctd.Members.Add(ccon);

// 85: // Create Class BriefcaseName Property

// 86: CodeMemberProperty mpBriefcaseName = new CodeMemberProperty();

// 87: mpBriefcaseName.Attributes = MemberAttributes.Private;

// 88: mpBriefcaseName.Type = new CodeTypeReference("string");

// 89: mpBriefcaseName.Name = "BriefcaseName";

// 90: mpBriefcaseName.HasGet = true;

// 91: mpBriefcaseName.GetStatements.Add(new CodeSnippetExpression("return m_BriefcaseName"));

// 92: mpBriefcaseName.HasSet = true;

// 93: mpBriefcaseName.SetStatements.Add(new CodeSnippetExpression("m_BriefcaseName = value"));

// 94: ctd.Members.Add(mpBriefcaseName);

// 95:

// 96: // Create Class BriefcaseTitle Property

// 97: CodeMemberProperty mpBriefcaseTitle = new CodeMemberProperty();

// 98: mpBriefcaseTitle.Attributes = MemberAttributes.Private;

// 99: mpBriefcaseTitle.Type = new CodeTypeReference("string");

// 100: mpBriefcaseTitle.Name = "BriefcaseTitle";

// 101: mpBriefcaseTitle.HasGet = true;

// 102: mpBriefcaseTitle.GetStatements.Add(new CodeSnippetExpression("return m_BriefcaseTitle"));

// 103: mpBriefcaseTitle.HasSet = true;

// 104: mpBriefcaseTitle.SetStatements.Add(new CodeSnippetExpression("m_BriefcaseTitle = value"));

// 105: ctd.Members.Add(mpBriefcaseTitle);

// 106:

// 107: // Create Class BriefcaseID Property

// 108: CodeMemberProperty mpBriefcaseID = new CodeMemberProperty();

// 109: mpBriefcaseID.Attributes = MemberAttributes.Private;

// 110: mpBriefcaseID.Type = new CodeTypeReference("int");

// 111: mpBriefcaseID.Name = "BriefcaseID";

// 112: mpBriefcaseID.HasGet = true;

// 113: mpBriefcaseID.GetStatements.Add(new CodeSnippetExpression("m_BriefcaseID"));

// 114: mpBriefcaseID.HasSet = true;

// 115: mpBriefcaseID.SetStatements.Add(new CodeSnippetExpression("m_BriefcaseID = value"));

// 116: ctd.Members.Add(mpBriefcaseID);

// 117:

// 118: // Create Class BriefcaseSection Property

// 119: CodeMemberProperty mpBriefcaseSection = new CodeMemberProperty();

// 120: mpBriefcaseSection.Attributes = MemberAttributes.Private;

// 121: mpBriefcaseSection.Type = new CodeTypeReference("int");

// 122: mpBriefcaseSection.Name = "BriefcaseSection";

// 123: mpBriefcaseSection.HasGet = true;

// 124: mpBriefcaseSection.GetStatements.Add(new CodeSnippetExpression

// 125: ("return m_BriefcaseSectionID"));

// 126: mpBriefcaseSection.HasSet = true;

// 127: mpBriefcaseSection.SetStatements.Add(new CodeSnippetExpression

// 128: ("m_BriefcaseSectionID = value"));

// 129: ctd.Members.Add(mpBriefcaseSection);

// Create Class BriefcaseFolder Property

CodeMemberProperty mpBriefcaseFolder = new CodeMemberProperty();

mpBriefcaseFolder.Attributes = MemberAttributes.Private;

mpBriefcaseFolder.Type = new CodeTypeReference( " int " );

mpBriefcaseFolder.Name = " BriefcaseFolder " ;

mpBriefcaseFolder.HasGet = true ;

mpBriefcaseFolder.GetStatements.Add( new CodeSnippetExpression( " return m_BriefcaseFlderID " ));

mpBriefcaseFolder.HasSet = true ;

mpBriefcaseFolder.SetStatements.Add( new CodeSnippetExpression( " m_BriefcaseFolderID = value " ));

ctd.Members.Add(mpBriefcaseFolder);

// Create Class BriefcaseItem Property

CodeMemberProperty mpBriefcaseItem = new CodeMemberProperty();

mpBriefcaseItem.Attributes = MemberAttributes.Private;

mpBriefcaseItem.Type = new CodeTypeReference( " string " );

mpBriefcaseItem.Name = " BriefcaseItem " ;

mpBriefcaseItem.HasGet = true ;

mpBriefcaseItem.GetStatements.Add( new CodeSnippetExpression( " return m_BriefcaseItemID " ));

mpBriefcaseItem.HasSet = true ;

mpBriefcaseItem.SetStatements.Add( new CodeSnippetExpression( " m_BriefcaseItemID = value " ));

ctd.Members.Add(mpBriefcaseItem);

// Create Class GetBriefcaseName Method

CodeMemberMethod mtd1 = new CodeMemberMethod();

mtd1.Name = " GetBriefcaseName " ;

mtd1.ReturnType = new CodeTypeReference( " String " );

mtd1.Attributes = MemberAttributes.Public;

mtd1.Statements.Add( new CodeSnippetStatement( " return BriefcaseName; " ));

ctd.Members.Add(mtd1);

// Create Class GetBriefcaseTitle Method

CodeMemberMethod mtd2 = new CodeMemberMethod();

mtd2.Name = " GetBriefcaseTitle " ;

mtd2.ReturnType = new CodeTypeReference( " String " );

mtd2.Attributes = MemberAttributes.Public;

mtd2.Statements.Add( new CodeSnippetStatement( " return BriefcaseTitle; " ));

ctd.Members.Add(mtd2);

// Create Class GetBriefcaseID Method

CodeMemberMethod mtd3 = new CodeMemberMethod();

mtd3.Name = " GetBriefcaseID " ;

mtd3.ReturnType = new CodeTypeReference( " Int " );

mtd3.Attributes = MemberAttributes.Public;

mtd3.Statements.Add( new CodeSnippetStatement( " return BriefcaseID; " ));

ctd.Members.Add(mtd3);

// Create Class GetBriefcaseSection Method

CodeMemberMethod mtd4 = new CodeMemberMethod();

mtd4.Name = " GetBriefcaseSectionID " ;

mtd4.ReturnType = new CodeTypeReference( " Int " );

mtd4.Attributes = MemberAttributes.Public;

mtd4.Statements.Add( new CodeSnippetStatement( " return BriefcaseSectionID; " ));

ctd.Members.Add(mtd4);

// Create Class GetBriefcaseFolder Method

CodeMemberMethod mtd5 = new CodeMemberMethod();

mtd5.Name = " GetBriefcaseFolderID " ;

mtd5.ReturnType = new CodeTypeReference( " Int " );

mtd5.Attributes = MemberAttributes.Public;

mtd5.Statements.Add( new CodeSnippetStatement( " return BriefcaseFolderID; " ));

ctd.Members.Add(mtd5);

// Create Class GetBriefcaseItem Method

CodeMemberMethod mtd6 = new CodeMemberMethod();

mtd6.Name = " GetBriefcaseItemID " ;

mtd6.ReturnType = new CodeTypeReference( " Int " );

mtd6.Attributes = MemberAttributes.Public;

mtd6.Statements.Add( new CodeSnippetStatement( " return BriefcaseItemID; " ));

ctd.Members.Add(mtd6);

// Generate Source Code File

cnsCodeDom.Types.Add(ctd);

cscg.GenerateCodeFromNamespace(cnsCodeDom, sw, cop);

// cscg.GenerateCodeFromType(ctd,sw,cop);

// Close StreamWriter

sw.Close();

s.Close();

}

由以上代码生成:

using System

using System.IO

namespace CodeDom {

public class Briefcase

{

private @string m_BriefcaseName;

private @string m_BriefcaseTitle;

private @int m_cmfBriefcaseID;

private @int m_BriefcaseSectionID;

private @int m_BriefcaseFolderID;

private @int m_BriefcaseItemID;

public Briefcase()

{

}

private @int BriefcaseFolder

{

get {

return m_BriefcaseFlderID;

}

set {

m_BriefcaseFolderID = value;

}

private @string BriefcaseItem

{

get {

return m_BriefcaseItemID;

}

set {

m_BriefcaseItemID = value;

}

public virtual String GetBriefcaseName()

{

return BriefcaseName;

}

public virtual String GetBriefcaseTitle()

{

return BriefcaseTitle;

}

public virtual Int GetBriefcaseID()

{

return BriefcaseID;

}

public virtual Int GetBriefcaseSectionID()

{

return BriefcaseSectionID;

}

public virtual Int GetBriefcaseFolderID()

{

return BriefcaseFolderID;

}

public virtual Int GetBriefcaseItemID()

{

return BriefcaseItemID;

}

Advantages of CodeDom Technology

The CodeDom namespaces in the .NET Framework provide these advantages:

The CodeDom is based upon a single model for rendering source code. Therefore, source code may be generated for any language that supports the CodeDom specification.
The CodeDom allows programs to be dynamically created, compiled, and executed at runtime.
The CodeDom provides a language independent object model for representing the structure of source code in memory.
Future releases of the CodeDom could translate source code files between languages a lot like graphic file converter programs do with graphics files today. For example, a VB.NET program could be represented by the CodeDom then translated into C# for another developer. Cool huh?

Limitations of CodeDom Technology

The CodeDom namespaces contain classes to conceptually represent most programming constructs. Examples of these include: declarations, statements, iterations, arrays, casts, comments, error handling, and others. However, there are limitations to the current implementation of the CodeDom which will remain until the CodeDom namespaces are updated by Microsoft. In the meanwhile, to represent constructs not presently supported in CodeDom you can use the "Snippet" classes. These classes allow you to insert literal lines of source code into a compile unit. The classes available for handling snippets include: the CodeSnippetCompileUnit, CodeSnippetExpression, CodeSnippetStatement, and CodeSnippetTypeMember classes. You can use the snippet classes as a generic "catch all" for implementing presently unsupported programming constructs in the CodeDom. As the CodeDom namespaces are enhanced by Microsoft, you should not need to rely as heavily upon the snippet classes. As with any new technology, there are limitations to its functionality - CodeDom technology is no exception. We will look at four useful programming constructs not presently supported by the CodeDom. There are many more examples of missing constructs unsupported by the current implementation of CodeDom, but these should give you an idea of the enhancements forthcoming in the CodeDom namespaces.

Limitation #1: There is no support for aliasing a namespace.


         namespace MyNamespace
     {
          public void MyClass
          {
          }
     }
     namespace MyNamespace2
     {
          using MyAlias = MyNamespace.MyClass;
          public void MyClass2 : MyAlias
          {
          }
             }

Limitation #2: There is no support for nested namespaces.

namespace OutterNamespace
     {
          namespace InnerNamespace
          {
               public void MyClass
               {
               }
          }
      }

Limitation #3: There is no support for variable declaration lists.


     using System;
      using System.CodeDom;
      using System.CodeDom.Compiler;

      namespace MyNamespace
      {
          public void MyClass
          {
              public void MyClass()
              {
                  int i,j,k;
                  bool blnYes, blnNo;
              }
          }
      }

Limitation #4: There is no support for the "unsafe" modifier in C#.


     using System;

      class MyUnsafeClass
      {
         unsafe static void MyPointerFn(int* ptr)
          {
              *p *= *p;
          {
      {
      unsafe public static void main()
      {
           //unsafe operation using address-of operator &
           int i = 10;
           MyPointerFn(&i);
           Console.WriteLine(i);
      }

System.CodeDom Namespace Overview

The System.CodeDom Namespace contains classes, interfaces and enumerations to represent source code trees in memory. Each source code tree is called a CompileUnit. CompileUnits are linked together to form a tree structure in memory representing the structure of the source code. Remember our discussion on trees? Each CodeDom class is analogous to a node in the source tree. Each CodeDom node contains data which is used by the ICodeGenerator Interface later on. The ICodeGenerator Interface is what receives the Compile Units and outputs source code in the designated language. Compile Units are the key to understanding how the CodeDom creates the internal representation of the source code in memory.

System.CodeDom Enumerations
CodeBinaryOperatorType	Specifies identifiers for supported binary operators.
FieldDirection	Specifies identifiers used to indicate the direction of parameter and argument declarations.
MemberAttributes	Specifies member attribute identifiers for class members.

System.CodeDom Classes
CodeArgumentReferenceExpression	Represents a reference to an argument.
CodeArrayCreateExpression	Represents an expression that creates an array.
CodeArrayIndexerExpression	Represents an expression that indicates an array and a specific index or indices.
CodeAssignStatement	Represents a simple assignment statement.
CodeAttachEventStatement	Represents a statement that attaches an event handler.
CodeAttributeArgument	Represents an argument used in a metadata custom attribute declaration.
CodeAttributeArgumentCollection	Represents a collection of CodeAttributeArgument objects.
CodeAttributeDeclaration	Represents an attribute declaration.
CodeAttributeDeclarationCollection	Represents a collection of CodeAttributeDeclaration objects.
CodeBaseReferenceExpression	Represents a reference to the base class.
CodeBinaryOperatorExpression	Represents an expression that consists of a binary operation between two expressions.
CodeCastExpression	Represents an expression that is to be cast to a data type or interface.
CodeCatchClause	Represents a catch exception block.
CodeCatchClauseCollection	Represents a collection of CodeCatchClause objects.
CodeComment	Represents a comment.
CodeCommentStatement	Represents a statement consisting of a single comment.
CodeCommentStatementCollection	Represents a collection of CodeCommentStatement objects.
CodeCompileUnit	Provides a top-level object to use for compilation.
CodeConditionStatement	Represents a conditional branch statement, typically represented as an if statement.
CodeConstructor	Represents the declaration of an instance constructor for a type.
CodeDelegateCreateExpression	Represents an expression that creates a delegate.
CodeDelegateInvokeExpression	Represents an expression that invokes a delegate.
CodeDirectionExpression	Represents an expression that indicates the direction type of the reference.
CodeEntryPointMethod	Represents the entry point of an executable.
CodeEventReferenceExpression	Represents an expression that references an event.
CodeExpression	Represents a code expression. This is a base class for other code expression objects that is never instantiated.
CodeExpressionCollection	Represents a collection of CodeExpression objects.
CodeExpressionStatement	Represents a statement that consists of a single expression.
CodeFieldReferenceExpression	Represents a reference to a field.
CodeGotoStatement	Represents a goto statement.
CodeIndexerExpression	Represents a reference to an indexer property of an object.
CodeIterationStatement	Represents a for statement, or a simple loop through a block of statements, using a test expression as a condition for continuing to loop.
CodeLabeledStatement	Represents a labeled statement or a stand-alone label.
CodeLinePragma	Represents a specific location within a specific file.
CodeMemberEvent	Represents an event member of a class.
CodeMemberField	Represents a field class member declaration.
CodeMemberMethod	Represents a declaration for a method of a class.
CodeMemberProperty	Represents a declaration for a property of a class.
CodeMethodInvokeExpression	Represents an expression that invokes a method.
CodeMethodReferenceExpression	Represents an expression that references a method on a specific object.
CodeMethodReturnStatement	Represents a return statement.
CodeNamespace	Represents a namespace declaration.
CodeNamespaceCollection	Represents a collection of CodeNamespace objects.
CodeNamespaceImport	Represents a namespace import directive that indicates a namespace to use.
CodeNamesapceImportCollection	Represents a collection of CodeNamespaceImport objects.
CodeObject	Provides a common base class for most Code Document Object Model (CodeDOM) objects.
CodeObjectCreateExpression	Represents an expression that creates a new instance of an object.
CodeParamaterDeclarationExpression	Represents a parameter declaration for a method, property, or constructor.
CodeParameterDeclarationExpressionCollection	Represents a collection of CodeParameterDeclarationExpression objects.
CodePrimitiveExpression	Represents a primitive data type value.
CodePropertyReferenceExpression	Represents a reference to a property.
CodePropertySetValueReferenceExpression	Represents an expression that represents the value argument of a property set method call within a property set method declaration.
CodeRemoveEventStatement	Represents a statement that removes an event handler.
CodeSnippetCompileUnit	Represents a literal code fragment that can be compiled.
CodeSnippetExpression	Represents a literal expression.
CodeSnippetStatement	Represents a statement using a literal code fragment.
CodeSnippetTypeMember	Represents a member of a class using a literal code fragment.
CodeStatementCollection	Represents a collection ofCodeStatement objects.
CodeThisReferenceExpression	Represents a reference to the current local class instance.
CodeThrowExceptionStatement	Represents a statement that throws an exception.
CodeTryCatchFinallyStatement	Represents a try block, with any number of catch clauses and optionally, a finally block.
CodeTypeConstructor	Represents a static constructor for a class.
CodeTypeDeclaration	Represents a type declaration for a class, structure, interface or enumeration.
CodeTypeDeclarationCollection	Represents a collection of CodeTypeDeclaration objects.
CodeTypeDelegate	Represents a delegate declaration.
CodeTypeMember	Represents the declaration for a member of a type. Type members include fields, methods, properties, constructors and nested types.
CodeTypeMemberCollection	Represents a collection of CodeTypeMember objects.
CodeTypeOfExpression	Represents a typeof expression, an expression that returns a specified runtime type.
CodeTypeReference	Represents a data type to CodeDOM objects.
CodeTypeReferenceCollection	Represents a collection of CodeTypeReference objects.
CodeTypeReferenceExpression	Represents a reference to a data type.
CodeVariableDeclarationStatement	Represents a declaration of a variable.
CodeVariableReferenceExpression	Represents an expression that references a local variable.

System.CodeDom.Compiler Namespace Overview

The System.CodeDom.Compiler namespace contains enumerations, interfaces and classes used to generate and compile source code. Compile Units created using the System.CodeDom namespace are collected and processed by the System.CodeDom.Compiler namespace. When generating source code, CompileUnits are processed by three main interfaces: the ICodeParser, ICodeGenerator, and ICodeCompiler Interfaces. The ICodeParser Interface parses the CompileUnit trees into a structure in memory. The ICodeGenerator Interface reads the output of the ICodeParser Interface and physically generates the source code files in the desired language. The ICodeCompiler Interface receives source code files as input and compiles the source code into assemblies. The key to understanding the System.CodeDom.Compiler namespace is to learn how the three exposed interfaces work: the ICodeParser, ICodeCompiler, and ICodeCompiler Interfaces. In short, the System.CodeDom.Compiler namespace operates on the premise of having tree structures called Compile Units already built and ready to be parsed, generated and compiled.

System.CodeDom.Compiler Enumerations
GeneratorSupport	Specifies identifiers used to determine whether a code generator supports certain types of code.
LanguageOptions	Specifies identifiers that indicate special features of a language.

System.CodeDom.Compiler Interfaces
ICodeCompiler	Provides a compiler execution interface.
ICodeGenerator	Provides an interface for generating code.
ICodeParser	Specifies an interface for parsing code into a CodeCompileUnit.

System.CodeDom.Compiler Classes
CodeCompiler	Provides a helper class for implementing an ICodeCompiler.
CodeDomProvider	Provides a base class for CodeDomProvider implementations. This class is abstract.
CodeGenerator	Provides a helper class for implementing an ICodeGenerator. This class is abstract.
CodeGeneratorOptions	Represents options used by code generators.
CodeParser	Provides a helper class for implementing an ICodeParser.
CompilerError	Represents a compiler error or warning.
CompilerErrorCollection	Represents a collection of CompilerError objects.
CompilerParameters	Represents the parameters used to invoke the compiler.
CompilerResults	Represents the results of compilation that are returned from the compiler.
Executor	Provides command execution functions for invoking compilers. This class cannot be inherited.
IndentedTextWriter	Provides a text writer that can indent new lines by a tab string token.
TempFileCollection	Represents a collection of temporary files.

posted on 2006-05-09 13:58 梦在天涯阅读(1058) 评论(0) 编辑收藏引用所属分类: C#/.NET

只有注册用户登录后才能发表评论。
【推荐】100%开源！大型工业跨平台软件C++源码提供，建模，组态！

相关文章: csharp中xml引用xslt C#入门代码本博客所有精华随笔索引 C#的Form通过CLI调用C++的DLL NativeC++通过CLI调用C#的Form CLI/C++中混合类的使用一个CLI/C++的DLL同时被C#的exe和NativeC++的exe调用 struct在p/invoke中的转化 C#通过C++/CLI调用C++DLL C#调用C++的COM

网站导航: 博客园 IT新闻 BlogJava 知识库博问管理

C++ Programmer's Cookbook

使用codeDom ---namespace 动态的生成.net代码

公告

导航

统计

常用链接

随笔分类

随笔档案

收藏夹

Blogs

c#(csharp)

C++(cpp)

Enlish

Forums(bbs)

My self

Often go

Useful Webs

Xml/Uml/html

搜索

积分与排名

最新评论

阅读排行榜