Prise en charge des extraits de Code dans un Service de langage héritéSupport for Code Snippets in a Legacy Language Service

Un extrait de code est un fragment de code est inséré dans le fichier source.A code snippet is a piece of code that is inserted into the source file. L’extrait de code est un modèle basé sur XML avec un ensemble de champs.The snippet itself is an XML-based template with a set of fields. Ces champs sont mis en surbrillance une fois l’extrait de code est inséré et peut avoir des valeurs différentes selon le contexte dans lequel l’extrait de code est inséré.These fields are highlighted after the snippet is inserted and can have different values depending on the context in which the snippet is inserted. Immédiatement après que l’extrait de code est inséré, le service de langage peut mettre en forme l’extrait de code.Immediately after the snippet is inserted, the language service can format the snippet.

L’extrait de code est inséré dans un mode d’édition spéciale qui permet les champs de l’extrait de code pour permettre une navigation à l’aide de la touche TAB.The snippet is inserted in a special edit mode that allows the fields of the snippet to be navigated by using the TAB key. Les champs peuvent prendre en charge les menus déroulants de style IntelliSense.The fields can support IntelliSense-style drop-down menus. L’utilisateur est validée sur l’extrait de code au fichier source en tapant l’entrée ou sur la touche ÉCHAP.The user commits the snippet to the source file by typing either the ENTER or the ESC key. Pour en savoir plus sur les extraits de code, consultez extraits de Code.To learn more about snippets, please see Code Snippets.

Les services de langage hérité sont implémentés en tant que partie d’un VSPackage, mais la plus récente pour implémenter des fonctionnalités de service de langage consiste à utiliser des extensions MEF.Legacy language services are implemented as part of a VSPackage, but the newer way to implement language service features is to use MEF extensions. Pour plus d’informations, consultez procédure pas à pas : implémentation des extraits de Code.To find out more, see Walkthrough: Implementing Code Snippets.

Note

Nous vous recommandons de commencer à utiliser l’API de l’éditeur de nouveau dès que possible.We recommend that you begin to use the new editor API as soon as possible. Cela améliorer les performances de votre service de langage et vous permettent de tirer parti des nouvelles fonctionnalités de l’éditeur.This will improve the performance of your language service and let you take advantage of new editor features.

Managed Package Framework prend en charge des extraits de CodeManaged Package Framework Support for Code Snippets

Managed package framework (MPF) prend en charge la plupart des fonctionnalités de l’extrait de code, de lire le modèle à insérer l’extrait de code et permettant spéciales en mode édition.The managed package framework (MPF) supports most snippet functionality, from reading the template to inserting the snippet and enabling the special edit mode. Prise en charge est gérée via la ExpansionProvider classe.Support is managed through the ExpansionProvider class.

Lorsque le Source classe est instanciée, la CreateExpansionProvider méthode dans le LanguageService classe est appelée pour obtenir un ExpansionProvider objet (Notez que la base de LanguageService classe retourne toujours un nouveau ExpansionProvider objet pour chaque Source objet).When the Source class is instantiated, the CreateExpansionProvider method in the LanguageService class is called to obtain an ExpansionProvider object (note that the base LanguageService class always returns a new ExpansionProvider object for each Source object).

MPF ne prend pas en charge les fonctions d’extension.The MPF does not support expansion functions. Une fonction d’extension est une fonction nommée qui est incorporée dans un modèle extrait et renvoie une ou plusieurs valeurs à placer dans un champ.An expansion function is a named function that is embedded in a snippet template and returns one or more values to be placed in a field. Les valeurs sont retournées par le langage service proprement dit via un ExpansionFunction objet.The values are returned by the language service itself through an ExpansionFunction object. Le ExpansionFunction objet doit être implémenté par le service de langage pour prendre en charge les fonctions d’extension.The ExpansionFunction object must be implemented by the language service to support expansion functions.

Prise en charge pour les extraits de CodeProviding Support for Code Snippets

