GeneratorSupport Enum

Definitie

Naamruimte:: System.CodeDom.Compiler

Assembly:: System.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Definieert id's die worden gebruikt om te bepalen of een codegenerator bepaalde typen code-elementen ondersteunt.

Deze opsomming ondersteunt een bitsgewijze combinatie van de waarden van de leden.

public enum class GeneratorSupport

[System.Flags]
[System.Serializable]
public enum GeneratorSupport

[<System.Flags>]
[<System.Serializable>]
type GeneratorSupport =

Public Enum GeneratorSupport

Overname: Object

ValueType

Enum
GeneratorSupport

Kenmerken: FlagsAttribute SerializableAttribute

Velden

Name	Waarde	Description
ArraysOfArrays	1	Geeft aan dat de generator matrices van matrices ondersteunt.
EntryPointMethod	2	Geeft aan dat de generator ondersteuning biedt voor de aanduiding van een methode voor het programmainvoerpunt. Dit wordt gebruikt bij het bouwen van uitvoerbare bestanden.
GotoStatements	4	Geeft aan dat de generator goto-instructies ondersteunt.
MultidimensionalArrays	8	Geeft aan dat de generator ondersteuning biedt voor het verwijzen naar multidimensionale matrices. Momenteel kan de CodeDom niet worden gebruikt om multidimensionale matrices te instantiëren.
StaticConstructors	16	Geeft aan dat de generator statische constructors ondersteunt.
TryCatchStatements	32	Geeft aan dat de generator instructies ondersteunt `try-catch` .
ReturnTypeAttributes	64	Geeft aan dat de generator declaraties van kenmerken van het retourtype ondersteunt.
DeclareValueTypes	128	Geeft aan dat de generator declaraties van waardetypen ondersteunt.
DeclareEnums	256	Geeft aan dat de generator opsommingsdeclaraties ondersteunt.
DeclareDelegates	512	Geeft aan dat de generator gedelegeerde declaraties ondersteunt.
DeclareInterfaces	1024	Geeft aan dat de generator interfacedeclaraties ondersteunt.
DeclareEvents	2048	Geeft aan dat de generator gebeurtenisdeclaraties ondersteunt.
AssemblyAttributes	4096	Geeft aan dat de generator assemblykenmerken ondersteunt.
ParameterAttributes	8192	Geeft aan dat de generator parameterkenmerken ondersteunt.
ReferenceParameters	16384	Geeft aan dat de generator referentie- en outparameters ondersteunt.
ChainedConstructorArguments	32768	Geeft aan dat de generator ketenconstructorargumenten ondersteunt.
NestedTypes	65536	Geeft aan dat de generator de declaratie van geneste typen ondersteunt.
MultipleInterfaceMembers	131072	Geeft aan dat de generator ondersteuning biedt voor de declaratie van leden die meerdere interfaces implementeren.
PublicStaticMembers	262144	Geeft aan dat de generator openbare statische leden ondersteunt.
ComplexExpressions	524288	Geeft aan dat de generator complexe expressies ondersteunt.
Win32Resources	1048576	Geeft aan dat de generator compilatie met Win32-resources ondersteunt.
Resources	2097152	Geeft aan dat de generator compilatie met .NET resources ondersteunt. Dit kunnen standaardbronnen zijn die rechtstreeks in een assembly worden gecompileerd of resources waarnaar wordt verwezen in een satellietassembly.
PartialTypes	4194304	Geeft aan dat de generator gedeeltelijke typedeclaraties ondersteunt.
GenericTypeReference	8388608	Geeft aan dat de generator algemene typeverwijzingen ondersteunt.
GenericTypeDeclaration	16777216	Geeft aan dat de generator algemene typedeclaraties ondersteunt.
DeclareIndexerProperties	33554432	Geeft aan dat de generator de declaratie van indexeereigenschappen ondersteunt.

Voorbeelden

In het volgende voorbeeld ziet u hoe u CompilerParameters verschillende compilerinstellingen en opties kunt opgeven.

