Dela via

Generera och kompilera källkod från ett CodeDOM-diagram

Namnområdet System.CodeDom.Compiler innehåller gränssnitt för att generera källkod från CodeDOM-objektdiagram och för att hantera kompilering med kompilatorer som stöds. En kodprovider kan skapa källkod på ett visst programmeringsspråk enligt ett CodeDOM-diagram. En klass som härleds från CodeDomProvider kan vanligtvis tillhandahålla metoder för att generera och kompilera kod för det språk som providern stöder.

Använda en CodeDOM-kodprovider för att generera källkod

För att generera källkod på ett visst språk behöver du ett CodeDOM-diagram som representerar strukturen för källkoden som ska genereras.

I följande exempel visas hur du skapar en instans av en CSharpCodeProvider:

CSharpCodeProvider^ provider = gcnew CSharpCodeProvider();

CSharpCodeProvider provider = new CSharpCodeProvider();

Dim provider As New CSharpCodeProvider()

Grafen för kodgenerering finns vanligtvis i en CodeCompileUnit. Om du vill generera kod för en CodeCompileUnit som innehåller ett CodeDOM-diagram anropar GenerateCodeFromCompileUnit du kodproviderns metod. Den här metoden har en parameter för en TextWriter som används för att generera källkoden, så det är ibland nödvändigt att först skapa en TextWriter som kan skrivas till. I följande exempel visas hur du genererar kod från en CodeCompileUnit och skriver den genererade källkoden till en fil med namnet HelloWorld.cs.

public:
    static String^ GenerateCSharpCode(CodeCompileUnit^ compileunit)
    {
        // Generate the code with the C# code provider.
        CSharpCodeProvider^ provider = gcnew CSharpCodeProvider();

        // Build the output file name.
        String^ sourceFile;
        if (provider->FileExtension[0] == '.')
        {
           sourceFile = "HelloWorld" + provider->FileExtension;
        }
        else
        {
           sourceFile = "HelloWorld." + provider->FileExtension;
        }

        // Create a TextWriter to a StreamWriter to the output file.
        StreamWriter^ sw = gcnew StreamWriter(sourceFile, false);
        IndentedTextWriter^ tw = gcnew IndentedTextWriter(sw, "    ");

            // Generate source code using namespace the code provider.
        provider->GenerateCodeFromCompileUnit(compileunit, tw,
            gcnew CodeGeneratorOptions());

        // Close the output file.
        tw->Close();
        sw->Close();

        return sourceFile;
    }

public static string GenerateCSharpCode(CodeCompileUnit compileunit)
{
    // Generate the code with the C# code provider.
    CSharpCodeProvider provider = new CSharpCodeProvider();

    // Build the output file name.
    string sourceFile;
    if (provider.FileExtension[0] == '.')
    {
       sourceFile = "HelloWorld" + provider.FileExtension;
    }
    else
    {
       sourceFile = "HelloWorld." + provider.FileExtension;
    }

    // Create a TextWriter to a StreamWriter to the output file.
    using (StreamWriter sw = new StreamWriter(sourceFile, false))
    {
        IndentedTextWriter tw = new IndentedTextWriter(sw, "    ");

        // Generate source code using the code provider.
        provider.GenerateCodeFromCompileUnit(compileunit, tw,
            new CodeGeneratorOptions());

        // Close the output file.
        tw.Close();
    }

    return sourceFile;
}

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

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

    ' Create a TextWriter to a StreamWriter to the output file.
    Using sw As New StreamWriter(sourceFile, false)
        Dim tw As New IndentedTextWriter(sw, "    ")

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

        ' Close the output file.
        tw.Close()
    End Using

    Return sourceFile
End Function

Använda en CodeDOM-kodprovider för att kompilera sammansättningar

Starta kompilering

Om du vill kompilera en sammansättning med hjälp av en CodeDom-provider måste du antingen ha källkod för att kompilera på ett språk som du har en kompilator för, eller ett CodeDOM-diagram som källkoden som ska kompileras kan genereras från.

Om du kompilerar från ett CodeDOM-diagram, skicka det diagram som innehåller grafen till metoden hos kodprovidern. Om du har en källkodsfil på ett språk som kompilatorn förstår skickar du namnet på filen som innehåller källkoden CompileAssemblyFromFile till metoden för CodeDom-providern. Du kan också skicka en sträng som innehåller källkod på ett språk som kompilatorn förstår till CompileAssemblyFromSource metoden för CodeDom-providern.

Konfigurera kompileringsparametrar

Alla standardmetoder för kompilering av en CodeDom-provider har en parameter av typen CompilerParameters som anger vilka alternativ som ska användas för kompilering.

Du kan ange ett filnamn för utdatasammansättningen i OutputAssembly egenskapen för CompilerParameters. Annars används ett standardnamn för utdatafilen.

Som standard initieras en ny CompilerParameters med dess GenerateExecutable egenskap inställd på false. Om du kompilerar ett körbart program måste du ange GenerateExecutable egenskapen till true. När GenerateExecutable är inställt på false, genererar kompilatorn ett klassbibliotek.

Om du kompilerar en körbar fil från en CodeDOM-graf måste en CodeEntryPointMethod definieras i diagrammet. Om det finns flera kodinmatningspunkter kan det vara nödvändigt att ställa in MainClass-egenskapen på CompilerParameters till namnet på den klass som definierar den entry point som ska användas.

