CSharpCompilation Classe

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.

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

Ereditarietà: Object

Compilation
CSharpCompilation

Campi

_features

(Ereditato da Compilation)

Proprietà

Assembly	Oggetto IAssemblySymbol che rappresenta l'assembly da creare. (Ereditato da Compilation)
AssemblyName	Nome dell'assembly semplice o Null se non specificato. (Ereditato da Compilation)
CommonAssembly	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonDynamicType	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonGlobalNamespace	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonObjectType	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonOptions	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonScriptClass	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonScriptGlobalsType	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonSourceModule	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonSyntaxTrees	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
DirectiveReferences	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
DynamicType	TypeSymbol per il tipo 'dynamic' in questa compilazione. (Ereditato da Compilation)
ExternalReferences	Riferimenti ai metadati passati al costruttore di compilazione. (Ereditato da Compilation)
GlobalNamespace	Spazio dei nomi radice che contiene tutti gli spazi dei nomi e i tipi definiti nel codice sorgente o nei metadati a cui si fa riferimento, uniti in una singola gerarchia di spazi dei nomi. (Ereditato da Compilation)
IsCaseSensitive	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
Language	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
LanguageVersion	Versione del linguaggio utilizzata per analizzare gli alberi della sintassi di questa compilazione.
ObjectType	INamedTypeSymbol per il tipo .NET System.Object, che potrebbe avere un typeKind di errore se non è presente alcuna libreria COR in questa compilazione. (Ereditato da Compilation)
Options	Le opzioni con cui è stata creata la compilazione.
ReferencedAssemblyNames	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
References	Tutti i riferimenti ai metadati, ovvero i riferimenti passati al costruttore di compilazione, nonché i riferimenti specificati tramite direttive #r. (Ereditato da Compilation)
ScriptClass	Simbolo che rappresenta la classe Script implicita. Valore Null se la classe non è definita nella compilazione. (Ereditato da Compilation)
ScriptCompilationInfo	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
SourceModule	Ottiene l'oggetto IModuleSymbol per il modulo creato compilando tutto il codice sorgente. (Ereditato da Compilation)
SyntaxTrees	Alberi della sintassi (analizzati dal codice sorgente) con cui è stata creata la compilazione.

Metodi

