C++ Programmer's Cookbook

{C++ 基础} {C++ 高级} {C#界面,C++核心算法} {设计模式} {C#基础}

使用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:

  1. 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.
  2. The CodeDom allows programs to be dynamically created, compiled, and executed at runtime.
  3. The CodeDom provides a language independent object model for representing the structure of source code in memory.
  4. 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.

  1. 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
              {
              }
                 }
    
  2. Limitation #2: There is no support for nested namespaces.
    namespace OutterNamespace
         {
              namespace InnerNamespace
              {
                   public void MyClass
                   {
                   }
              }
          }
    
  3. 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;
                  }
              }
          }
    
  4. 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 梦在天涯 阅读(853) 评论(0)  编辑 收藏 引用 所属分类: C#/.NET


只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理


公告

EMail:itech001#126.com

导航

统计

  • 随笔 - 461
  • 文章 - 4
  • 评论 - 746
  • 引用 - 0

常用链接

随笔分类

随笔档案

收藏夹

Blogs

c#(csharp)

C++(cpp)

Enlish

Forums(bbs)

My self

Often go

Useful Webs

Xml/Uml/html

搜索

  •  

积分与排名

  • 积分 - 1633320
  • 排名 - 5

最新评论

阅读排行榜