CSharpCompilation Clase

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.

public ref class CSharpCompilation sealed : Microsoft::CodeAnalysis::Compilation

public sealed class CSharpCompilation : Microsoft.CodeAnalysis.Compilation

type CSharpCompilation = class
    inherit Compilation

Public NotInheritable Class CSharpCompilation
Inherits Compilation

Herencia: Object

Compilation
CSharpCompilation

Campos

_features

(Heredado de Compilation)

Propiedades

Assembly	IAssemblySymbol que representa el ensamblado que se va a crear. (Heredado de Compilation)
AssemblyName	Nombre de ensamblado simple o null si no se especifica. (Heredado de Compilation)
CommonAssembly	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonDynamicType	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonGlobalNamespace	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonObjectType	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonOptions	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonScriptClass	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonScriptGlobalsType	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonSourceModule	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonSyntaxTrees	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
DirectiveReferences	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
DynamicType	TypeSymbol para el tipo "dinámico" en esta compilación. (Heredado de Compilation)
ExternalReferences	Referencias de metadatos pasadas al constructor de compilación. (Heredado de Compilation)
GlobalNamespace	Espacio de nombres raíz que contiene todos los espacios de nombres y tipos definidos en el código fuente o en metadatos a los que se hace referencia, combinados en una única jerarquía de espacios de nombres. (Heredado de Compilation)
IsCaseSensitive	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
Language	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
LanguageVersion	Versión del lenguaje que se usó para analizar los árboles de sintaxis de esta compilación.
ObjectType	INamedTypeSymbol para el tipo System.Object de .NET, que podría tener un TypeKind de Error si no había ninguna biblioteca COR en esta compilación. (Heredado de Compilation)
Options	Las opciones con las que se creó la compilación.
ReferencedAssemblyNames	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
References	Todas las referencias de metadatos: referencias pasadas al constructor de compilación, así como referencias especificadas a través de directivas #r. (Heredado de Compilation)
ScriptClass	Símbolo que representa la clase Script implícita. Esto es null si la clase no está definida en la compilación. (Heredado de Compilation)
ScriptCompilationInfo	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
SourceModule	Obtiene para IModuleSymbol el módulo que se va a crear compilando todo el código fuente. (Heredado de Compilation)
SyntaxTrees	Árboles de sintaxis (analizados desde el código fuente) con los que se creó esta compilación.

Métodos