Pour activer la prise en charge des extraits de code, vous devez fournir ou installer les extraits de code et vous devez fournir les moyens de l’utilisateur d’insérer des extraits de code.To enable support for code snippets, you must provide or install the snippets and you must provide the means for the user to insert those snippets. Il existe trois étapes à activer la prise en charge des extraits de code :There are three steps to enabling support for code snippets:

  1. Installation des fichiers d’extrait de code.Installing the snippet files.

  2. L’activation des extraits de code pour votre service de langage.Enabling code snippets for your language service.

  3. Appel de la ExpansionProvider objet.Invoking the ExpansionProvider object.

Installation des fichiers de l’extrait de codeInstalling the Snippet Files

Tous les extraits de code pour une langue sont stockés en tant que modèles dans des fichiers XML, en général un seul modèle extrait par fichier.All snippets for a language are stored as templates in XML files, typically one snippet template per file. Pour plus d’informations sur le schéma XML utilisé pour les modèles d’extrait de code, consultez référence du schéma des extraits de Code.For details on the XML schema used for code snippet templates, see Code Snippets Schema Reference. Chaque modèle d’extrait de code est identifié avec un ID de langue.Each snippet template is identified with a language ID. Ce langage ID est spécifié dans le Registre et qu’il est placé dans le Language attribut de le <Code > balise dans le modèle.This language ID is specified in the registry and is put into the Language attribute of the <Code> tag in the template.

Il existe généralement deux emplacements où sont stockés les fichiers de modèle d’extrait de code : (1) où votre langue a été installée et (2) dans le dossier de l’utilisateur.There are typically two locations where snippet template files are stored: 1) where your language was installed and 2) in the user's folder. Ces emplacements sont ajoutés au Registre ainsi que Visual Studio Gestionnaire des extraits de Code peut rechercher les extraits de code.These locations are added to the registry so that the Visual Studio Code Snippets Manager can find the snippets. Dossier de l’utilisateur est où sont stockés les extraits de code créés par l’utilisateur.The user's folder is where snippets created by the user are stored.

La mise en page de dossier par défaut pour les fichiers de modèle d’extrait de code installé ressemble à ceci : [InstallRoot]\ [TestLanguage] \Snippets\ [LCID] \Snippets.The typical folder layout for the installed snippet template files looks like this: [InstallRoot]\ [TestLanguage] \Snippets\ [LCID] \Snippets.

[InstallRoot] est le dossier d’installation dans votre langue.[InstallRoot] is the folder your language is installed in.

[TestLanguage] est le nom de votre langue, comme un nom de dossier.[TestLanguage] is the name of your language as a folder name.

[LCID] est l’ID de paramètres régionaux.[LCID] is the locale ID. Voici comment les différentes versions de vos extraits de code sont stockés.This is how localized versions of your snippets are stored. Par exemple, l’ID de paramètres régionaux pour l’anglais est 1033, par conséquent, [LCID] est remplacé par 1033.For example, the locale ID for English is 1033, so [LCID] is replaced by 1033.

Un fichier supplémentaire doit être fourni et qui est un fichier d’index, généralement appelé SnippetsIndex.xml ou ExpansionsIndex.xml (vous pouvez utiliser n’importe quel nom de fichier valide se terminant par .xml).One additional file must be supplied and that is an index file, typically called SnippetsIndex.xml or ExpansionsIndex.xml (you can use any valid filename ending in .xml). Ce fichier est généralement stocké dans le [InstallRoot]\ [TestLanguage] dossier et spécifie l’emplacement exact du dossier des extraits de code ainsi que l’ID de langue et le GUID de la langue service qui utilise les extraits de code.This file is typically stored in the [InstallRoot]\ [TestLanguage] folder and specifies the exact location of the snippets folder as well as the language ID and GUID of the language service that uses the snippets. Le chemin d’accès exact du fichier d’index est placé dans le Registre comme décrit plus loin dans « Installation les entrées de Registre ».The exact path of the index file is put into the registry as described later in "Installing the Registry Entries". Voici un exemple d’un fichier SnippetsIndex.xml :Here is an example of a SnippetsIndex.xml file:

<?xml version="1.0" encoding="utf-8" ?>  
<SnippetCollection>  
    <Language Lang="Testlanguage" Guid="{b614a40a-80d9-4fac-a6ad-fc2868fff7cd}">  
        <SnippetDir>  
            <OnOff>On</OnOff>  
            <Installed>true</Installed>  
            <Locale>1033</Locale>  
            <DirPath>%InstallRoot%\TestLanguage\Snippets\%LCID%\Snippets\</DirPath>  
            <LocalizedName>Snippets</LocalizedName>  
        </SnippetDir>  
    </Language>  
