AssemblyBuilder.CreateCodeFile(BuildProvider) Metodo

Definizione

Spazio dei nomi:

System.Web.Compilation

Assembly:

System.Web.dll

Consente a un provider di compilazione di creare un file di origine temporaneo e di includere il file di origine nella compilazione dell'assembly.

C#

public System.IO.TextWriter CreateCodeFile(System.Web.Compilation.BuildProvider buildProvider);

Parametri

buildProvider

BuildProvider

Provider di compilazione che genera il file di origine del codice.

Restituisce

TextWriter

Classe TextWriter aperta che può essere utilizzata per scrivere codice sorgente in un file temporaneo.

Esempio

Nell'esempio di codice seguente viene illustrata una semplice implementazione del provider di compilazione, che eredita dalla classe base astratta BuildProvider . Il provider di compilazione esegue l'override dei CodeCompilerTypemembri , GetGeneratedTypee GenerateCode della classe base.

Nell'implementazione del GenerateCode metodo il provider di compilazione aggiunge il codice generato per la compilazione dell'assembly usando il CreateCodeFile metodo . L'esempio non include l'implementazione della SampleClassGenerator classe . Per altre informazioni, vedere CodeCompileUnit.

C#

using System;
using System.Collections;
using System.IO;
using System.Text;
using System.Web;
using System.Web.Compilation;
using System.CodeDom.Compiler;
using System.CodeDom;
using System.Security;
using System.Security.Permissions;

// Define a simple build provider implementation.
[PermissionSet(SecurityAction.Demand, Unrestricted = true)]
public class SampleBuildProvider : BuildProvider
{
    // Define an internal member for the compiler type.
    protected CompilerType _compilerType = null;

    public SampleBuildProvider()
    {
        // Set the compiler to use Visual Basic.
        _compilerType = GetDefaultCompilerTypeForLanguage("C#");
    }

    // Return the internal CompilerType member 
    // defined in this implementation.
    public override CompilerType CodeCompilerType
    {
        get { return _compilerType; }
    }

    // Define a method that returns details for the 
    // code compiler for this build provider.
    public string GetCompilerTypeDetails()
    {
        StringBuilder details = new StringBuilder("");

        if (_compilerType != null)
        {
            // Format a string that contains the code compiler
            // implementation, and various compiler details.

            details.AppendFormat("CodeDomProvider type: {0}; \n",
                _compilerType.CodeDomProviderType.ToString());
            details.AppendFormat("Compiler debug build = {0}; \n",
                _compilerType.CompilerParameters.IncludeDebugInformation.ToString());
            details.AppendFormat("Compiler warning level = {0}; \n",
                _compilerType.CompilerParameters.WarningLevel.ToString());

            if (_compilerType.CompilerParameters.CompilerOptions != null)
            {
                details.AppendFormat("Compiler options: {0}; \n",
                    _compilerType.CompilerParameters.CompilerOptions.ToString());
            }
        }
        return details.ToString();
    }

    // Define the build provider implementation of the GenerateCode method.
    public override void GenerateCode(AssemblyBuilder assemBuilder)
    {
        // Generate a code compile unit, and add it to
        // the assembly builder.

        TextWriter tw = assemBuilder.CreateCodeFile(this);
        if (tw != null)
        {
            try
            {
                // Generate the code compile unit from the virtual path.
                CodeCompileUnit compileUnit = SampleClassGenerator.BuildCompileUnitFromPath(VirtualPath);

                // Generate the source for the code compile unit, 
                // and write it to a file specified by the assembly builder.
                CodeDomProvider provider = assemBuilder.CodeDomProvider;
                provider.CreateGenerator().GenerateCodeFromCompileUnit(compileUnit, tw, null);
            }
            finally
            {
                tw.Close();
            }
        }
    }

    public override System.Type GetGeneratedType(CompilerResults results)
    {
        string typeName = SampleClassGenerator.TypeName;

        return results.CompiledAssembly.GetType(typeName);
    }
}

Commenti

Un'implementazione BuildProvider chiama il metodo durante la CreateCodeFile generazione di un file di origine per un percorso virtuale. Il codice sorgente aggiunto con CreateCodeFile è incluso nella compilazione dell'assembly.

In genere, un'implementazione del metodo del provider GenerateCode di compilazione legge la VirtualPath proprietà , analizza il contenuto e quindi aggiunge il codice sorgente generato all'oggetto specificato AssemblyBuilder . Il provider di compilazione usa il metodo per aggiungere il CreateCodeFile codice sorgente come file fisico all'assembly. In alternativa, il provider di compilazione può usare il metodo per aggiungere il AddCodeCompileUnit codice sorgente come grafico CodeDOM all'assembly.

Dopo aver chiamato CreateCodeFile, il provider di compilazione scrive il contenuto del file di origine usando l'oggetto restituito TextWriter . Dopo aver scritto il file di origine, l'oggetto BuildProvider deve utilizzare il Close metodo per chiudere l'oggetto e liberare le TextWriter risorse di sistema associate.

Si applica a

Vedi anche

• BuildProvider
• OpenReader
• OpenStream
• AddCodeCompileUnit(BuildProvider, CodeCompileUnit)