AddReferences(IEnumerable<MetadataReference>)	Crea una nueva compilación con referencias de metadatos adicionales.
AddReferences(MetadataReference[])	Crea una nueva compilación con referencias de metadatos adicionales.
AddSyntaxTrees(IEnumerable<SyntaxTree>)	Crea una nueva compilación con árboles de sintaxis adicionales.
AddSyntaxTrees(SyntaxTree[])	Crea una nueva compilación con árboles de sintaxis adicionales.
AppendDefaultVersionResource(Stream)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
ClassifyCommonConversion(ITypeSymbol, ITypeSymbol)	Clasifica una conversión de `source` a `destination` según el lenguaje de programación de esta compilación.
ClassifyConversion(ITypeSymbol, ITypeSymbol)	Clasifica una conversión de `source` a `destination`.
Clone()	Cree un duplicado de esta compilación con diferentes instancias de símbolos.
CommonAddSyntaxTrees(IEnumerable<SyntaxTree>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonBindScriptClass()	Resuelve un símbolo que representa el contenedor de scripts (clase Script). Usa el nombre completo de la clase contenedora almacenada en ScriptClassName para buscar el símbolo. (Heredado de Compilation)
CommonClone()	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonContainsSyntaxTree(SyntaxTree)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<Boolean>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<Boolean>, ImmutableArray<NullableAnnotation>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateArrayTypeSymbol(ITypeSymbol, Int32)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateArrayTypeSymbol(ITypeSymbol, Int32, NullableAnnotation)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol, ITypeSymbol)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateErrorNamespaceSymbol(INamespaceSymbol, String)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateErrorTypeSymbol(INamespaceOrTypeSymbol, String, Int32)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>, SignatureCallingConvention, ImmutableArray<INamedTypeSymbol>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateNativeIntegerTypeSymbol(Boolean)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreatePointerTypeSymbol(ITypeSymbol)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonCreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonGetAssemblyOrModuleSymbol(MetadataReference)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonGetCompilationNamespace(INamespaceSymbol)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonGetEntryPoint(CancellationToken)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonGetSemanticModel(SyntaxTree, Boolean)	Obtiene un SemanticModel objeto para el objeto especificado `syntaxTree`. Si Microsoft.CodeAnalysis.Compilation.SemanticModelProvider no es NULL, intenta usar Microsoft.CodeAnalysis.SemanticModelProvider.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Compilation,System.Boolean) para obtener un modelo semántico. De lo contrario, crea un nuevo modelo semántico mediante Microsoft.CodeAnalysis.Compilation.CreateSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean). (Heredado de Compilation)
CommonGetSpecialType(SpecialType)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonGetTypeByMetadataName(String)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonRemoveAllSyntaxTrees()	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonRemoveSyntaxTrees(IEnumerable<SyntaxTree>)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonReplaceSyntaxTree(SyntaxTree, SyntaxTree)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonWithAssemblyName(String)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonWithOptions(CompilationOptions)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
CommonWithReferences(IEnumerable<MetadataReference>)	Crea una nueva compilación con las referencias especificadas. (Heredado de Compilation)
CommonWithScriptCompilationInfo(ScriptCompilationInfo)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
ContainsSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken)	Devuelve true si hay un nombre de símbolo de declaración de origen que cumple el predicado especificado.
ContainsSymbolsWithName(String, SymbolFilter, CancellationToken)	Devuelve true si hay un nombre de símbolo de declaración de origen que coincide con el nombre proporcionado. Esto será más rápido que ContainsSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken) cuando el predicado es simplemente una comprobación de cadena simple.
ContainsSyntaxTree(SyntaxTree)	Devuelve true si esta compilación contiene el árbol especificado. En caso contrario, devuelve un valor falso.
Create(String, IEnumerable<SyntaxTree>, IEnumerable<MetadataReference>, CSharpCompilationOptions)	Crea una nueva compilación desde cero. Los métodos como AddSyntaxTrees o AddReferences en el objeto devuelto permitirán seguir creando la compilación incrementalmente.
CreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Boolean>, ImmutableArray<Location>)	Devuelve un nuevo símbolo de tipo anónimo con los tipos de miembro, los nombres y las ubicaciones de origen especificados. Los miembros de tipo anónimo se leerán de forma predeterminada. Las propiedades grabables se admiten en VB y se pueden crear pasando `false` las ubicaciones adecuadas en `memberIsReadOnly`. (Heredado de Compilation)
CreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Boolean>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	Devuelve un nuevo símbolo de tipo anónimo con los tipos de miembro, los nombres, las ubicaciones de origen y las anotaciones que aceptan valores NULL especificados. Los miembros de tipo anónimo se leerán de forma predeterminada. Las propiedades grabables se admiten en VB y se pueden crear pasando `false` las ubicaciones adecuadas en `memberIsReadOnly`. (Heredado de Compilation)
CreateArrayTypeSymbol(ITypeSymbol, Int32)	Devuelve un nuevo ArrayTypeSymbol que representa un tipo de matriz asociado a los tipos base de la biblioteca cor en esta compilación. (Heredado de Compilation)
CreateArrayTypeSymbol(ITypeSymbol, Int32, NullableAnnotation)	Devuelve un nuevo ArrayTypeSymbol que representa un tipo de matriz asociado a los tipos base de la biblioteca cor en esta compilación. (Heredado de Compilation)
CreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol)	Crea un IMethodSymbol cuya MethodKind propiedad es BuiltinOperator para un operador unario. Los operadores integrados se suelen crear para símbolos como `bool int.operator -(int value)` los que admite implícitamente el lenguaje, incluso si dicho símbolo no está definido explícitamente para ese tipo en los metadatos o de origen. (Heredado de Compilation)
CreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol, ITypeSymbol)	Crea un IMethodSymbol cuya MethodKind propiedad es BuiltinOperator para un operador binario. Los operadores integrados se suelen crear para símbolos como `bool int.operator ==(int v1, int v2)` los que admite implícitamente el lenguaje, incluso si dicho símbolo no está definido explícitamente para ese tipo en los metadatos o de origen. (Heredado de Compilation)
CreateDefaultWin32Resources(Boolean, Boolean, Stream, Stream)	Cree una secuencia rellenada con recursos win32 predeterminados. (Heredado de Compilation)
CreateErrorNamespaceSymbol(INamespaceSymbol, String)	Devuelve un nuevo espacio de nombres INamespaceSymbol que representa un espacio de nombres de error (falta) con el nombre especificado. (Heredado de Compilation)
CreateErrorTypeSymbol(INamespaceOrTypeSymbol, String, Int32)	Devuelve un nuevo INamedTypeSymbol que representa un tipo de error con el nombre y la aridad especificados en el contenedor opcional especificado. (Heredado de Compilation)
CreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>)	Devuelve un nuevo IFunctionPointerTypeSymbol que representa un tipo de puntero de función asociado a los tipos de esta compilación. (Heredado de Compilation)
CreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>, SignatureCallingConvention, ImmutableArray<INamedTypeSymbol>)	Devuelve un nuevo IFunctionPointerTypeSymbol que representa un tipo de puntero de función asociado a los tipos de esta compilación. (Heredado de Compilation)
CreateNativeIntegerTypeSymbol(Boolean)	Devuelve un nuevo INamedTypeSymbol que representa un entero nativo. (Heredado de Compilation)
CreatePointerTypeSymbol(ITypeSymbol)	Devuelve un nuevo IPointerTypeSymbol que representa un tipo de puntero asociado a un tipo de esta compilación. (Heredado de Compilation)
CreateScriptCompilation(String, SyntaxTree, IEnumerable<MetadataReference>, CSharpCompilationOptions, CSharpCompilation, Type, Type)	Crea una nueva compilación que se puede usar en el scripting.
CreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>)	Devuelve un nuevo INamedTypeSymbol con los tipos de elemento, los nombres y las ubicaciones especificados. (Heredado de Compilation)
CreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	Devuelve un nuevo INamedTypeSymbol con los tipos de elementos especificados y los nombres de elementos (opcionales), las ubicaciones y las anotaciones que aceptan valores NULL. (Heredado de Compilation)
CreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>)	Devuelve un nuevo INamedTypeSymbol con el tipo y las ubicaciones subyacentes especificados. El tipo subyacente debe ser compatible con tupla. (Heredado de Compilation)
CreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	Devuelve un nuevo INamedTypeSymbol con los nombres de elemento subyacente y (opcional) especificados, ubicaciones y anotaciones que aceptan valores NULL. El tipo subyacente debe ser compatible con tupla. (Heredado de Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, CancellationToken)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, IMethodSymbol, CancellationToken)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, IMethodSymbol, Stream, IEnumerable<EmbeddedText>, CancellationToken)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, IMethodSymbol, Stream, IEnumerable<EmbeddedText>, Stream, CancellationToken)	Emita el IL para el código fuente compilado en la secuencia especificada. (Heredado de Compilation)
EmitDifference(EmitBaseline, IEnumerable<SemanticEdit>, Func<ISymbol,Boolean>, Stream, Stream, Stream, CancellationToken)	Emita las diferencias entre la compilación y la generación anterior para Editar y continuar. Las diferencias se expresan como símbolos agregados y modificados, y se emiten como metadatos, IL y deltas de PDB. Se devuelve una representación de la compilación actual como EmitBaseline para su uso en una edición y continuación posteriores. (Heredado de Compilation)
EmitDifference(EmitBaseline, IEnumerable<SemanticEdit>, Func<ISymbol, Boolean>, Stream, Stream, Stream, ICollection<MethodDefinitionHandle>, CancellationToken)	Obsoletos. Emita las diferencias entre la compilación y la generación anterior para Editar y continuar. Las diferencias se expresan como símbolos agregados y modificados, y se emiten como metadatos, IL y deltas de PDB. Se devuelve una representación de la compilación actual como EmitBaseline para su uso en una edición y continuación posteriores. (Heredado de Compilation)
EmitDifference(EmitBaseline, IEnumerable<SemanticEdit>, Stream, Stream, Stream, ICollection<MethodDefinitionHandle>, CancellationToken)	Obsoletos. Emita las diferencias entre la compilación y la generación anterior para Editar y continuar. Las diferencias se expresan como símbolos agregados y modificados, y se emiten como metadatos, IL y deltas de PDB. Se devuelve una representación de la compilación actual como EmitBaseline para su uso en una edición y continuación posteriores. (Heredado de Compilation)
GetAssemblyOrModuleSymbol(MetadataReference)	Obtiene o IAssemblySymbol IModuleSymbol para una referencia de metadatos usada para crear esta compilación. (Heredado de Compilation)
GetCompilationNamespace(INamespaceSymbol)	Obtiene el espacio de nombres de compilación correspondiente para el módulo o el espacio de nombres de ensamblado especificados. (Heredado de Compilation)
GetDeclarationDiagnostics(CancellationToken)	Obtiene los diagnósticos generados durante los encabezados de declaración de símbolos. Por ejemplo, no hay ningún diagnóstico para los cuerpos de descriptor de acceso o método.
GetDiagnostics(CancellationToken)	Obtiene todos los diagnósticos de la compilación, incluida la sintaxis, la declaración y el enlace. No incluye ningún diagnóstico que se pueda producir durante la emisión.
GetDirectiveReference(ReferenceDirectiveTriviaSyntax)	Devuelve una referencia de metadatos a la que se resuelve un #r determinado.
GetEntryPoint(CancellationToken)	Devuelve el método Main que actúa como punto de entrada del ensamblado, si es ejecutable (y no un script). (Heredado de Compilation)
GetMetadataReference(IAssemblySymbol)	Obtiene el MetadataReference objeto que corresponde al símbolo de ensamblado.
GetMethodBodyDiagnostics(CancellationToken)	Obtiene los diagnósticos generados durante el análisis de cuerpos de método y inicializadores de campo.
GetParseDiagnostics(CancellationToken)	Obtiene los diagnósticos generados durante la fase de análisis de una compilación. No hay diagnósticos para declaraciones o descriptores de acceso o cuerpos de método, por ejemplo.
GetSemanticModel(SyntaxTree, Boolean)	Obtiene un nuevo syntaxTreeSemanticModel para el árbol de sintaxis especificado.
GetSpecialType(SpecialType)	Obtenga el símbolo del tipo predefinido de la biblioteca de Cor a la que hace referencia esta compilación. (Heredado de Compilation)
GetSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken)	Devuelve símbolos de declaración de origen cuyo nombre cumple el predicado especificado.
GetSymbolsWithName(String, SymbolFilter, CancellationToken)	Devuelve símbolos de declaración de origen cuyo nombre coincide con el nombre proporcionado. Esto será más rápido que GetSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken) cuando el predicado es simplemente una comprobación de cadena simple. `name` distingue mayúsculas de minúsculas.
GetTypeByMetadataName(String)	Obtiene el tipo dentro del ensamblado de la compilación y todos los ensamblados a los que se hace referencia (excepto aquellos a los que solo se puede hacer referencia a través de un alias extern) mediante su nombre de metadatos CLR canónico. Esta búsqueda sigue el orden siguiente: Si el tipo se encuentra en el ensamblado de la compilación, se devuelve ese tipo. A continuación, se busca en la biblioteca principal (la biblioteca que define `System.Object` y no tiene referencias de ensamblado). Si el tipo se encuentra allí, se devuelve ese tipo. Por último, se busca en todos los ensamblados no extern a los que se hace referencia. Si se encuentra uno y solo un tipo que coincida con el nombre de metadatos proporcionado, se devuelve ese tipo único. La accesibilidad se omite para esta comprobación. (Heredado de Compilation)
GetTypesByMetadataName(String)	Obtiene todos los tipos con el ensamblado de la compilación y todos los ensamblados a los que se hace referencia que tienen el nombre de metadatos CLR canónicos especificado. La accesibilidad al ensamblado actual se omite al buscar nombres de tipo coincidentes. (Heredado de Compilation)
GetUnreferencedAssemblyIdentities(Diagnostic)	Dados los Diagnostic informes sin referencias AssemblyIdentity, devuelve las instancias reales AssemblyIdentity a las que no se hace referencia. (Heredado de Compilation)
GetUsedAssemblyReferences(CancellationToken)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
GetUsedAssemblyReferences(CancellationToken)	Referencias de ensamblado de metadatos únicas que se consideran usadas por esta compilación. Por ejemplo, si se hace referencia a un tipo declarado en un ensamblado al que se hace referencia en el código fuente de esta compilación, se considera que se usa la referencia. Etc. El conjunto devuelto es un subconjunto de referencias devueltas por References la API. El resultado no está definido si la compilación contiene errores. El efecto de los espacios de nombres importados en el resultado de esta API depende de si la creación de informes de importaciones sin usar está deshabilitada para la compilación. La creación de informes de importaciones sin usar está deshabilitada si DocumentationMode se establece en None. Cuando los informes de importaciones no usados están deshabilitados, todos los ensamblados a los que se hace referencia contienen cualquier tipo que pertenezca a espacios de nombres importados se incluyen en el resultado. Es decir, considerado utilizado. Cuando se habilitan los informes de importaciones sin usar, los espacios de nombres importados no tienen efecto en el resultado de esta API. Por lo tanto, al quitar las referencias de ensamblado que no están en el resultado, podría producirse el error "CS0246: No se encontró el nombre del tipo o del espacio de nombres (¿falta una directiva using o una referencia de ensamblado?) en una importación de espacio de nombres sin usar. Sin embargo, el compilador notificaría esa importación como sin usar para la compilación en la que se invocó esta API. Para evitar los errores, se recomienda quitar las referencias de ensamblado sin usar y las importaciones sin usar al mismo tiempo. (Heredado de Compilation)
HasImplicitConversion(ITypeSymbol, ITypeSymbol)	Devuelve true si hay una conversión implícita (C#) o de ampliación (VB) de `fromType` a `toType`. Devuelve false si o `fromTypetoType` es NULL, o si no existe dicha conversión. (Heredado de Compilation)
IsSymbolAccessibleWithin(ISymbol, ISymbol, ITypeSymbol)	Comprueba si `symbol` es accesible desde dentro de `within`. Se usa un calificador opcional de tipo `throughType` para resolver el acceso protegido para los miembros de instancia. Todos los símbolos deben ser de esta compilación o de algún ensamblado al que hace referencia esta compilación (References). `within` es necesario que sea o INamedTypeSymbol IAssemblySymbol. (Heredado de Compilation)
RemoveAllReferences()	Crea una nueva compilación sin referencias de metadatos
RemoveAllSyntaxTrees()	Crea una nueva compilación sin árboles de sintaxis. Conserva la información de metadatos de esta compilación para su uso con árboles agregados más adelante.
RemoveReferences(IEnumerable<MetadataReference>)	Crea una nueva compilación sin las referencias de metadatos especificadas.
RemoveReferences(MetadataReference[])	Crea una nueva compilación sin las referencias de metadatos especificadas.
RemoveSyntaxTrees(IEnumerable<SyntaxTree>)	Crea una nueva compilación sin los árboles de sintaxis especificados. Conserva la información de metadatos para su uso con árboles agregados más adelante.
RemoveSyntaxTrees(SyntaxTree[])	Crea una nueva compilación sin los árboles de sintaxis especificados. Conserva la información de metadatos para su uso con árboles agregados más adelante.
ReplaceReference(MetadataReference, MetadataReference)	Crea una nueva compilación con una referencia de metadatos antigua reemplazada por una nueva referencia de metadatos.
ReplaceSyntaxTree(SyntaxTree, SyntaxTree)	Crea una nueva compilación sin el árbol antiguo, pero con el nuevo árbol.
SupportsRuntimeCapability(RuntimeCapability)	Determina si el entorno de ejecución Compilation que tiene como destino admite una funcionalidad determinada. (Heredado de Compilation)
ToMetadataReference(ImmutableArray<String>, Boolean)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
WithAssemblyName(String)	Crea una nueva compilación con el nombre especificado.
WithOptions(CompilationOptions)	Crea una nueva compilación con las opciones de compilación especificadas. (Heredado de Compilation)
WithOptions(CSharpCompilationOptions)	Crea una nueva compilación con las opciones de compilación especificadas.
WithReferences(IEnumerable<MetadataReference>)	Crea una nueva compilación con las referencias especificadas.
WithReferences(MetadataReference[])	Crea una nueva compilación con las referencias especificadas.
WithScriptCompilationInfo(CSharpScriptCompilationInfo)	Devuelve una nueva compilación con el conjunto de compilación especificado como el envío anterior.
WithScriptCompilationInfo(ScriptCompilationInfo)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior. (Heredado de Compilation)

Métodos de extensión

ClassifyConversion(Compilation, ITypeSymbol, ITypeSymbol)	El objeto de compilación es una representación inmutable de una sola invocación del compilador. Aunque es inmutable, una compilación también es a petición y se darán cuenta y almacenarán en caché los datos según sea necesario. Una compilación puede generar una nueva compilación a partir de la compilación existente con la aplicación de pequeños deltas. En muchos casos, es más eficaz que crear una nueva compilación desde cero, ya que la nueva compilación puede reutilizar la información de la compilación anterior.
Emit(CSharpCompilation, String, String, String, String, IEnumerable<ResourceDescription>, CancellationToken)	Emita el IL para la compilación en la secuencia especificada.
WithAnalyzers(Compilation, ImmutableArray<DiagnosticAnalyzer>, AnalyzerOptions)	Devuelve una nueva compilación con analizadores de diagnóstico adjuntos.
WithAnalyzers(Compilation, ImmutableArray<DiagnosticAnalyzer>, AnalyzerOptions, CancellationToken)	Obsoletos. Devuelve una nueva compilación con analizadores de diagnóstico adjuntos.
WithAnalyzers(Compilation, ImmutableArray<DiagnosticAnalyzer>, CompilationWithAnalyzersOptions)	Devuelve una nueva compilación con analizadores de diagnóstico adjuntos.
Emit(Compilation, String, String, String, String, IEnumerable<ResourceDescription>, CancellationToken)	Emita el IL para la compilación en la secuencia especificada.
AliasImports(Compilation)	Obtiene la propiedad AliasImports de compilación.
ClassifyConversion(Compilation, ITypeSymbol, ITypeSymbol)	Determina qué tipo de conversión hay entre los tipos especificados.
GetSpecialType(Compilation, SpecialType)	Obtiene el símbolo de tipo especial en la compilación actual.
MemberImports(Compilation)	Obtiene la propiedad MemberImports de compilación.
RootNamespace(Compilation)	Obtiene la propiedad RootNamespace de compilación.

Se aplica a

Compartir a través de