</SnippetCollection>  

Le <langue > balise spécifie l’ID de langue (le Lang attribut) et le GUID du service de langage.The <Language> tag specifies the language ID (the Lang attribute) and the language service GUID.

Cet exemple suppose que vous avez installé votre service de langage dans le dossier d’installation de Visual Studio.This example assumes you have installed your language service in the Visual Studio installation folder. Le LCID % est remplacé par actuel ID de paramètres régionaux. l’utilisateurThe %LCID% is replaced with the user's current locale ID. Plusieurs <SnippetDir > balises peuvent être ajoutés, une pour chaque autre répertoire et les paramètres régionaux.Multiple <SnippetDir> tags can be added, one for each different directory and locale. En outre, un dossier d’extrait de code peut contenir des sous-dossiers, chacun d’eux est identifié dans le fichier d’index avec la <SnippetSubDir > balise qui est incorporé dans un <SnippetDir > balise.In addition, a snippet folder can contain subfolders, each of which is identified in the index file with the <SnippetSubDir> tag that is embedded in a <SnippetDir> tag.

Ils peuvent également créer leurs propres extraits de code pour votre langue.Users can also create their own snippets for your language. Ceux-ci sont généralement stockés dans le dossier de paramètres de l’utilisateur, par exemple [TestDocs] \Code extraits\ [TestLanguage] \Test extraits de Code, où [TestDocs] est l’emplacement du dossier des paramètres de l’utilisateur de Visual Studio.These are typically stored in the user's settings folder, for example [TestDocs] \Code Snippets\ [TestLanguage] \Test Code Snippets, where [TestDocs] is the location of the user's settings folder for Visual Studio.

Les éléments de substitution suivants peuvent être placés dans le chemin d’accès stocké dans le <Chemin_du_répertoire > balise dans le fichier d’index.The following substitution elements can be placed in the path stored in the <DirPath> tag in the index file.

ÉlémentElement DescriptionDescription
LCID %%LCID% ID de paramètres régionaux.Locale ID.
%InstallRoot%%InstallRoot% Dossier d’installation racine pour Visual Studio, par exemple, C:\Program Files\Microsoft Visual Studio 8.Root installation folder for Visual Studio, for example, C:\Program Files\Microsoft Visual Studio 8.
% ProjDir %%ProjDir% Dossier contenant le projet actuel.Folder containing the current project.
% ProjItem %%ProjItem% Dossier contenant l’élément de projet actuel.Folder containing the current project item.
% TestDocs %%TestDocs% Dossier dans le dossier des paramètres de l’utilisateur, par exemple, C:\Documents and Settings\ [username] documents\Visual Studio\8.Folder in the user's settings folder, for example, C:\Documents and Settings\ [username] \My Documents\Visual Studio\8.

L’activation des extraits de Code pour votre Service de langageEnabling Code Snippets for Your Language Service

Vous pouvez activer des extraits de code pour votre service de langage en ajoutant la ProvideLanguageCodeExpansionAttribute d’attributs pour votre VSPackage (consultez l’inscription d’un Service de langage hérité pour plus d’informations).You can enable code snippets for your language service by adding the ProvideLanguageCodeExpansionAttribute attribute to your VSPackage (see Registering a Legacy Language Service for details). Le ShowRoots et SearchPaths paramètres sont facultatifs, mais vous devez inclure le SearchPaths paramètre nommé afin d’informer le Gestionnaire des extraits de Code de l’emplacement de vos extraits de code.The ShowRoots and SearchPaths parameters are optional, but you should include the SearchPaths named parameter in order to inform the Code Snippets Manager of the location of your snippets.

Voici un exemple d’utilisation de cet attribut :The following is an example of how to use this attribute:

