SyntaxEditor Classe

Définition

Espace de noms:

Microsoft.CodeAnalysis.Editing

Assembly:

Microsoft.CodeAnalysis.Workspaces.dll

Paquet:

Microsoft.CodeAnalysis.Workspaces.Common v4.9.2

Source:

SyntaxEditor.cs

Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence.
3. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur.
4. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException.
5. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 de modification ci-dessus génère une erreur pour un client de l’éditeur d’ajouter une modification qui met à jour un nœud parent, puis d’ajouter une modification qui met à jour un nœud enfant (sauf si la modification parente est certaine de contenir l’enfant), et la tentative de cette opération sera levée au moment de l’exécution. Si un client a besoin de mettre à jour un enfant et un parent, il doit d’abord ajouter la modification enfant, puis la modification parente. Et la modification parente doit passer un rappel « de calcul » approprié afin qu’elle voit les résultats de la modification enfant.

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

Constructeurs

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

Propriétés

Generator	SyntaxGenerator à utiliser pour créer et modifier SyntaxNodedes.
OriginalRoot	SyntaxNode qui a été spécifié lors de la SyntaxEditor construction.

Méthodes

GetChangedRoot()	Retourne le nœud racine modifié.
InsertAfter(SyntaxNode, IEnumerable<SyntaxNode>)	Insérez les nouveaux nœuds après que le nœud spécifié existe déjà dans l’arborescence.
InsertAfter(SyntaxNode, SyntaxNode)	Insérez le nouveau nœud après que le nœud spécifié existe déjà dans l’arborescence.
InsertBefore(SyntaxNode, IEnumerable<SyntaxNode>)	Insérez les nouveaux nœuds avant le nœud spécifié déjà existant dans l’arborescence.
InsertBefore(SyntaxNode, SyntaxNode)	Insérez le nouveau nœud avant le nœud spécifié 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érifie que le nœud est suivi, même s’il n’est pas modifié.

Méthodes d’extension

AddAttribute(SyntaxEditor, SyntaxNode, SyntaxNode)	Éditeur pour apporter des modifications à une arborescence de syntaxe. L’éditeur fonctionne en donnant une liste des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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 des modifications à effectuer dans une arborescence particulière dans l’ordre. Les modifications sont indiquées SyntaxNode dans 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’un SyntaxAnnotation, ce qui produit une racine « actuelle » qui les suit toutes. Cela permet de trouver ce même nœud après l’application des modifications précédentes qui mutent l’arborescence. Chaque modification est ensuite appliquée dans l’ordre dans lequel elle a été ajoutée à l’éditeur. Une modification tente d’abord de la trouver SyntaxNode dans la racine « actuelle ». Si ce nœud est introuvable, l’opération échoue avec un ArgumentException. La modification particulière s’exécutera sur ce nœud, en supprimant, en remplaçant ou en insérant autour de celui-ci en fonction de la modification. Si la modification est transmise à un délégué comme argument « compute », il reçoit le SyntaxNode trouvé 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.