public static bool CompileCode(CodeDomProvider provider,
    String sourceFile,
    String exeFile)
{

    CompilerParameters cp = new CompilerParameters();

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

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

    // Generate debug information.
    cp.IncludeDebugInformation = true;

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

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

    // Set the level at which the compiler
    // should start displaying warnings.
    cp.WarningLevel = 3;

    // Set whether to treat all warnings as errors.
    cp.TreatWarningsAsErrors = false;

    // Set compiler argument to optimize output.
    cp.CompilerOptions = "/optimize";

    // Set a temporary files collection.
    // The TempFileCollection stores the temporary files
    // generated during a build in the current directory,
    // and does not delete them after compilation.
    cp.TempFiles = new TempFileCollection(".", true);

    if (provider.Supports(GeneratorSupport.EntryPointMethod))
    {
        // Specify the class that contains
        // the main method of the executable.
        cp.MainClass = "Samples.Class1";
    }

    if (Directory.Exists("Resources"))
    {
        if (provider.Supports(GeneratorSupport.Resources))
        {
            // Set the embedded resource file of the assembly.
            // This is useful for culture-neutral resources,
            // or default (fallback) resources.
            cp.EmbeddedResources.Add("Resources\\Default.resources");

            // Set the linked resource reference files of the assembly.
            // These resources are included in separate assembly files,
            // typically localized for a specific language and culture.
            cp.LinkedResources.Add("Resources\\nb-no.resources");
        }
    }

    // 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);
        foreach(CompilerError ce in cr.Errors)
        {
            Console.WriteLine("  {0}", ce.ToString());
            Console.WriteLine();
        }
    }
    else
    {
        Console.WriteLine("Source {0} built into {1} successfully.",
            sourceFile, cr.PathToAssembly);
        Console.WriteLine("{0} temporary files created during the compilation.",
            cp.TempFiles.Count.ToString());
    }

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

Public Shared Function CompileCode(ByVal provider As CodeDomProvider, _
ByVal sourceFile As String, ByVal exeFile As String) As Boolean

    Dim cp As New CompilerParameters()

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

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

    ' Generate debug information.
    cp.IncludeDebugInformation = True

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

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

    ' Set the level at which the compiler 
    ' should start displaying warnings.
    cp.WarningLevel = 3

    ' Set whether to treat all warnings as errors.
    cp.TreatWarningsAsErrors = False

    ' Set compiler argument to optimize output.
    cp.CompilerOptions = "/optimize"

    ' Set a temporary files collection.
    ' The TempFileCollection stores the temporary files
    ' generated during a build in the current directory,
    ' and does not delete them after compilation.
    cp.TempFiles = New TempFileCollection(".", True)

    If provider.Supports(GeneratorSupport.EntryPointMethod) Then
        ' Specify the class that contains
        ' the main method of the executable.
        cp.MainClass = "Samples.Class1"
    End If


    If Directory.Exists("Resources") Then
        If provider.Supports(GeneratorSupport.Resources) Then
            ' Set the embedded resource file of the assembly.
            ' This is useful for culture-neutral resources,
            ' or default (fallback) resources.
            cp.EmbeddedResources.Add("Resources\Default.resources")

            ' Set the linked resource reference files of the assembly.
            ' These resources are included in separate assembly files,
            ' typically localized for a specific language and culture.
            cp.LinkedResources.Add("Resources\nb-no.resources")
        End If
    End If

    ' 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 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)
        Console.WriteLine("{0} temporary files created during the compilation.", _
                cp.TempFiles.Count.ToString())
    End If

    ' Return the results of compilation.
    If cr.Errors.Count > 0 Then
        Return False
    Else
        Return True
    End If
End Function 'CompileCode

Opmerkingen

Deze id's worden gebruikt bij het aanroepen van de Supports methode van een codegenerator om te bepalen of de codegenerator ondersteuning biedt voor het genereren van bepaalde typen code.

Van toepassing op

Zie ook

Feedback

Is deze pagina nuttig?