CompilerType Classe

Définition

Espace de noms:

System.Web.Compilation

Assembly:

System.Web.dll

Représente les paramètres de compilateur utilisés dans l'environnement de génération ASP.NET pour générer et compiler le code source à partir d'un chemin d'accès virtuel. Cette classe ne peut pas être héritée.

C#

public sealed class CompilerType

Héritage

Object

CompilerType

Exemples

L’exemple de code suivant illustre une implémentation de fournisseur de build simple, héritant de la classe de base abstraite BuildProvider . Le fournisseur de build remplace les CodeCompilerTypemembres , GetGeneratedTypeet GenerateCode de la classe de base.

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);
    }
}

Remarques

Utilisez la CodeCompilerType propriété d’une BuildProvider implémentation pour examiner les paramètres utilisés pour générer et compiler le code source à partir d’un chemin d’accès virtuel pour ce fournisseur de build.

L’environnement de build ASP.NET utilise des BuildProvider objets pour générer du code source pour les types de fichiers personnalisés au sein du projet. Les classes dérivées de BuildProvider fournissent des détails de build pour les fichiers sources, les pages Web, les ressources et d’autres éléments personnalisés. Lorsque le fournisseur de build nécessite un langage de programmation spécifique, il remplace la CodeCompilerType propriété et appelle la GetDefaultCompilerType méthode pour retourner un CompilerType objet pour le langage de programmation pris en charge.

Pour définir l’objet CompilerType dans une implémentation de fournisseur de build, utilisez la GetDefaultCompilerType méthode ou la GetDefaultCompilerTypeForLanguage méthode .

La CodeDomProviderType propriété spécifie l’implémentation CodeDomProvider utilisée pour générer et compiler le code source d’un fournisseur de build. La CompilerParameters propriété définit les paramètres utilisés pour compiler le code source dans un assembly.

Propriétés

CodeDomProviderType	Obtient un Type pour l'implémentation CodeDomProvider configurée.
CompilerParameters	Obtient les paramètres et options servant à compiler le code source dans un assembly.

Méthodes

Equals(Object)	Détermine si l'objet spécifié représente le même fournisseur de code et les mêmes paramètres de compilateur que l'instance actuelle de CompilerType.
GetHashCode()	Retourne le code de hachage de cette instance.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

S’applique à

Voir aussi

• CompilerParameters
• CodeDomProvider
• BuildProvider