[ProvideLanguageCodeExpansion(  
         typeof(TestSnippetLanguageService),  
         "Test Snippet Language",          // Name of language used as registry key  
         0,                               // Resource ID of localized name of language service  
         "Test Snippet Language",        // Name of Language attribute in snippet template  
         @"%InstallRoot%\Test Snippet Language\Snippets\%LCID%\SnippetsIndex.xml",  // Path to snippets index  
         SearchPaths = @"%InstallRoot%\Test Snippet Language\Snippets\%LCID%\")]    // Path to snippets  

Appel du fournisseur d’extensionCalling the Expansion Provider

Le service de langage contrôle l’insertion d’un extrait de code, ainsi que la façon d’insertion est appelée.The language service controls the insertion of any code snippet, as well as the way insertion is invoked.

Appel du fournisseur d’extension pour les extraits de CodeCalling the Expansion Provider for Code Snippets

Il existe deux façons d’appeler le fournisseur d’extension : à l’aide d’une commande de menu ou à l’aide d’un raccourci à partir d’une liste de saisie semi-automatique.There are two ways to invoke the expansion provider: by using a menu command or by using a shortcut from a completion list.

Insérer un extrait de Code à l’aide d’une commande de MenuInserting a Code Snippet by using a Menu Command

Pour utiliser une commande de menu pour afficher le navigateur de l’extrait de code, vous ajoutez une commande de menu et appelez ensuite la DisplayExpansionBrowser méthode dans le ExpansionProvider interface en réponse à cette commande de menu.To use a menu command to display the snippet browser, you add a menu command and then call the DisplayExpansionBrowser method in the ExpansionProvider interface in response to that menu command.

  1. Ajouter une commande et un bouton à votre fichier .vsct.Add a command and a button to your .vsct file. Vous trouverez des instructions permettant d’effectuer dans avec une commande de Menu pour créer une Extension.You can find instructions for doing so in Creating an Extension with a Menu Command.

  2. Dérivez une classe de la ViewFilter classe et substituer la QueryCommandStatus méthode pour indiquer la prise en charge de la nouvelle commande de menu.Derive a class from the ViewFilter class and override the QueryCommandStatus method to indicate support for the new menu command. Cet exemple permet toujours de la commande de menu.This example always enables the menu command.

    using Microsoft.VisualStudio.Package;  
    
    namespace TestLanguagePackage  
    {  
        class TestViewFilter : ViewFilter  
        {  
            public TestViewFilter(CodeWindowManager mgr, IVsTextView view)  
                : base(mgr, view)  
            {  
            }  
    
            protected override int QueryCommandStatus(ref Guid guidCmdGroup,  
                                                      uint nCmdId)  
            {  
                int hr = base.QueryCommandStatus(ref guidCmdGroup, nCmdId);  
                // If the base class did not recognize the command then  
                // see if we can handle the command.  
                if (hr == (int)Microsoft.VisualStudio.OLE.Interop.Constants.OLECMDERR_E_UNKNOWNGROUP)  
                {  
                    if (guidCmdGroup == GuidList.guidTestLanguagePackageCmdSet)  
                    {  
                        if (nCmdId == PkgCmdIDList.InvokeCodeSnippetsBrowser)  
                        {  
                            hr = (int)(OLECMDF.OLECMDF_SUPPORTED | OLECMDF.OLECMDF_ENABLED);  
                        }  
                    }  
                }  
                return hr;  
            }  
        }  
    }  
    
  3. Remplacer la HandlePreExec méthode dans le ViewFilter classe pour obtenir le ExpansionProvider objet et appelez le DisplayExpansionBrowser méthode sur cet objet.Override the HandlePreExec method in the ViewFilter class to obtain the ExpansionProvider object and call the DisplayExpansionBrowser method on that object.

    using Microsoft.VisualStudio.Package;  
    
    namespace TestLanguagePackage  
    {  
        class TestViewFilter : ViewFilter  
        {  
            public override bool HandlePreExec(ref Guid guidCmdGroup,  
                                               uint nCmdId,  
                                               uint nCmdexecopt,  
                                               IntPtr pvaIn,  
                                               IntPtr pvaOut)  
            {  
                if (base.HandlePreExec(ref guidCmdGroup,  
                                       nCmdId,  
                                       nCmdexecopt,  
                                       pvaIn,  
                                       pvaOut))  
                {  
                    // Base class handled the command.  Do nothing more here.  
                    return true;  
                }  
    
                if (guidCmdGroup == GuidList.guidTestLanguagePackageCmdSet)  
                {  
                    if (nCmdId == PkgCmdIDList.InvokeCodeSnippetsBrowser)  
                    {  
                        ExpansionProvider ep = this.GetExpansionProvider();  
                        if (this.TextView != null && ep != null)  
                        {  
                            bool bDisplayed = ep.DisplayExpansionBrowser(  
                                this.TextView,  
                                "TestLanguagePackage Snippet:",  
                                null,  
                                false,  
                                null,  
                                false);  
                        }  
                        return true;   // Handled the command.  
                    }  
                }  
                return false;   // Did not handle the command.  
            }  
        }  
    }  
    

    Les méthodes suivantes dans le ExpansionProvider classe sont appelés pendant le processus d’insertion de l’extrait de code par Visual Studio dans l’ordre indiqué :The following methods in the ExpansionProvider class are called by Visual Studio in the given order during the process of inserting the snippet:

  4. OnItemChosen

  5. IsValidKind

  6. OnBeforeInsertion

  7. FormatSpan

  8. OnAfterInsertion

    Après le OnAfterInsertion est appelée, l’extrait de code a été inséré et ExpansionProvider objet est en mode édition spéciale utilisé pour modifier un extrait de code qui vient d’être a été insérée.After the OnAfterInsertion method is called, the snippet has been inserted and the ExpansionProvider object is in a special edit mode used for modifying a snippet that has just been inserted.

Insérer un extrait de code à l’aide d’un raccourciInserting a code snippet by using a shortcut

Implémentation d’un raccourci à partir d’une liste de saisie semi-automatique est beaucoup plus compliquée que l’implémentation d’une commande de menu.Implementation of a shortcut from a completion list is much more involved than implementing a menu command. Vous devez tout d’abord ajouter des raccourcis de l’extrait de code à la liste de saisie semi-automatique IntelliSense.You must first add snippet shortcuts to the IntelliSense word completion list. Puis vous devez détecter lorsqu’un nom de raccourci d’extrait de code a été inséré à la suite d’achèvement.Then you must detect when a snippet shortcut name has been inserted as a result of completion. Enfin, vous devez obtenir le titre de l’extrait de code et le chemin d’accès à l’aide du nom raccourci et transmettre ces informations pour le InsertNamedExpansion méthode sur le ExpansionProvider (méthode).Finally, you must obtain the snippet title and path using the shortcut name and pass that information to the InsertNamedExpansion method on the ExpansionProvider method.

Pour ajouter des raccourcis de l’extrait de code à la liste de saisie semi-automatique, ajoutez-les à la Declarations de l’objet dans votre AuthoringScope classe.To add snippet shortcuts to the word completion list, add them to the Declarations object in your AuthoringScope class. Il se peut que vous devez vous assurer que vous pouvez identifier le raccourci comme un nom de l’extrait de code.You must make sure you can identify the shortcut as a snippet name. Pour obtenir un exemple, consultez procédure pas à pas : obtention d’une liste d’installé des extraits de Code (implémentation hérité).For an example, see Walkthrough: Getting a List of Installed Code Snippets (Legacy Implementation).

Vous pouvez détecter l’insertion du raccourci d’extrait de code dans le OnAutoComplete méthode de la Declarations classe.You can detect the insertion of the code snippet shortcut in the OnAutoComplete method of the Declarations class. Étant donné que le nom de l’extrait de code a déjà été inséré dans le fichier source, il doit être supprimé lors de l’expansion est insérée.Because the snippet name has already been inserted into the source file, it must be removed when the expansion is inserted. Le InsertNamedExpansion méthode prend une étendue qui décrit le point d’insertion de l’extrait ; si l’étendue inclut le nom de l’extrait de code entier dans le fichier source, ce nom est remplacé par l’extrait de code.The InsertNamedExpansion method takes a span that describes the point of insertion for the snippet; if the span includes the entire snippet name in the source file, that name is replaced by the snippet.

Voici une version d’un Declarations classe qui gère l’insertion d’extrait de code donnée un nom de raccourci.Here is a version of a Declarations class that handles snippet insertion given a shortcut name. Autres méthodes dans la Declarations classe ont été omis par souci de clarté.Other methods in the Declarations class have been omitted for clarity. Notez que le constructeur de cette classe prend un LanguageService objet.Note that the constructor of this class takes a LanguageService object. Cela peut être passé à partir de votre version de la AuthoringScope objet (par exemple, votre implémentation de la AuthoringScope classe peut prendre la LanguageService de l’objet dans son constructeur et transmettre cet objet à votre TestDeclarations constructeur de classe).This can be passed in from your version of the AuthoringScope object (for example, your implementation of the AuthoringScope class might take the LanguageService object in its constructor and pass that object on to your TestDeclarations class constructor).

using Microsoft.VisualStudio.Package;  
using Microsoft.VisualStudio.TextManager.Interop;  

namespace TestLanguagePackage  
{  
    internal class TestDeclarations : Declarations  
    {  
        private ArrayList       declarations;  
        private LanguageService languageService;  
        private TextSpan        commitSpan;  

        public TestDeclarations(LanguageService langService)  
            : base()  
        {  
            languageService = langService;  
            declarations = new ArrayList();  
        }  

        // This method is used to add declarations to the internal list.  
        public void AddDeclaration(TestDeclaration declaration)  
        {  
            declarations.Add(declaration);  
        }  

        // This method is called to get the string to commit to the source buffer.  
        // Note that the initial extent is only what the user has typed so far.  
        public override string OnCommit(IVsTextView textView,  
                                        string textSoFar,  
                                        char commitCharacter,  
                                        int index,  
                                        ref TextSpan initialExtent)  
        {  
            // We intercept this call only to get the initial extent  
            // of what was committed to the source buffer.  
            commitSpan = initialExtent;  

            return base.OnCommit(textView,  
                                 textSoFar,  
                                 commitCharacter,  
                                 index,  
                                 ref initialExtent);  
        }  

        // This method is called after the string has been committed to the source buffer.  
        public override char OnAutoComplete(IVsTextView textView,  
                                            string committedText,  
                                            char commitCharacter,  
                                            int index)  
        {  
            TestDeclaration item = declarations[index] as TestDeclaration;  
            if (item != null)  
            {  
                // In this example, TestDeclaration identifies types with a string.  
                // You can choose a different approach.  
                if (item.Type == "snippet")  
                {  
                    Source src = languageService.GetSource(textView);  
                    if (src != null)  
                    {  
                        ExpansionProvider ep = src.GetExpansionProvider();  
                        if (ep != null)  
                        {  
                            string title;  
                            string path;  
                            int commitLength = commitSpan.iEndIndex - commitSpan.iStartIndex;  
                            if (commitLength < committedText.Length)  
                            {  
                                // Replace everything that was inserted  
                                // so calculate the span of the full  
                                // insertion, taking into account what  
                                // was inserted when the commitSpan  
                                // was obtained in the first place.  
                                commitSpan.iEndIndex += (committedText.Length - commitLength);  
                            }  

                            if (ep.FindExpansionByShortcut(textView,  
                                                           committedText,  
                                                           commitSpan,  
                                                           true,  
                                                           out title,  
                                                           out path))  
                            {  
                                ep.InsertNamedExpansion(textView,  
                                                        title,  
                                                        path,  
                                                        commitSpan,  
                                                        false);  
                            }  
                        }  
                    }  
                }  
            }  
            return '\0';  
        }  
    }  
}  

Lorsque le service de langage Obtient le nom du raccourci, il appelle la FindExpansionByShortcut méthode pour obtenir le titre d’extrait de nom de fichier et le code.When the language service gets the shortcut name, it calls the FindExpansionByShortcut method to obtain the filename and code snippet title. Le service de langage appelle ensuite la InsertNamedExpansion méthode dans la ExpansionProvider classe pour insérer l’extrait de code.The language service then calls the InsertNamedExpansion method in the ExpansionProvider class to insert the code snippet. Les méthodes suivantes sont appelées par Visual Studio dans l’ordre indiqué dans la ExpansionProvider classe pendant le processus d’insertion de l’extrait de code :The following methods are called by Visual Studio in the given order in the ExpansionProvider class during the process of inserting the snippet:

  1. IsValidKind

  2. OnBeforeInsertion

  3. FormatSpan

  4. OnAfterInsertion

    Pour plus d’informations sur l’obtention d’une liste des extraits de code installé pour votre service de langage, consultez procédure pas à pas : obtention d’une liste d’installé des extraits de Code (implémentation hérité).For more information on getting a list of installed code snippets for your language service, see Walkthrough: Getting a List of Installed Code Snippets (Legacy Implementation).

Implémentation de la classe ExpansionFunctionImplementing the ExpansionFunction Class

Une fonction d’extension est une fonction nommée qui est incorporée dans un modèle extrait et renvoie une ou plusieurs valeurs à placer dans un champ.An expansion function is a named function that is embedded in a snippet template and returns one or more values to be placed in a field. Pour prendre en charge les fonctions d’extension dans votre service de langage, vous devez dériver une classe à partir de la ExpansionFunction classe et implémenter la GetCurrentValue (méthode).In order to support expansion functions in your language service, you must derive a class from the ExpansionFunction class and implement the GetCurrentValue method. Vous devez substituer la CreateExpansionFunction méthode dans le LanguageService classe pour retourner une nouvelle instanciation de votre version de la ExpansionFunction classe pour chaque fonction d’extension que vous prenez en charge.You must then override the CreateExpansionFunction method in the LanguageService class to return a new instantiation of your version of the ExpansionFunction class for each expansion function you support. Si vous prenez en charge une liste de valeurs possibles d’une fonction d’extension, vous devez également substituer la GetIntellisenseList méthode dans la ExpansionFunction classe pour retourner une liste de ces valeurs.If you support a list of possible values from an expansion function, you must also override the GetIntellisenseList method in the ExpansionFunction class to return a list of those values.

Une fonction d’extension qui prend des arguments ou qui doit accéder aux autres champs ne doit pas être associée à un champ modifiable, car le fournisseur d’extension peut ne pas être entièrement initialisé au moment où que la fonction d’extension est appelée.An expansion function that takes arguments or needs to access other fields should not be associated with an editable field, as the expansion provider might not be fully initialized by the time the expansion function is called. Par conséquent, la fonction d’extension n’est pas en mesure d’obtenir la valeur de ses arguments ou tout autre champ.As a result, the expansion function is not able to obtain the value of its arguments or any other field.

ExempleExample

Voici un exemple de la façon dont une fonction d’extension simple appelée GetName peut être implémenté.Here is an example of how a simple expansion function called GetName might be implemented. Cette fonction d’extension ajoute un nombre à un nom de classe de base chaque fois que la fonction d’extension est instanciée (qui correspond à chaque fois que l’extrait de code associé est inséré).This expansion function appends a number to a base class name each time the expansion function is instantiated (which corresponds to each time the associated code snippet is inserted).

using Microsoft.VisualStudio.Package;  

namespace TestLanguagePackage  
{  
    public class TestLanguageService : LanguageService  
    {  
        private int classNameCounter = 0;  

        public override ExpansionFunction CreateExpansionFunction(  
            ExpansionProvider provider,  
            string functionName)  
        {  
            ExpansionFunction function = null;  
            if (functionName == "GetName")  
            {  
                ++classNameCounter;  
                function = new TestGetNameExpansionFunction(provider, classNameCounter);  
            }  
            return function;  
        }  
    }  

    internal class TestGetNameExpansionFunction : ExpansionFunction  
    {  
        private int nameCount;  

        TestGetNameExpansionFunction(ExpansionProvider provider, int counter)  
            : base(provider)  
        {  
            nameCount = counter;  
        }  

        public override string GetCurrentValue()  
        {  
            string name = "TestClass";  
            name += nameCount.ToString();  
            return name;  
        }  
    }  
}  

Voir aussiSee Also

Fonctionnalités de Service de langage hérité Legacy Language Service Features
L’inscription d’un Service de langage hérité Registering a Legacy Language Service
Extraits de code Code Snippets
Procédure pas à pas : Obtention d’une liste d’extraits de code installés (implémentation héritée)Walkthrough: Getting a List of Installed Code Snippets (Legacy Implementation)