Gerando código-fonte e compilando um programa de um gráfico de CodeDOM

The System.CodeDom.Compiler espaço para nome fornece interfaces para a geração de código-fonte de gráficos de objetos de CodeDOM e gerenciamento de compilação com compiladores com suporte. Um provedor de código pode produzir código-fonte em uma linguagem de programação específica de acordo com a um gráfico de CodeDOM.Uma classe que deriva de CodeDomProvider normalmente pode fornecer métodos para gerar e oferece suporte a compilação de código para o linguagem do provedor.

Usando um provedor de CodeDOM código para gerar código-fonte

Para gerar código-fonte em um determinado linguagem, você precisa de um gráfico de CodeDOM que representa a estrutura do código-fonte para gerar.

O exemplo a seguir demonstram como criar uma instância de um CSharpCodeProvider:

Dim provider As New CSharpCodeProvider()

O gráfico para a geração de código geralmente está contido em um CodeCompileUnit. Para gerar o código para um CodeCompileUnit que contém um gráfico de CodeDOM, chame o GenerateCodeFromCompileUnit método do provedor de código. Esse método tem um parâmetro para um TextWriter que ele usa para gerar o código de fonte, às vezes, é necessário criar primeiro um TextWriter que podem ser gravados em.O exemplo a seguir demonstra como gerar código de um CodeCompileUnit e escrever o código-fonte gerado para um arquivo denominado HelloWorld.cs.

Public Shared Function GenerateCSharpCode( _
    compileunit As CodeCompileUnit) As String
       
    ' Generate the code with the C# code provider.
    Dim provider As CSharpCodeProvider = New CSharpCodeProvider()

    ' Build the output file name.
    Dim sourceFile As String
    If provider.FileExtension.StartsWith(".")
        sourceFile = "HelloWorld" + provider.FileExtension
    Else
        sourceFile = "HelloWorld." + provider.FileExtension
    End If

    ' Create a TextWriter to a StreamWriter to an output file.
    Dim tw As New IndentedTextWriter( _
        New StreamWriter(sourceFile, False), "    ")

    ' Generate source code using the code provider.
    provider.GenerateCodeFromCompileUnit(compileunit, tw, _
        New CodeGeneratorOptions())

    ' Close the output file.
    tw.Close()
        
    Return sourceFile
End Function
   

Usando um provedor de código CodeDOM compilar assemblies

Invocar a compilação

Para compilar um assembly usando um provedor de CodeDom, você deve ter o código-fonte para compilar em um linguagem para os quais você tem um compilador ou um CodeDOM dessa origem do gráfico pode ser gerado código para compilar a partir de.

Se você está compilando de um gráfico de CodeDOM, passar o CodeCompileUnit que contém o gráfico para a CompileAssemblyFromDom método do provedor de código. Se você tiver um arquivo de código-fonte em um linguagem que o compilador compreende, passe o nome do arquivo que contém o código-fonte para o CompileAssemblyFromFile método do provedor de CodeDom. Você também pode passar uma seqüência de caracteres contendo o código-fonte em um linguagem que o compilador compreende à CompileAssemblyFromSource método do provedor de CodeDom.

Configurando parâmetros de compilação

Todos os métodos de invocação de compilação padrão de um provedor de CodeDom tem um parâmetro do tipo CompilerParameters indica as opções a serem usadas para compilação.

Você pode especificar um nome de arquivo para o assembly de saída no OutputAssembly propriedade das CompilerParameters.Caso contrário, será usado um nome de arquivo de saída padrão.

Por padrão, um novo CompilerParameters é inicializada com o seu GenerateExecutable conjunto de propriedades como False.Se você está compilando um programa executável, você deve conjunto o GenerateExecutable propriedade True.Quando o GenerateExecutable is conjunto to False, o compilador irá gerar uma biblioteca de classes.

Se você está compilando um executável de um gráfico de CodeDOM, um CodeEntryPointMethod deve ser definida no gráfico. Se houver vários pontos de entrada de código, talvez seja necessário conjunto o MainClass propriedade das CompilerParameters com o nome da classe que define o ponto de entrada para usar.

Para incluir informações de depurar em um executável gerado, conjunto o IncludeDebugInformation propriedade para True.

Se seu projeto fizer referência a todos sistema autônomo assemblies, você deve especificar nomes assembly sistema autônomo itens em um StringCollection sistema autônomo o ReferencedAssemblies propriedade das CompilerParameters use ao invocar a compilação.

Você pode compilar um assembly que é gravado em memória em vez de disco por configuração o GenerateInMemory propriedade para True.Quando um assembly é gerado na memória, seu código poderá obter uma referência a assembly gerado a partir de CompiledAssembly propriedade de um CompilerResults. Se um assembly for gravado para disco, você pode obter o caminho para o assembly gerado do PathToAssembly propriedade de um CompilerResults.

Para especificar uma seqüência de argumentos de linha de comando personalizado a ser usado ao invocar o processo de compilação conjunto a seqüência de caracteres no CompilerOptions propriedade.

Se um token de segurança do Win32 é necessária para chamar o processo de compilador, especificar o token no UserToken propriedade.

Para vincular um arquivo de recursos do Win32 no assembly compilado, especifique o nome do arquivo de recurso Win32 no Win32Resource propriedade.

Para especificar um nível de aviso na qual se deseja interromper a compilação, defina o WarningLevel propriedade para um número inteiro que representa o nível de aviso na qual se deseja interromper a compilação. Você também pode configurar o compilador para interromper a compilação se avisos são encontrados, definindo o TreatWarningsAsErrors propriedade para True.

O exemplo de código a seguir demonstra a compilação de um arquivo de fonte usando um provedor de CodeDom derivado o CodeDomProvider classe.

Public Shared Function CompileCSharpCode(sourceFile As String, _
    exeFile As String) As Boolean
    Dim provider As CSharpCodeProvider = New CSharpCodeProvider()
          
    ' Build the parameters for source compilation.
    Dim cp As New CompilerParameters()
         
    ' Add an assembly reference.
    cp.ReferencedAssemblies.Add("System.dll")

    ' Save the assembly as a physical file.
    cp.GenerateInMemory = False

    ' Generate an executable instead of a class library.
    cp.GenerateExecutable = True
          
    ' Set the assembly file name to generate.
    cp.OutputAssembly = exeFile
        
    ' Invoke compilation.
    Dim cr As CompilerResults = _
        provider.CompileAssemblyFromFile(cp, sourceFile)
          
    If cr.Errors.Count > 0 Then
        ' Display compilation errors.
        Console.WriteLine("Errors building {0} into {1}", _
            sourceFile, cr.PathToAssembly)
        Dim ce As System.CodeDom.Compiler.CompilerError
        For Each ce In  cr.Errors
            Console.WriteLine("  {0}", ce.ToString())
            Console.WriteLine()
        Next ce
    Else
        Console.WriteLine("Source {0} built into {1} successfully.", _
            sourceFile, cr.PathToAssembly)
    End If
          
    ' Return the results of compilation.
    If cr.Errors.Count > 0 Then
        Return False
    Else
        Return True
    End If
End Function

Idiomas com suporte inicial

O .NET estrutura fornece código compiladores e geradores de código nos seguintes idiomas: Translation from VPE for Csharp, Visual Basic, C++, J# e JScript.Suporte codeDOM pode ser estendido para outros idiomas por meio da implementação de geradores de código de específico a um linguagem e compiladores de código.

Consulte também

Referência

Referência rápida codeDOM

System.CodeDom

System.CodeDom.Compiler

Outros recursos

Tecnologias de desenvolvimento avançadas