SyntaxEditor Classe

Définition

Espace de noms:

Microsoft.CodeAnalysis.Editing

Assembly:

Microsoft.CodeAnalysis.Workspaces.dll

Paquet:

Microsoft.CodeAnalysis.Workspaces.Common v5.0.0

Source:

SyntaxEditor.cs

Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante :

1. La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée.
2. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence.
3. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur.
4. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException.
5. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé.
6. La racine « actuelle » est ensuite retournée.

public ref class SyntaxEditor

public class SyntaxEditor

type SyntaxEditor = class

Public Class SyntaxEditor

Héritage

Object

SyntaxEditor

Dérivé

Microsoft.CodeAnalysis.Editing.DocumentEditor

Remarques

La stratégie d’édition ci-dessus génère une erreur pour qu’un client de l’éditeur ajoute une modification qui met à jour un nœud parent, puis ajoute une modification qui met à jour un nœud enfant (sauf si la modification parente est certaine de contenir l’enfant) et tente cette opération au moment de l’exécution. Si un client doit mettre à jour à la fois un enfant et un parent, il doit d’abord ajouter la modification de l’enfant, puis le changement parent. Et la modification parente doit passer un rappel « compute » approprié afin qu’il voit les résultats de la modification enfant.

Si un client souhaite effectuer un remplacement, recherchez la valeurSyntaxNode placée dans l’arborescence en ajoutant une annotation dédiée à ce nœud, puis recherchez-la dans le nœud « actuel » passé à un rappel « compute ».

Constructeurs

Nom	Description
SyntaxEditor(SyntaxNode, HostWorkspaceServices)	Crée une nouvelle instance SyntaxEditor.
SyntaxEditor(SyntaxNode, SolutionServices)	Crée une nouvelle instance SyntaxEditor.
SyntaxEditor(SyntaxNode, Workspace)	Obsolète. Crée une nouvelle instance SyntaxEditor.

Propriétés

Nom	Description
Generator	À SyntaxGenerator utiliser pour créer et modifier SyntaxNodeles données.
OriginalRoot	Qui SyntaxNode a été spécifié lors de la SyntaxEditor construction.

Méthodes

Nom	Description
GetChangedRoot()	Retourne le nœud racine modifié.
InsertAfter(SyntaxNode, IEnumerable<SyntaxNode>)	Insérez les nouveaux nœuds après le nœud spécifié déjà existant dans l’arborescence.
InsertAfter(SyntaxNode, SyntaxNode)	Insérez le nouveau nœud après le nœud spécifié déjà existant dans l’arborescence.
InsertBefore(SyntaxNode, IEnumerable<SyntaxNode>)	Insérez les nouveaux nœuds avant que le nœud spécifié soit déjà existant dans l’arborescence.
InsertBefore(SyntaxNode, SyntaxNode)	Insérez le nouveau nœud avant que le nœud spécifié soit déjà existant dans l’arborescence.
RemoveNode(SyntaxNode, SyntaxRemoveOptions)	Supprimez le nœud de l’arborescence.
RemoveNode(SyntaxNode)	Supprimez le nœud de l’arborescence.
ReplaceNode(SyntaxNode, Func<SyntaxNode,SyntaxGenerator,SyntaxNode>)	Remplacez le nœud spécifié par un nœud produit par la fonction.
ReplaceNode(SyntaxNode, SyntaxNode)	Remplacez le nœud spécifié par un autre nœud.
TrackNode(SyntaxNode)	Vérifiez que le nœud est suivi, même s’il n’est pas modifié.

Méthodes d’extension

Nom	Description
AddAttribute(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
AddAttributeArgument(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
AddBaseType(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
AddInterfaceType(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
AddMember(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
AddParameter(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
AddReturnAttribute(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
InsertMembers(SyntaxEditor, SyntaxNode, Int32, IEnumerable<SyntaxNode>)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
InsertParameter(SyntaxEditor, SyntaxNode, Int32, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetAccessibility(SyntaxEditor, SyntaxNode, Accessibility)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetExpression(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetGetAccessorStatements(SyntaxEditor, SyntaxNode, IEnumerable<SyntaxNode>)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetModifiers(SyntaxEditor, SyntaxNode, DeclarationModifiers)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetName(SyntaxEditor, SyntaxNode, String)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetSetAccessorStatements(SyntaxEditor, SyntaxNode, IEnumerable<SyntaxNode>)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetStatements(SyntaxEditor, SyntaxNode, IEnumerable<SyntaxNode>)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetType(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetTypeConstraint(SyntaxEditor, SyntaxNode, String, SpecialTypeConstraintKind, IEnumerable<SyntaxNode>)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.
SetTypeParameters(SyntaxEditor, SyntaxNode, IEnumerable<String>)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste de modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications s’appliquent SyntaxNode à l’arborescence d’origine pour laquelle l’éditeur est créé. La sémantique de l’application est la suivante : La racine d’origine fournie est utilisée comme racine « actuelle » pour toutes les opérations. Cette racine « actuelle » sera continuellement mise à jour, devenant la nouvelle racine « actuelle ». La racine d’origine n’est jamais modifiée. Chaque modification a son suivi donné SyntaxNode , à l’aide d’une SyntaxAnnotationracine « actuelle » qui les suit tous. Cela permet à ce même nœud de se trouver après l’application des modifications antérieures qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre où elle a été ajoutée à l’éditeur. Une modification tente d’abord de trouver sa SyntaxNode valeur dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécute sur ce nœud, supprime, remplace ou insère autour de ce nœud en fonction de la modification. Si la modification est passée à un délégué en tant qu’argument « compute », elle reçoit la SyntaxNode valeur trouvée dans la racine actuelle. La racine « actuelle » sera ensuite mise à jour en remplaçant le nœud actuel par le nouveau nœud calculé. La racine « actuelle » est ensuite retournée.