AddReferences(IEnumerable<MetadataReference>)	Crea una nuova compilazione con riferimenti di metadati aggiuntivi.
AddReferences(MetadataReference[])	Crea una nuova compilazione con riferimenti di metadati aggiuntivi.
AddSyntaxTrees(IEnumerable<SyntaxTree>)	Crea una nuova compilazione con alberi della sintassi aggiuntivi.
AddSyntaxTrees(SyntaxTree[])	Crea una nuova compilazione con alberi della sintassi aggiuntivi.
AppendDefaultVersionResource(Stream)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
ClassifyCommonConversion(ITypeSymbol, ITypeSymbol)	Classifica una conversione da `source` a `destination` in base al linguaggio di programmazione di questa compilazione.
ClassifyConversion(ITypeSymbol, ITypeSymbol)	Classifica una conversione da `source` a `destination`.
Clone()	Creare un duplicato di questa compilazione con istanze di simboli diverse.
CommonAddSyntaxTrees(IEnumerable<SyntaxTree>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonBindScriptClass()	Risolve un simbolo che rappresenta il contenitore di script (classe Script). Usa il nome completo della classe contenitore archiviata in ScriptClassName per trovare il simbolo. (Ereditato da Compilation)
CommonClone()	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonContainsSyntaxTree(SyntaxTree)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<Boolean>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<Boolean>, ImmutableArray<NullableAnnotation>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateArrayTypeSymbol(ITypeSymbol, Int32)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateArrayTypeSymbol(ITypeSymbol, Int32, NullableAnnotation)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol, ITypeSymbol)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateErrorNamespaceSymbol(INamespaceSymbol, String)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateErrorTypeSymbol(INamespaceOrTypeSymbol, String, Int32)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>, SignatureCallingConvention, ImmutableArray<INamedTypeSymbol>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateNativeIntegerTypeSymbol(Boolean)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreatePointerTypeSymbol(ITypeSymbol)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonCreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonGetAssemblyOrModuleSymbol(MetadataReference)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonGetCompilationNamespace(INamespaceSymbol)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonGetEntryPoint(CancellationToken)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonGetSemanticModel(SyntaxTree, Boolean)	Ottiene un SemanticModel oggetto per l'oggetto specificato `syntaxTree`. Se Microsoft.CodeAnalysis.Compilation.SemanticModelProvider è diverso da Null, tenta di usare Microsoft.CodeAnalysis.SemanticModelProvider.GetSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,Microsoft.CodeAnalysis.Compilation,System.Boolean) per ottenere un modello semantico. In caso contrario, crea un nuovo modello semantico usando Microsoft.CodeAnalysis.Compilation.CreateSemanticModel(Microsoft.CodeAnalysis.SyntaxTree,System.Boolean). (Ereditato da Compilation)
CommonGetSpecialType(SpecialType)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonGetTypeByMetadataName(String)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonRemoveAllSyntaxTrees()	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonRemoveSyntaxTrees(IEnumerable<SyntaxTree>)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonReplaceSyntaxTree(SyntaxTree, SyntaxTree)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonWithAssemblyName(String)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonWithOptions(CompilationOptions)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
CommonWithReferences(IEnumerable<MetadataReference>)	Crea una nuova compilazione con i riferimenti specificati. (Ereditato da Compilation)
CommonWithScriptCompilationInfo(ScriptCompilationInfo)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
ContainsSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken)	Restituisce true se è presente un nome di simbolo di dichiarazione di origine che soddisfa il predicato specificato.
ContainsSymbolsWithName(String, SymbolFilter, CancellationToken)	Restituisce true se è presente un nome di simbolo di dichiarazione di origine corrispondente al nome specificato. Questo sarà più veloce rispetto ContainsSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken) al momento in cui il predicato è solo un semplice controllo di stringa.
ContainsSyntaxTree(SyntaxTree)	Restituisce true se la compilazione contiene l'albero specificato. False in caso contrario.
Create(String, IEnumerable<SyntaxTree>, IEnumerable<MetadataReference>, CSharpCompilationOptions)	Crea una nuova compilazione da zero. I metodi come AddSyntaxTrees o AddReferences sull'oggetto restituito consentiranno di continuare a compilare la compilazione incrementale.
CreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Boolean>, ImmutableArray<Location>)	Restituisce un nuovo simbolo di tipo anonimo con i tipi, i nomi e i percorsi di origine specificati. Per impostazione predefinita, i membri di tipo anonimo saranno di sola lettura. Le proprietà scrivibili sono supportate in VB e possono essere create passando `false` nelle posizioni appropriate in `memberIsReadOnly`. (Ereditato da Compilation)
CreateAnonymousTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Boolean>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	Restituisce un nuovo simbolo di tipo anonimo con i tipi di membro, i nomi, le posizioni di origine e le annotazioni nullable specificati. Per impostazione predefinita, i membri di tipo anonimo saranno di sola lettura. Le proprietà scrivibili sono supportate in VB e possono essere create passando `false` nelle posizioni appropriate in `memberIsReadOnly`. (Ereditato da Compilation)
CreateArrayTypeSymbol(ITypeSymbol, Int32)	Restituisce un nuovo arrayTypeSymbol che rappresenta un tipo di matrice associato ai tipi di base della libreria COR in questa compilazione. (Ereditato da Compilation)
CreateArrayTypeSymbol(ITypeSymbol, Int32, NullableAnnotation)	Restituisce un nuovo arrayTypeSymbol che rappresenta un tipo di matrice associato ai tipi di base della libreria COR in questa compilazione. (Ereditato da Compilation)
CreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol)	Crea un oggetto IMethodSymbol il cui MethodKind oggetto è BuiltinOperator per un operatore unario. Gli operatori predefiniti vengono comunemente creati per simboli come `bool int.operator -(int value)` il linguaggio supportato in modo implicito, anche se tale simbolo non è definito in modo esplicito per quel tipo in un'origine o in metadati. (Ereditato da Compilation)
CreateBuiltinOperator(String, ITypeSymbol, ITypeSymbol, ITypeSymbol)	Crea un oggetto IMethodSymbol il cui MethodKind oggetto è BuiltinOperator per un operatore binario. Gli operatori predefiniti vengono comunemente creati per simboli come `bool int.operator ==(int v1, int v2)` il linguaggio supportato in modo implicito, anche se tale simbolo non è definito in modo esplicito per quel tipo in un'origine o in metadati. (Ereditato da Compilation)
CreateDefaultWin32Resources(Boolean, Boolean, Stream, Stream)	Creare un flusso pieno di risorse win32 predefinite. (Ereditato da Compilation)
CreateErrorNamespaceSymbol(INamespaceSymbol, String)	Restituisce un nuovo INamespaceSymbol che rappresenta uno spazio dei nomi di errore (mancante) con il nome specificato. (Ereditato da Compilation)
CreateErrorTypeSymbol(INamespaceOrTypeSymbol, String, Int32)	Restituisce un nuovo oggetto INamedTypeSymbol che rappresenta un tipo di errore con il nome e l'arità specificati nel contenitore facoltativo specificato. (Ereditato da Compilation)
CreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>)	Restituisce un nuovo oggetto IFunctionPointerTypeSymbol che rappresenta un tipo di puntatore a funzione associato ai tipi in questa compilazione. (Ereditato da Compilation)
CreateFunctionPointerTypeSymbol(ITypeSymbol, RefKind, ImmutableArray<ITypeSymbol>, ImmutableArray<RefKind>, SignatureCallingConvention, ImmutableArray<INamedTypeSymbol>)	Restituisce un nuovo oggetto IFunctionPointerTypeSymbol che rappresenta un tipo di puntatore a funzione associato ai tipi in questa compilazione. (Ereditato da Compilation)
CreateNativeIntegerTypeSymbol(Boolean)	Restituisce un nuovo oggetto INamedTypeSymbol che rappresenta un numero intero nativo. (Ereditato da Compilation)
CreatePointerTypeSymbol(ITypeSymbol)	Restituisce un nuovo IPointerTypeSymbol che rappresenta un tipo di puntatore associato a un tipo in questa compilazione. (Ereditato da Compilation)
CreateScriptCompilation(String, SyntaxTree, IEnumerable<MetadataReference>, CSharpCompilationOptions, CSharpCompilation, Type, Type)	Crea una nuova compilazione che può essere usata nello scripting.
CreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>)	Restituisce un nuovo oggetto INamedTypeSymbol con i tipi di elemento, i nomi e le posizioni specificati. (Ereditato da Compilation)
CreateTupleTypeSymbol(ImmutableArray<ITypeSymbol>, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	Restituisce un nuovo oggetto INamedTypeSymbol con i tipi di elemento specificati e (facoltativi) nomi di elementi, posizioni e annotazioni nullable. (Ereditato da Compilation)
CreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>)	Restituisce un nuovo oggetto INamedTypeSymbol con il tipo sottostante e i nomi e le posizioni degli elementi specificati. Il tipo sottostante deve essere compatibile con la tupla. (Ereditato da Compilation)
CreateTupleTypeSymbol(INamedTypeSymbol, ImmutableArray<String>, ImmutableArray<Location>, ImmutableArray<NullableAnnotation>)	Restituisce un nuovo oggetto INamedTypeSymbol con il tipo sottostante e (facoltativo) i nomi, le posizioni e le annotazioni nullable specificati. Il tipo sottostante deve essere compatibile con la tupla. (Ereditato da Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, CancellationToken)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, IMethodSymbol, CancellationToken)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, IMethodSymbol, Stream, IEnumerable<EmbeddedText>, CancellationToken)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)
Emit(Stream, Stream, Stream, Stream, IEnumerable<ResourceDescription>, EmitOptions, IMethodSymbol, Stream, IEnumerable<EmbeddedText>, Stream, CancellationToken)	Generare il codice sorgente compilato nel flusso specificato. (Ereditato da Compilation)
EmitDifference(EmitBaseline, IEnumerable<SemanticEdit>, Func<ISymbol,Boolean>, Stream, Stream, Stream, CancellationToken)	Generare le differenze tra la compilazione e la generazione precedente per Modifica e continuazione. Le differenze vengono espresse come simboli aggiunti e modificati e vengono generate come metadati, delta IL e PDB. Una rappresentazione della compilazione corrente viene restituita come EmitBaseline da utilizzare in una successiva modifica e continuazione. (Ereditato da Compilation)
EmitDifference(EmitBaseline, IEnumerable<SemanticEdit>, Func<ISymbol, Boolean>, Stream, Stream, Stream, ICollection<MethodDefinitionHandle>, CancellationToken)	Obsoleti. Generare le differenze tra la compilazione e la generazione precedente per Modifica e continuazione. Le differenze vengono espresse come simboli aggiunti e modificati e vengono generate come metadati, delta IL e PDB. Una rappresentazione della compilazione corrente viene restituita come EmitBaseline da utilizzare in una successiva modifica e continuazione. (Ereditato da Compilation)
EmitDifference(EmitBaseline, IEnumerable<SemanticEdit>, Stream, Stream, Stream, ICollection<MethodDefinitionHandle>, CancellationToken)	Obsoleti. Generare le differenze tra la compilazione e la generazione precedente per Modifica e continuazione. Le differenze vengono espresse come simboli aggiunti e modificati e vengono generate come metadati, delta IL e PDB. Una rappresentazione della compilazione corrente viene restituita come EmitBaseline da utilizzare in una successiva modifica e continuazione. (Ereditato da Compilation)
GetAssemblyOrModuleSymbol(MetadataReference)	Ottiene l'oggetto IAssemblySymbol o IModuleSymbol per un riferimento ai metadati utilizzato per creare questa compilazione. (Ereditato da Compilation)
GetCompilationNamespace(INamespaceSymbol)	Ottiene lo spazio dei nomi di compilazione corrispondente per il modulo o lo spazio dei nomi dell'assembly specificato. (Ereditato da Compilation)
GetDeclarationDiagnostics(CancellationToken)	Ottiene la diagnostica generata durante le intestazioni di dichiarazione dei simboli. Non sono disponibili diagnostica per le funzioni di accesso o i corpi dei metodi, ad esempio.
GetDiagnostics(CancellationToken)	Ottiene tutte le informazioni di diagnostica per la compilazione, inclusa la sintassi, la dichiarazione e l'associazione. Non include alcuna diagnostica che potrebbe essere prodotta durante l'emissione.
GetDirectiveReference(ReferenceDirectiveTriviaSyntax)	Restituisce un riferimento ai metadati in cui un determinato #r viene risolto.
GetEntryPoint(CancellationToken)	Restituisce il metodo Main che fungerà da punto di ingresso dell'assembly, se è eseguibile (e non uno script). (Ereditato da Compilation)
GetMetadataReference(IAssemblySymbol)	Ottiene l'oggetto MetadataReference che corrisponde al simbolo dell'assembly.
GetMethodBodyDiagnostics(CancellationToken)	Ottiene la diagnostica generata durante l'analisi dei corpi del metodo e degli inizializzatori di campo.
GetParseDiagnostics(CancellationToken)	Ottiene la diagnostica generata durante la fase di analisi di una compilazione. Non sono disponibili diagnostica per dichiarazioni o funzioni di accesso o corpi del metodo, ad esempio.
GetSemanticModel(SyntaxTree, Boolean)	Ottiene un nuovo oggetto SyntaxTreeSemanticModel per l'albero della sintassi specificato.
GetSpecialType(SpecialType)	Ottiene il simbolo per il tipo predefinito dalla libreria Cor a cui fa riferimento questa compilazione. (Ereditato da Compilation)
GetSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken)	Restituisce simboli di dichiarazione di origine il cui nome soddisfa il predicato specificato.
GetSymbolsWithName(String, SymbolFilter, CancellationToken)	Restituisce simboli di dichiarazione di origine il cui nome corrisponde al nome specificato. Questo sarà più veloce rispetto GetSymbolsWithName(Func<String,Boolean>, SymbolFilter, CancellationToken) al momento in cui il predicato è solo un semplice controllo di stringa. `name` applica la distinzione maiuscole/minuscole.
GetTypeByMetadataName(String)	Ottiene il tipo all'interno dell'assembly della compilazione e di tutti gli assembly a cui si fa riferimento (ad eccezione di quelli a cui è possibile fare riferimento solo tramite un alias extern) usando il relativo nome di metadati CLR canonico. Questa ricerca segue l'ordine seguente: Se il tipo viene trovato nell'assembly della compilazione, viene restituito tale tipo. Viene quindi eseguita la ricerca della libreria principale (la libreria che definisce `System.Object` e non contiene riferimenti ad assembly). Se il tipo viene trovato, viene restituito quel tipo. Infine, vengono eseguite ricerche in tutti gli assembly non extern a cui si fa riferimento rimanenti. Se viene trovato uno e un solo tipo corrispondente al nome dei metadati specificato, viene restituito il singolo tipo. L'accessibilità viene ignorata per questo controllo. (Ereditato da Compilation)
GetTypesByMetadataName(String)	Ottiene tutti i tipi con l'assembly della compilazione e tutti gli assembly a cui si fa riferimento con il nome dei metadati CLR canonico specificato. L'accessibilità all'assembly corrente viene ignorata durante la ricerca di nomi di tipi corrispondenti. (Ereditato da Compilation)
GetUnreferencedAssemblyIdentities(Diagnostic)	Dato un Diagnostic report senza riferimenti AssemblyIdentity, restituisce le istanze effettive AssemblyIdentity a cui non è stato fatto riferimento. (Ereditato da Compilation)
GetUsedAssemblyReferences(CancellationToken)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
GetUsedAssemblyReferences(CancellationToken)	Riferimenti di assembly di metadati univoci che vengono considerati usati da questa compilazione. Ad esempio, se viene fatto riferimento a un tipo dichiarato in un assembly a cui si fa riferimento nel codice sorgente all'interno di questa compilazione, il riferimento viene considerato da usare. And so on. Il set restituito è un subset di riferimenti restituiti dall'API References . Il risultato non è definito se la compilazione contiene errori. L'effetto degli spazi dei nomi importati sul risultato di questa API dipende dal fatto che la segnalazione delle importazioni inutilizzate sia disabilitata per la compilazione. La segnalazione delle importazioni inutilizzate è disabilitata se DocumentationMode è impostata su None. Quando la creazione di report sulle importazioni inutilizzate è disabilitata, tutti gli assembly a cui si fa riferimento contenenti tutti i tipi appartenenti agli spazi dei nomi importati vengono inclusi nel risultato. Vale a dire considerato usato. Quando la creazione di report sulle importazioni inutilizzate è abilitata, gli spazi dei nomi importati non hanno effetto sul risultato di questa API. Di conseguenza, la rimozione di riferimenti ad assembly non inclusi nel risultato potrebbe causare un errore "CS0246: Impossibile trovare il tipo o il nome dello spazio dei nomi (manca una direttiva using o un riferimento all'assembly?)" in un'importazione dello spazio dei nomi inutilizzata. Tuttavia, tale importazione verrebbe segnalata dal compilatore come inutilizzata per la compilazione in cui è stata richiamata questa API. Per evitare gli errori, è consigliabile rimuovere contemporaneamente riferimenti ad assembly inutilizzati e importazioni inutilizzate. (Ereditato da Compilation)
HasImplicitConversion(ITypeSymbol, ITypeSymbol)	Restituisce true se è presente una conversione implicita (C#) o di tipo widening (VB) da `fromType` a `toType`. Restituisce false se `fromType` o `toType` è null oppure se non esiste alcuna conversione di questo tipo. (Ereditato da Compilation)
IsSymbolAccessibleWithin(ISymbol, ISymbol, ITypeSymbol)	Controlla se `symbol` è accessibile dall'interno `within`di . Un qualificatore facoltativo di tipo `throughType` viene usato per risolvere l'accesso protetto per i membri dell'istanza. Tutti i simboli devono essere di questa compilazione o di alcuni assembly a cui fa riferimento (References) da questa compilazione. `within` deve essere un INamedTypeSymbol oggetto o IAssemblySymbol. (Ereditato da Compilation)
RemoveAllReferences()	Crea una nuova compilazione senza riferimenti ai metadati
RemoveAllSyntaxTrees()	Crea una nuova compilazione senza alberi della sintassi. Mantiene le informazioni sui metadati da questa compilazione per l'uso con alberi aggiunti in un secondo momento.
RemoveReferences(IEnumerable<MetadataReference>)	Crea una nuova compilazione senza i riferimenti ai metadati specificati.
RemoveReferences(MetadataReference[])	Crea una nuova compilazione senza i riferimenti ai metadati specificati.
RemoveSyntaxTrees(IEnumerable<SyntaxTree>)	Crea una nuova compilazione senza gli alberi della sintassi specificati. Mantiene le informazioni sui metadati da usare con alberi aggiunti in un secondo momento.
RemoveSyntaxTrees(SyntaxTree[])	Crea una nuova compilazione senza gli alberi della sintassi specificati. Mantiene le informazioni sui metadati da usare con alberi aggiunti in un secondo momento.
ReplaceReference(MetadataReference, MetadataReference)	Crea una nuova compilazione con un riferimento ai metadati precedente sostituito con un nuovo riferimento ai metadati.
ReplaceSyntaxTree(SyntaxTree, SyntaxTree)	Crea una nuova compilazione senza l'albero precedente, ma con la nuova struttura ad albero.
SupportsRuntimeCapability(RuntimeCapability)	Determina se il runtime Compilation di destinazione supporta una particolare funzionalità. (Ereditato da Compilation)
ToMetadataReference(ImmutableArray<String>, Boolean)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
WithAssemblyName(String)	Crea una nuova compilazione con il nome specificato.
WithOptions(CompilationOptions)	Crea una nuova compilazione con le opzioni di compilazione specificate. (Ereditato da Compilation)
WithOptions(CSharpCompilationOptions)	Crea una nuova compilazione con le opzioni di compilazione specificate.
WithReferences(IEnumerable<MetadataReference>)	Crea una nuova compilazione con i riferimenti specificati.
WithReferences(MetadataReference[])	Crea una nuova compilazione con i riferimenti specificati.
WithScriptCompilationInfo(CSharpScriptCompilationInfo)	Restituisce una nuova compilazione con la compilazione specificata impostata come invio precedente.
WithScriptCompilationInfo(ScriptCompilationInfo)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente. (Ereditato da Compilation)

Metodi di estensione

ClassifyConversion(Compilation, ITypeSymbol, ITypeSymbol)	L'oggetto di compilazione è una rappresentazione non modificabile di una singola chiamata del compilatore. Sebbene non modificabile, anche una compilazione è su richiesta e si rende conto e memorizza nella cache i dati in base alle esigenze. Una compilazione può produrre una nuova compilazione dalla compilazione esistente con l'applicazione di delta di piccole dimensioni. In molti casi, è più efficiente della creazione di una nuova compilazione da zero, perché la nuova compilazione può riutilizzare le informazioni dalla compilazione precedente.
Emit(CSharpCompilation, String, String, String, String, IEnumerable<ResourceDescription>, CancellationToken)	Generare il codice IL per la compilazione nel flusso specificato.
WithAnalyzers(Compilation, ImmutableArray<DiagnosticAnalyzer>, AnalyzerOptions)	Restituisce una nuova compilazione con analizzatori di diagnostica associati.
WithAnalyzers(Compilation, ImmutableArray<DiagnosticAnalyzer>, AnalyzerOptions, CancellationToken)	Obsoleti. Restituisce una nuova compilazione con analizzatori di diagnostica associati.
WithAnalyzers(Compilation, ImmutableArray<DiagnosticAnalyzer>, CompilationWithAnalyzersOptions)	Restituisce una nuova compilazione con analizzatori di diagnostica associati.
Emit(Compilation, String, String, String, String, IEnumerable<ResourceDescription>, CancellationToken)	Generare il codice IL per la compilazione nel flusso specificato.
AliasImports(Compilation)	Ottiene la proprietà AliasImports di compilazione.
ClassifyConversion(Compilation, ITypeSymbol, ITypeSymbol)	Determina il tipo di conversione tra i tipi specificati.
GetSpecialType(Compilation, SpecialType)	Ottiene il simbolo di tipo speciale nella compilazione corrente.
MemberImports(Compilation)	Ottiene la proprietà MemberImports di compilazione.
RootNamespace(Compilation)	Ottiene la proprietà RootNamespace di compilazione.

Si applica a

Condividi tramite