Om du vill inkludera felsökningsinformation i en genererad körbar fil anger du IncludeDebugInformation egenskapen till true.

Om projektet refererar till några sammansättningar måste du ange sammansättningsnamnen som objekt i en StringCollection som ReferencedAssemblies egenskapen för den CompilerParameters du använder när du anropar kompilering.

Du kan kompilera en sammansättning som skrivs till minnet i stället för disken genom att ställa in GenerateInMemory egenskapen på true. När en sammansättning genereras i minnet kan koden hämta en referens till den genererade sammansättningen från CompiledAssembly egenskapen för en CompilerResults. Om en sammansättning skrivs till disken kan du hämta sökvägen till den genererade sammansättningen från PathToAssembly egenskapen för en CompilerResults.

Om du vill ange en anpassad kommandoradsargumentsträng som ska användas när kompileringsprocessen anropas anger du strängen CompilerOptions i egenskapen .

Om en Win32-säkerhetstoken krävs för att anropa kompileringsprocessen anger du token i UserToken egenskapen.

Om du vill länka en Win32-resursfil till den kompilerade sammansättningen anger du namnet på Win32-resursfilen i Win32Resource egenskapen.

Om du vill ange en varningsnivå där kompilering ska stoppas anger du WarningLevel egenskapen till ett heltal som representerar varningsnivån där kompilering ska stoppas. Du kan också konfigurera kompilatorn att stoppa kompilering om varningar påträffas genom att ange TreatWarningsAsErrors egenskapen till true.

Följande kodexempel visar hur du kompilerar en källfil med hjälp av en CodeDom-provider som härletts från CodeDomProvider klassen.

public:
    static bool CompileCSharpCode(String^ sourceFile, String^ exeFile)
    {
        CSharpCodeProvider^ provider = gcnew CSharpCodeProvider();

        // Build the parameters for source compilation.
        CompilerParameters^ cp = gcnew CompilerParameters();

        // Add an assembly reference.
        cp->ReferencedAssemblies->Add( "System.dll" );

        // Generate an executable instead of
        // a class library.
        cp->GenerateExecutable = true;

        // Set the assembly file name to generate.
        cp->OutputAssembly = exeFile;

        // Save the assembly as a physical file.
        cp->GenerateInMemory = false;

        // Invoke compilation.
        CompilerResults^ cr = provider->CompileAssemblyFromFile(cp, sourceFile);

       if (cr->Errors->Count > 0)
       {
           // Display compilation errors.
            Console::WriteLine("Errors building {0} into {1}",
                sourceFile, cr->PathToAssembly);
            for each (CompilerError^ ce in cr->Errors)
            {
                Console::WriteLine("  {0}", ce->ToString());
                Console::WriteLine();
            }
        }
        else
        {
            Console::WriteLine("Source {0} built into {1} successfully.",
                sourceFile, cr->PathToAssembly);
        }

        // Return the results of compilation.
        if (cr->Errors->Count > 0)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

public static bool CompileCSharpCode(string sourceFile, string exeFile)
{
    CSharpCodeProvider provider = new CSharpCodeProvider();

    // Build the parameters for source compilation.
    CompilerParameters cp = new CompilerParameters();

    // Add an assembly reference.
    cp.ReferencedAssemblies.Add( "System.dll" );

    // Generate an executable instead of
    // a class library.
    cp.GenerateExecutable = true;

    // Set the assembly file name to generate.
    cp.OutputAssembly = exeFile;

    // Save the assembly as a physical file.
    cp.GenerateInMemory = false;

    // Invoke compilation.
    CompilerResults cr = provider.CompileAssemblyFromFile(cp, sourceFile);

   if (cr.Errors.Count > 0)
   {
       // Display compilation errors.
        Console.WriteLine($"Errors building {sourceFile} into {cr.PathToAssembly}");
        foreach (CompilerError ce in cr.Errors)
        {
            Console.WriteLine($"  {ce.ToString()}");
            Console.WriteLine();
        }
    }
    else
    {
        Console.WriteLine($"Source {sourceFile} built into {cr.PathToAssembly} successfully.");
    }

    // Return the results of compilation.
    if (cr.Errors.Count > 0)
    {
        return false;
    }
    else
    {
        return true;
    }
}

Public Shared Function CompileCSharpCode(sourceFile As String, _
    exeFile As String) As Boolean
    Dim provider As New CSharpCodeProvider()

    ' Build the parameters for source compilation.
    Dim cp As New CompilerParameters()

    ' Add an assembly reference.
    cp.ReferencedAssemblies.Add("System.dll")

    ' Generate an executable instead of
    ' a class library.
    cp.GenerateExecutable = true

    ' Set the assembly file name to generate.
    cp.OutputAssembly = exeFile

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

    ' 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)
        For Each ce As CompilerError 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

Språk med inledande stöd

.NET tillhandahåller kodkompilatorer och kodgeneratorer för följande språk: C#, Visual Basic, C++och JScript. CodeDOM-stöd kan utökas till andra språk genom att implementera språkspecifika kodgeneratorer och kodkompilatorer.

Se även

  • Last updated on