SyntaxGenerator Classe

Définition

Espace de noms:

Microsoft.CodeAnalysis.Editing

Assembly:

Microsoft.CodeAnalysis.Workspaces.dll

Paquet:

Microsoft.CodeAnalysis.Workspaces.Common v4.9.2

Source:

SyntaxGenerator.cs

Fabrique indépendante du langage pour la création de nœuds de syntaxe.

Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages.

Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.

public ref class SyntaxGenerator abstract : Microsoft::CodeAnalysis::Host::ILanguageService

public abstract class SyntaxGenerator : Microsoft.CodeAnalysis.Host.ILanguageService

type SyntaxGenerator = class
    interface ILanguageService

Public MustInherit Class SyntaxGenerator
Implements ILanguageService

Héritage

Object

SyntaxGenerator

Implémente

ILanguageService

Constructeurs

SyntaxGenerator()

Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.

Champs

DefaultRemoveOptions

Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.

Méthodes

AddAccessors(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les accesseurs ajoutés.
AddAttributeArguments(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instance de l’attribut avec les arguments ajoutés.
AddAttributes(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instance d’une déclaration avec les attributs spécifiés ajoutés.
AddAttributes(SyntaxNode, SyntaxNode[])	Crée une instance d’une déclaration avec les attributs spécifiés ajoutés.
AddBaseType(SyntaxNode, SyntaxNode)	Ajoute un type de base à la déclaration
AddEventHandler(SyntaxNode, SyntaxNode)	Crée une instruction qui ajoute le gestionnaire donné à l’événement donné.
AddExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération d’ajout.
AddInterfaceType(SyntaxNode, SyntaxNode)	Ajoute un type d’interface à la déclaration
AddMembers(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les membres ajoutés à la fin.
AddMembers(SyntaxNode, SyntaxNode[])	Crée une instance de la déclaration avec les membres ajoutés à la fin.
AddNamespaceImports(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les importations d’espaces de noms ajoutées.
AddNamespaceImports(SyntaxNode, SyntaxNode[])	Crée une instance de la déclaration avec les importations d’espaces de noms ajoutées.
AddParameters(SyntaxNode, IEnumerable<SyntaxNode>)	Ajoute les paramètres à la déclaration.
AddReturnAttributes(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instance d’une déclaration de méthode avec des attributs de retour ajoutés.
AddReturnAttributes(SyntaxNode, SyntaxNode[])	Crée une instance d’un nœud de déclaration de méthode avec des attributs de retour ajoutés.
AddSwitchSections(SyntaxNode, IEnumerable<SyntaxNode>)	Ajoute les sections switch à l’instruction .
AliasImportDeclaration(String, INamespaceOrTypeSymbol)	Crée une déclaration d’importation d’alias.
AliasImportDeclaration(String, SyntaxNode)	Crée une déclaration d’importation d’alias.
Argument(RefKind, SyntaxNode)	Crée un nœud qui est un argument pour un appel.
Argument(String, RefKind, SyntaxNode)	Crée un nœud qui est un argument pour un appel.
Argument(SyntaxNode)	Crée un nœud qui est un argument pour un appel.
ArrayCreationExpression(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une expression de création de tableau pour un tableau unidimensionnel avec des valeurs d’élément initiales spécifiées.
ArrayCreationExpression(SyntaxNode, SyntaxNode)	Crée une expression de création de tableau pour un tableau unidimensionnel de taille spécifiée.
ArrayTypeExpression(SyntaxNode)	Crée une expression qui indique un type de tableau.
AsPrivateInterfaceImplementation(SyntaxNode, SyntaxNode)	Convertit les déclarations de méthode, de propriété et d’indexeur en implémentations d’interface privée. Cela équivaut à une implémentation d’interface C# explicite (vous pouvez la déclarer pour l’accès via l’interface, mais ne pouvez pas l’appeler directement).
AsPrivateInterfaceImplementation(SyntaxNode, SyntaxNode, String)	Convertit les déclarations de méthode, de propriété et d’indexeur en implémentations d’interface privée. Cela équivaut à une implémentation d’interface C# explicite (vous pouvez la déclarer pour l’accès via l’interface, mais ne pouvez pas l’appeler directement).
AsPublicInterfaceImplementation(SyntaxNode, SyntaxNode)	Convertit les déclarations de méthode, de propriété et d’indexeur en implémentations d’interface publique. Cela équivaut à une implémentation implicite de l’interface C# (vous pouvez y accéder via l’interface ou directement via le membre nommé.)
AsPublicInterfaceImplementation(SyntaxNode, SyntaxNode, String)	Convertit les déclarations de méthode, de propriété et d’indexeur en implémentations d’interface publique. Cela équivaut à une implémentation implicite de l’interface C# (vous pouvez y accéder via l’interface ou directement via le membre nommé.)
AssignmentStatement(SyntaxNode, SyntaxNode)	Crée une expression qui indique une affectation de l’argument de droite à l’argument de gauche.
Attribute(AttributeData)	Crée un attribut correspondant aux données d’attribut existantes.
Attribute(String, IEnumerable<SyntaxNode>)	Crée un attribut.
Attribute(String, SyntaxNode[])	Crée un attribut.
Attribute(SyntaxNode, IEnumerable<SyntaxNode>)	Crée un attribut.
AttributeArgument(String, SyntaxNode)	Crée un argument d’attribut.
AttributeArgument(SyntaxNode)	Crée un argument d’attribut.
AwaitExpression(SyntaxNode)	Crée une expression await.
BaseExpression()	Crée une expression qui indique le paramètre de base de la méthode conteneur.
BitwiseAndExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération au niveau du bit et .
BitwiseNotExpression(SyntaxNode)	Crée une expression qui indique une opération sans bits
BitwiseOrExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération au niveau du bit ou .
CastExpression(ITypeSymbol, SyntaxNode)	Crée une expression qui indique une opération de conversion de type.
CastExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de conversion de type.
CatchClause(ITypeSymbol, String, IEnumerable<SyntaxNode>)	Crée une clause catch.
CatchClause(SyntaxNode, String, IEnumerable<SyntaxNode>)	Crée une clause catch.
ClassDeclaration(String, IEnumerable<String>, Accessibility, DeclarationModifiers, SyntaxNode, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration de classe.
ClearTrivia<TNode>(TNode)	Crée une instance du nœud avec les trivia de début et de fin supprimées et remplacées par des marqueurs élastiques.
CoalesceExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de fusion.
CompilationUnit(IEnumerable<SyntaxNode>)	Crée une déclaration d’unité de compilation
CompilationUnit(SyntaxNode[])	Crée une déclaration d’unité de compilation
ConditionalAccessExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération d’accès conditionnel. Utilisez MemberBindingExpression(SyntaxNode) et ElementBindingExpression(IEnumerable<SyntaxNode>) pour générer l’argument whenNotNull .
ConditionalExpression(SyntaxNode, SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération d’évaluation conditionnelle.
ConstructorDeclaration(IMethodSymbol, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Créer une déclaration de constructeur à l’aide de
ConstructorDeclaration(String, IEnumerable<SyntaxNode>, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration de constructeur.
ConvertExpression(ITypeSymbol, SyntaxNode)	Crée une expression qui indique une opération de conversion de type.
ConvertExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de conversion de type.
CustomEventDeclaration(IEventSymbol, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration d’événement personnalisée à partir d’un symbole d’événement existant.
CustomEventDeclaration(String, SyntaxNode, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration d’événement personnalisée.
Declaration(ISymbol)	Crée une déclaration correspondant à un symbole existant.
DefaultExpression(ITypeSymbol)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
DefaultExpression(SyntaxNode)	Expression qui représente la valeur par défaut d’un type. Il s’agit généralement d’une valeur Null pour les types référence ou d’une valeur vide pour les types valeur.
DefaultSwitchSection(IEnumerable<SyntaxNode>)	Crée une section par défaut pour une instruction switch.
DelegateDeclaration(String, IEnumerable<SyntaxNode>, IEnumerable<String>, SyntaxNode, Accessibility, DeclarationModifiers)	Crée une déclaration de délégué.
DivideExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de division.
DottedName(String)	Crée une expression de nom à partir d’une chaîne de nom en pointillés.
ElementAccessExpression(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une expression qui accède à un élément d’un tableau ou d’un indexeur.
ElementAccessExpression(SyntaxNode, SyntaxNode[])	Crée une expression qui accède à un élément d’un tableau ou d’un indexeur.
ElementBindingExpression(IEnumerable<SyntaxNode>)	Crée une expression qui indique une opération de liaison d’élément.
ElementBindingExpression(SyntaxNode[])	Crée une expression qui indique une opération de liaison d’élément.
EnumDeclaration(String, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>)	Crée une déclaration enum.
EnumMember(String, SyntaxNode)	Crée un membre enum
EventDeclaration(IEventSymbol)	Crée une déclaration d’événement à partir d’un symbole d’événement existant
EventDeclaration(String, SyntaxNode, Accessibility, DeclarationModifiers)	Crée une déclaration d’événement.
ExitSwitchStatement()	Créez une instruction qui quitte une instruction switch et continue après celle-ci.
ExpressionStatement(SyntaxNode)	Crée une instruction qui permet à une expression de s’exécuter dans un contexte d’instruction. Il s’agit généralement d’un appel ou d’une expression d’affectation.
FalseLiteralExpression()	Crée une expression qui indique le faux littéral booléen.
FieldDeclaration(IFieldSymbol)	Crée une déclaration de champ correspondant à un symbole de champ existant.
FieldDeclaration(IFieldSymbol, SyntaxNode)	Crée une déclaration de champ correspondant à un symbole de champ existant.
FieldDeclaration(String, SyntaxNode, Accessibility, DeclarationModifiers, SyntaxNode)	Crée une déclaration de champ.
GenericName(String, IEnumerable<ITypeSymbol>)	Crée une expression qui indique un nom d’identificateur générique.
GenericName(String, IEnumerable<SyntaxNode>)	Crée une expression qui indique un nom d’identificateur générique.
GenericName(String, ITypeSymbol[])	Crée une expression qui indique un nom d’identificateur générique.
GenericName(String, SyntaxNode[])	Crée une expression qui indique un nom d’identificateur générique.
GetAccessibility(SyntaxNode)	Obtient l’accessibilité de la déclaration.
GetAccessor(SyntaxNode, DeclarationKind)	Obtient l’accesseur du type spécifié pour la déclaration.
GetAccessorDeclaration(Accessibility, IEnumerable<SyntaxNode>)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
GetAccessors(SyntaxNode)	Obtient les accesseurs pour la déclaration.
GetAttributeArguments(SyntaxNode)	Obtient les arguments d’attribut pour la déclaration d’attribut.
GetAttributes(SyntaxNode)	Obtient les attributs d’une déclaration, sans inclure les attributs de retour.
GetBaseAndInterfaceTypes(SyntaxNode)	Obtient la liste des types de base et d’interface pour la déclaration.
GetDeclaration(SyntaxNode)	Retourne le nœud s’il s’agit d’une déclaration, la déclaration englobante immédiate s’il en existe une ou null.
GetDeclaration(SyntaxNode, DeclarationKind)	Retourne la déclaration englobante du type spécifié ou null.
GetDeclarationKind(SyntaxNode)	Obtient le DeclarationKind pour la déclaration.
GetExpression(SyntaxNode)	Obtient l’expression associée à la déclaration.
GetGenerator(Document)	Obtient le SyntaxGenerator pour la langue correspondant au document.
GetGenerator(Project)	Obtient le SyntaxGenerator pour la langue correspondant au projet.
GetGenerator(Workspace, String)	Obtient le SyntaxGenerator pour la langue spécifiée.
GetGetAccessorStatements(SyntaxNode)	Obtient les instructions du corps de l’accesseur get de la déclaration.
GetMembers(SyntaxNode)	Obtient les membres actuels de la déclaration.
GetModifiers(SyntaxNode)	Obtient le DeclarationModifiers pour la déclaration.
GetName(SyntaxNode)	Obtient le nom de la déclaration.
GetNamespaceImports(SyntaxNode)	Obtient les importations d’espace de noms qui font partie de la déclaration.
GetParameters(SyntaxNode)	Obtient la liste des paramètres de la déclaration.
GetReturnAttributes(SyntaxNode)	Obtient les attributs de retour de la déclaration.
GetSetAccessorStatements(SyntaxNode)	Obtient les instructions du corps du set-accesseur de la déclaration.
GetStatements(SyntaxNode)	Obtient les instructions du corps de la déclaration.
GetSwitchSections(SyntaxNode)	Obtient la liste des sections de commutateur pour l’instruction.
GetType(SyntaxNode)	Obtient le type de la déclaration.
GreaterThanExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération de test supérieure à celle-ci.
GreaterThanOrEqualExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de test supérieure à ou égale.
IdentifierName(String)	Crée une expression qui désigne un nom d’identificateur simple.
IfStatement(SyntaxNode, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une instruction if
IfStatement(SyntaxNode, IEnumerable<SyntaxNode>, SyntaxNode)	Crée une instruction if
IndexerDeclaration(IEnumerable<SyntaxNode>, SyntaxNode, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration d’indexeur.
IndexerDeclaration(IPropertySymbol, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration d’indexeur correspondant à un symbole d’indexeur existant.
IndexOf<T>(IReadOnlyList<T>, T)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
InsertAccessors(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les accesseurs insérés.
InsertAttributeArguments(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Crée une instance de l’attribut avec les arguments insérés.
InsertAttributes(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les attributs insérés.
InsertAttributes(SyntaxNode, Int32, SyntaxNode[])	Crée une instance de la déclaration avec les attributs insérés.
InsertMembers(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les membres insérés.
InsertMembers(SyntaxNode, Int32, SyntaxNode[])	Crée une instance de la déclaration avec les membres insérés.
InsertNamespaceImports(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Crée une instance de la déclaration avec les importations d’espace de noms insérées.
InsertNamespaceImports(SyntaxNode, Int32, SyntaxNode[])	Crée une instance de la déclaration avec les importations d’espace de noms insérées.
InsertNodesAfter(SyntaxNode, SyntaxNode, IEnumerable<SyntaxNode>)	Insère le nouveau nœud avant la déclaration spécifiée.
InsertNodesBefore(SyntaxNode, SyntaxNode, IEnumerable<SyntaxNode>)	Insère le nouveau nœud avant la déclaration spécifiée.
InsertParameters(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Insère les paramètres à l’index spécifié dans la déclaration.
InsertReturnAttributes(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Crée une instance d’une déclaration de méthode avec des attributs de retour insérés.
InsertReturnAttributes(SyntaxNode, Int32, SyntaxNode[])	Crée une instance d’une déclaration de méthode avec des attributs de retour insérés.
InsertSwitchSections(SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Insère les sections de commutateur à l’index spécifié dans l’instruction.
InterfaceDeclaration(String, IEnumerable<String>, Accessibility, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration d’interface.
InvocationExpression(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une expression d’appel.
InvocationExpression(SyntaxNode, SyntaxNode[])	Crée une expression d’appel
IsTypeExpression(SyntaxNode, ITypeSymbol)	Crée une expression qui désigne une opération is-type-case activée.
IsTypeExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération is-type-case activée.
LambdaParameter(String, ITypeSymbol)	Crée un paramètre lambda.
LambdaParameter(String, SyntaxNode)	Crée un paramètre lambda.
LessThanExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération de test inférieure à celle du test.
LessThanOrEqualExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération de test inférieure ou égale.
LiteralExpression(Object)	Crée une expression littérale. Il s’agit généralement de primitives numériques, de chaînes ou de caractères.
LocalDeclarationStatement(ITypeSymbol, String, SyntaxNode, Boolean)	Crée une instruction qui déclare une variable locale unique.
LocalDeclarationStatement(String, SyntaxNode)	Crée une instruction qui déclare une variable locale unique.
LocalDeclarationStatement(SyntaxNode, String, SyntaxNode, Boolean)	Crée une instruction qui déclare une variable locale unique.
LockStatement(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instruction qui représente un modèle de bloc de verrouillage.
LogicalAndExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération logique et.
LogicalNotExpression(SyntaxNode)	Crée une expression qui désigne une opération de non logique.
LogicalOrExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération logique ou.
MemberAccessExpression(SyntaxNode, String)	Crée une expression d’accès membre.
MemberAccessExpression(SyntaxNode, SyntaxNode)	Crée une expression d’accès membre.
MemberBindingExpression(SyntaxNode)	Crée une expression qui désigne une opération de liaison de membre.
MethodDeclaration(IMethodSymbol, IEnumerable<SyntaxNode>)	Crée une déclaration de méthode correspondant à un symbole de méthode existant.
MethodDeclaration(String, IEnumerable<SyntaxNode>, IEnumerable<String>, SyntaxNode, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>)	Crée une déclaration de méthode.
ModuloExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération modulo.
MultiplyExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération de multiplication.
NameExpression(INamespaceOrTypeSymbol)	Crée un nom qui désigne un type ou un espace de noms.
NameOfExpression(SyntaxNode)	Crée une expression nameof.
NamespaceDeclaration(String, IEnumerable<SyntaxNode>)	Crée une déclaration namespace.
NamespaceDeclaration(String, SyntaxNode[])	Crée une déclaration namespace.
NamespaceDeclaration(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une déclaration namespace.
NamespaceDeclaration(SyntaxNode, SyntaxNode[])	Crée une déclaration namespace.
NamespaceImportDeclaration(String)	Crée une déclaration d’importation d’espace de noms.
NamespaceImportDeclaration(SyntaxNode)	Crée une déclaration d’importation d’espace de noms.
NegateExpression(SyntaxNode)	Crée une expression qui désigne une opération de négation unaire.
NullableTypeExpression(SyntaxNode)	Crée une expression qui désigne un type nullable.
NullLiteralExpression()	Crée une expression qui désigne le littéral null.
ObjectCreationExpression(ITypeSymbol, IEnumerable<SyntaxNode>)	Crée une expression de création d’objet.
ObjectCreationExpression(ITypeSymbol, SyntaxNode[])	Crée une expression de création d’objet.
ObjectCreationExpression(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une expression de création d’objet.
ObjectCreationExpression(SyntaxNode, SyntaxNode[])	Crée une expression de création d’objet.
OperatorDeclaration(IMethodSymbol, IEnumerable<SyntaxNode>)	Crée un opérateur ou une déclaration de conversion correspondant à un symbole de méthode existant.
OperatorDeclaration(OperatorKind, IEnumerable<SyntaxNode>, SyntaxNode, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>)	Crée une déclaration de méthode.
ParameterDeclaration(IParameterSymbol, SyntaxNode)	Crée une déclaration de paramètre correspondant à un symbole de paramètre existant.
ParameterDeclaration(String, SyntaxNode, SyntaxNode, RefKind)	Crée une déclaration de paramètre.
PreserveTrivia<TNode>(TNode, Func<TNode,SyntaxNode>)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
PropertyDeclaration(IPropertySymbol, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration de propriété à l’aide d’un symbole de propriété existant comme signature.
PropertyDeclaration(String, SyntaxNode, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration de propriété. La propriété aura un get accesseur si IsWriteOnly est false et aura un set accesseur si IsReadOnly est false.
QualifiedName(SyntaxNode, SyntaxNode)	Crée une expression de nom qui désigne un nom qualifié. L’opérande de gauche peut être n’importe quelle expression de nom. L’opérande droit peut être l’identificateur et le nom générique.
ReferenceEqualsExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération de test d’égalité de type référence.
ReferenceNotEqualsExpression(SyntaxNode, SyntaxNode)	Crée une expression qui désigne une opération de test d’inégalité de type référence.
RemoveAllAttributes(SyntaxNode)	Supprime tous les attributs de la déclaration, y compris les attributs de retour.
RemoveEventHandler(SyntaxNode, SyntaxNode)	Crée une instruction qui supprime le gestionnaire donné de l’événement donné.
RemoveNode(SyntaxNode, SyntaxNode)	Supprime le nœud de la sous-arborescence en commençant à la racine.
RemoveNode(SyntaxNode, SyntaxNode, SyntaxRemoveOptions)	Supprime le nœud de la sous-arborescence en commençant à la racine.
RemoveNodes(SyntaxNode, IEnumerable<SyntaxNode>)	Supprime toutes les déclarations de la sous-arborescence en commençant à la racine.
RemoveRange<TNode>(SeparatedSyntaxList<TNode>, Int32, Int32)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
RemoveRange<TNode>(SyntaxList<TNode>, Int32, Int32)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
ReplaceNode(SyntaxNode, SyntaxNode, SyntaxNode)	Remplace le nœud dans l’arborescence de la racine par le nouveau nœud.
ReplaceRange(SyntaxNode, SyntaxNode, IEnumerable<SyntaxNode>)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
ReplaceWithTrivia(SyntaxNode, SyntaxNode, SyntaxNode)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
ReplaceWithTrivia(SyntaxNode, SyntaxToken, SyntaxToken)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
ReplaceWithTrivia<TNode>(SyntaxNode, TNode, Func<TNode,SyntaxNode>)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
ReturnStatement(SyntaxNode)	Crée une instruction qui peut être utilisée pour retourner une valeur à partir d’un corps de méthode.
SetAccessorDeclaration(Accessibility, IEnumerable<SyntaxNode>)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
StructDeclaration(String, IEnumerable<String>, Accessibility, DeclarationModifiers, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une déclaration struct.
SubtractExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de soustraction.
SwitchSection(IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une section pour une instruction switch.
SwitchSection(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une section à casse unique, une instruction switch.
SwitchStatement(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instruction switch qui branche des sections individuelles en fonction de la valeur de l’expression spécifiée.
SwitchStatement(SyntaxNode, SyntaxNode[])	Crée une instruction switch qui branche des sections individuelles en fonction de la valeur de l’expression spécifiée.
ThisExpression()	Crée une expression qui indique le paramètre this-parameter de la méthode contenant.
ThrowExpression(SyntaxNode)	Crée une expression qui peut être utilisée pour lever une exception.
ThrowStatement(SyntaxNode)	Crée une instruction qui peut être utilisée pour lever une exception.
TrueLiteralExpression()	Crée une expression qui indique le littéral vrai booléen.
TryCastExpression(SyntaxNode, ITypeSymbol)	Crée une expression qui indique une opération try-cast.
TryCastExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération try-cast.
TryCatchStatement(IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une instruction try-catch ou try-catch-finally.
TryCatchStatement(IEnumerable<SyntaxNode>, SyntaxNode[])	Crée une instruction try-catch ou try-catch-finally.
TryFinallyStatement(IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une instruction try-finally.
TupleElementExpression(ITypeSymbol, String)	Crée une expression qui indique un élément de tuple.
TupleElementExpression(SyntaxNode, String)	Crée une expression qui indique un élément de tuple.
TupleExpression(IEnumerable<SyntaxNode>)	Crée une expression de tuple.
TupleTypeExpression(IEnumerable<ITypeSymbol>, IEnumerable<String>)	Crée une expression qui indique un type de tuple.
TupleTypeExpression(IEnumerable<SyntaxNode>)	Crée une expression qui indique un type de tuple.
TupleTypeExpression(SyntaxNode[])	Crée une expression qui indique un type de tuple.
TypedConstantExpression(TypedConstant)	Crée une expression pour une constante typée.
TypeExpression(ITypeSymbol)	Crée une expression qui indique un type.
TypeExpression(ITypeSymbol, Boolean)	Crée une expression qui indique un type. Si addImport a la valeur false, ajoute un Microsoft.CodeAnalysis.Simplification.DoNotAddImportsAnnotation qui empêche l’ajout d’importations ou d’utilisations pour le type.
TypeExpression(SpecialType)	Crée une expression qui indique un nom de type spécial.
TypeOfExpression(SyntaxNode)	Crée une expression qui prend la valeur du type au moment de l’exécution.
UsingStatement(String, SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instruction qui représente un modèle using-block.
UsingStatement(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instruction qui représente un modèle using-block.
UsingStatement(SyntaxNode, String, SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instruction qui représente un modèle using-block.
ValueEqualsExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de test d’égalité de type valeur.
ValueNotEqualsExpression(SyntaxNode, SyntaxNode)	Crée une expression qui indique une opération de test d’inégalité de type valeur.
ValueReturningLambdaExpression(IEnumerable<SyntaxNode>)	Crée une expression qui déclare une valeur de paramètre zéro retournant une expression lambda.
ValueReturningLambdaExpression(IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une expression qui déclare une valeur retournant une expression lambda.
ValueReturningLambdaExpression(IEnumerable<SyntaxNode>, SyntaxNode)	Crée une expression qui déclare une valeur retournant une expression lambda.
ValueReturningLambdaExpression(String, IEnumerable<SyntaxNode>)	Crée une expression qui déclare une valeur de paramètre unique retournant une expression lambda.
ValueReturningLambdaExpression(String, SyntaxNode)	Crée une expression qui déclare une valeur de paramètre unique retournant une expression lambda.
ValueReturningLambdaExpression(SyntaxNode)	Crée une expression qui déclare une valeur de paramètre zéro retournant une expression lambda.
VoidReturningLambdaExpression(IEnumerable<SyntaxNode>)	Crée une expression qui déclare une expression lambda de retour de zéro paramètre void.
VoidReturningLambdaExpression(IEnumerable<SyntaxNode>, IEnumerable<SyntaxNode>)	Crée une expression qui déclare une expression lambda de retour void.
VoidReturningLambdaExpression(IEnumerable<SyntaxNode>, SyntaxNode)	Crée une expression qui déclare une expression lambda de retour void
VoidReturningLambdaExpression(String, IEnumerable<SyntaxNode>)	Crée une expression qui déclare une expression lambda retournée par un seul paramètre void.
VoidReturningLambdaExpression(String, SyntaxNode)	Crée une expression qui déclare une expression lambda retournée par un seul paramètre void.
VoidReturningLambdaExpression(SyntaxNode)	Crée une expression qui déclare une expression lambda de retour de zéro paramètre void.
WhileStatement(SyntaxNode, IEnumerable<SyntaxNode>)	Crée une instruction while-loop
WithAccessibility(SyntaxNode, Accessibility)	Modifie l’accessibilité de la déclaration.
WithAccessorDeclarations(SyntaxNode, IEnumerable<SyntaxNode>)	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
WithAccessorDeclarations(SyntaxNode, SyntaxNode[])	Fabrique indépendante du langage pour la création de nœuds de syntaxe. Cette API peut être utilisée pour créer des nœuds de syntaxe spécifiques au langage qui sont sémantiquement similaires entre les langages. Les arborescences générées par cette API essaieront de respecter les préférences de l’utilisateur lorsque cela est possible. Par exemple, la MemberAccessExpression(SyntaxNode, String) génération s’effectue de telle sorte que « this . » ou « Me. » soit simplifié en fonction de la préférence de l’utilisateur si Simplifier est utilisé.
WithExpression(SyntaxNode, SyntaxNode)	Modifie l’expression associée à la déclaration.
WithGetAccessorStatements(SyntaxNode, IEnumerable<SyntaxNode>)	Modifie les instructions pour le corps de l’accesseur get de la déclaration.
WithModifiers(SyntaxNode, DeclarationModifiers)	Modifie le DeclarationModifiers pour la déclaration.
WithName(SyntaxNode, String)	Modifie le nom de la déclaration.
WithSetAccessorStatements(SyntaxNode, IEnumerable<SyntaxNode>)	Modifie les instructions pour le corps de l’accesseur set de la déclaration.
WithStatements(SyntaxNode, IEnumerable<SyntaxNode>)	Modifie les instructions pour le corps de la déclaration.
WithType(SyntaxNode, SyntaxNode)	Modifie le type de la déclaration.
WithTypeArguments(SyntaxNode, IEnumerable<SyntaxNode>)	Convertit une expression qui se termine par un nom en expression qui se termine par un nom générique. Si l’expression se termine déjà par un nom générique, les nouveaux arguments de type sont utilisés à la place.
WithTypeArguments(SyntaxNode, SyntaxNode[])	Convertit une expression qui se termine par un nom en expression qui se termine par un nom générique. Si l’expression se termine déjà par un nom générique, les nouveaux arguments de type sont utilisés à la place.
WithTypeConstraint(SyntaxNode, String, SpecialTypeConstraintKind, IEnumerable<SyntaxNode>)	Ajoute une contrainte de type à un paramètre de type d’une déclaration.
WithTypeConstraint(SyntaxNode, String, SpecialTypeConstraintKind, SyntaxNode[])	Ajoute une contrainte de type à un paramètre de type d’une déclaration.
WithTypeConstraint(SyntaxNode, String, SyntaxNode[])	Ajoute une contrainte de type à un paramètre de type d’une déclaration.
WithTypeParameters(SyntaxNode, IEnumerable<String>)	Convertit une déclaration (méthode, classe, etc.) en déclaration avec des paramètres de type.
WithTypeParameters(SyntaxNode, String[])	Convertit une déclaration (méthode, classe, etc.) en déclaration avec des paramètres de type.