Procédure pas à pas : Création d’un éditeur de base et l’inscription d’un Type de fichier de l’éditeurWalkthrough: Creating a Core Editor and Registering an Editor File Type

Cette procédure pas à pas montre comment créer un VSPackage qui démarre le Visual StudioVisual Studio éditeur principal lorsqu’un fichier ayant l’extension de nom de fichier .myext est chargé.This walkthrough demonstrates how to create a VSPackage that starts the Visual StudioVisual Studio core editor when a file that has the .myext file name extension is loaded.

PrérequisPrerequisites

Pour suivre cette procédure pas à pas, vous devez installer le Kit de développement logiciel (SDK) Visual Studio.To follow this walkthrough, you must install the Visual Studio SDK. Pour plus d’informations, consultez Visual Studio SDK.For more information, see Visual Studio SDK.

Emplacements pour le modèle de projet de Package Visual StudioLocations for the Visual Studio Package Project template

Le modèle de projet de package Visual Studio se trouve à trois emplacements différents dans la boîte de dialogue Nouveau projet :The Visual Studio Package project template can be found in three different locations in the New Project dialog:

  1. Sous l’extensibilité Visual Basic.Under Visual Basic Extensibility. Le langage par défaut du projet est Visual Basic.The default language of the project is Visual Basic.

  2. Sous l’extensibilité C#.Under C# Extensibility. Le langage par défaut du projet est C#.The default language of the project is C#.

  3. Sous l’extensibilité Autres types de projets.Under Other Project Types Extensibility. Le langage par défaut du projet est C++.The default language of the project is C++.

Pour créer le VSPackageTo create the VSPackage

Pour ajouter la fabrique d’éditeurTo add the editor factory

  1. Avec le bouton droit le MyPackage de projet, pointez sur ajouter puis cliquez sur classe.Right-click the MyPackage project, point to Add and then click Class.

  2. Dans le ajouter un nouvel élément boîte de dialogue zone, assurez-vous que le classe modèle est sélectionné, type EditorFactory.cs pour le nom, puis cliquez sur ajouter pour ajouter la classe à votre projet.In the Add New Item dialog box, make sure the Class template is selected, type EditorFactory.cs for the name, and then click Add to add the class to your project.

    Le fichier EditorFactory.cs doit être ouvert automatiquement.The EditorFactory.cs file should be automatically opened.

  3. Référencer les assemblys suivants à partir de votre code.Reference the following assemblies from your code.

    Imports System.Runtime.InteropServices  
    Imports Microsoft.VisualStudio  
    Imports Microsoft.VisualStudio.Shell  
    Imports Microsoft.VisualStudio.Shell.Interop  
    Imports Microsoft.VisualStudio.OLE.Interop  
    Imports Microsoft.VisualStudio.TextManager.Interop  
    Imports IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider  
    
    using System.Runtime.InteropServices;  
    using Microsoft.VisualStudio;  
    using Microsoft.VisualStudio.Shell;  
    using Microsoft.VisualStudio.Shell.Interop;  
    using Microsoft.VisualStudio.OLE.Interop;  
    using Microsoft.VisualStudio.TextManager.Interop;  
    using IOleServiceProvider = Microsoft.VisualStudio.OLE.Interop.IServiceProvider;  
    
  4. Ajouter un GUID à la EditorFactory classe en ajoutant le Guid attribut immédiatement avant la déclaration de classe.Add a GUID to the EditorFactory class by adding the Guid attribute immediately before the class declaration.

    Vous pouvez générer un nouveau GUID à l’aide du programme guidgen.exe à la Visual StudioVisual Studio invite de commandes, ou en cliquant sur Create GUID sur la outils menu.You can generate a new GUID by using the guidgen.exe program at the Visual StudioVisual Studio command prompt, or by clicking Create GUID on the Tools menu. Le GUID utilisé ici n'est qu’un exemple ; n’utilisez pas dans votre projet.The GUID used here is only an example; do not use it in your project.

    <Guid("0eea3187-c5fa-48d4-aa72-b5eecd3b17b1")> _  
    
    [Guid("0eea3187-c5fa-48d4-aa72-b5eecd3b17b1")]   
    
  5. Dans la définition de classe, ajoutez deux variables privées pour contenir le package parent et un fournisseur de services.In the class definition, add two private variables to contain the parent package and a service provider.

    Class EditorFactory  
        Private parentPackage As Package  
        Private serviceProvider As IOleServiceProvider  
    
    class EditorFactory  
    {  
        private Package parentPackage;  
        private IOleServiceProvider serviceProvider;  
    }  
    
  6. Ajoutez un constructeur de classe publique qui prend un paramètre de type Package:Add a public class constructor that takes one parameter of type Package:

    Public Sub New(ByVal parentPackage As Package)  
        Me.parentPackage = parentPackage  
    End Sub  
    
    public EditorFactory(Package parentPackage)  
    {  
        this.parentPackage = parentPackage;  
    }  
    
  7. Modifier la EditorFactory dérivent de la déclaration de classe le IVsEditorFactory interface.Modify the EditorFactory class declaration to derive from the IVsEditorFactory interface.

    Class EditorFactory Implements IVsEditorFacto  
    
    class EditorFactory : IVsEditorFactory  
    
  8. Avec le bouton droit IVsEditorFactory, cliquez sur implémenter l’Interface, puis cliquez sur implémenter l’Interface explicitement.Right-click IVsEditorFactory, click Implement Interface, and then click Implement Interface Explicitly.

    Cette opération ajoute les quatre méthodes qui doivent être implémentées dans le IVsEditorFactory interface.This adds the four methods that must be implemented in the IVsEditorFactory interface.

  9. Remplacez le contenu de la méthode IVsEditorFactory.Close par le code suivant :Replace the contents of the IVsEditorFactory.Close method with the following code.

    Return VSConstants.S_OK  
    
    return VSConstants.S_OK;  
    
  10. Remplacez le contenu de la IVsEditorFactory.SetSite avec le code suivant.Replace the contents of the IVsEditorFactory.SetSite with the following code.

    Me.serviceProvider = psp  
    Return VSConstants.S_OK  
    
    this.serviceProvider = psp;  
    return VSConstants.S_OK;  
    
  11. Remplacez le contenu de la méthode IVsEditorFactory.MapLogicalView par le code suivant :Replace the contents of the IVsEditorFactory.MapLogicalView method with the following code.

    Dim retval As Integer = VSConstants.E_NOTIMPL  
    pbstrPhysicalView = Nothing ' We support only one view.  
    If rguidLogicalView.Equals(VSConstants.LOGVIEWID_Designer)OrElse _  
    rguidLogicalView.Equals(VSConstants.LOGVIEWID_Primary) Then  
        retval = VSConstants.S_OK  
    End If  
    Return retval  
    
    int retval = VSConstants.E_NOTIMPL;  
    pbstrPhysicalView = null;   // We support only one view.  
    if (rguidLogicalView.Equals(VSConstants.LOGVIEWID_Designer) ||  
    rguidLogicalView.Equals(VSConstants.LOGVIEWID_Primary))  
    {  
        retval = VSConstants.S_OK;  
    }  
    return retval;  
    
  12. Remplacez le contenu de la méthode IVsEditorFactory.CreateEditorInstance par le code suivant :Replace the contents of the IVsEditorFactory.CreateEditorInstance method with the following code.

    Dim retval As Integer = VSConstants.E_FAIL          
    
    ' Initialize these to empty to start with   
    ppunkDocView = IntPtr.Zero  
    ppunkDocData = IntPtr.Zero  
    pbstrEditorCaption = ""  
    pguidCmdUI = Guid.Empty  
    pgrfCDW = 0  
    
    If (grfCreateDoc And (VSConstants.CEF_OPENFILE Or _  
    VSConstants.CEF_SILENT)) = 0 Then  
        Throw New ArgumentException("Only Open or Silent is valid")  
    End If  
    If punkDocDataExisting <> IntPtr.Zero Then  
        Return VSConstants.VS_E_INCOMPATIBLEDOCDATA  
    End If  
    
    ' Instantiate a text buffer of type VsTextBuffer.   
    ' Note: we only need an IUnknown (object) interface for   
    ' this invocation.   
    Dim clsidTextBuffer As Guid = GetType(VsTextBufferClass).GUID  
    Dim iidTextBuffer As Guid = VSConstants.IID_IUnknown  
    Dim pTextBuffer As Object = pTextBuffer = _  
    parentPackage.CreateInstance(clsidTextBuffer, iidTextBuffer, _  
    GetType(Object))  
    
    If Not pTextBuffer Is Nothing Then  
        ' "Site" the text buffer with the service provider we were   
        ' provided.   
        Dim textBufferSite As IObjectWithSite = TryCast(pTextBuffer, _  
        IObjectWithSite)  
        If Not textBufferSite Is Nothing Then  
            textBufferSite.SetSite(Me.serviceProvider)  
        End If  
    
        ' Instantiate a code window of type IVsCodeWindow.   
        Dim clsidCodeWindow As Guid = GetType(VsCodeWindowClass).GUID  
        Dim iidCodeWindow As Guid = GetType(IVsCodeWindow).GUID  
        Dim pCodeWindow As IVsCodeWindow = _  
        CType(Me.parentPackage.CreateInstance(clsidCodeWindow, _  
        iidCodeWindow, GetType(IVsCodeWindow)), IVsCodeWindow)  
        If Not pCodeWindow Is Nothing Then  
            ' Give the text buffer to the code window.   
            ' We are giving up ownership of the text buffer!   
            pCodeWindow.SetBuffer(CType(pTextBuffer, IVsTextLines))  
    
            ' Now tell the caller about all this new stuff   
            ' that has been created.   
            ppunkDocView = Marshal.GetIUnknownForObject(pCodeWindow)  
            ppunkDocData = Marshal.GetIUnknownForObject(pTextBuffer)  
    
            ' Specify the command UI to use so keypresses are   
            ' automatically dealt with.   
            pguidCmdUI = VSConstants.GUID_TextEditorFactory  
    
            ' This caption is appended to the filename and   
            ' lets us know our invocation of the core editor   
            ' is up and running.   
            pbstrEditorCaption = " [MyPackage]"  
    
            retval = VSConstants.S_OK  
        End If  
    End If  
    Return retval  
    
    int retval = VSConstants.E_FAIL;  
    
    // Initialize these to empty to start with  
    ppunkDocView       = IntPtr.Zero;  
    ppunkDocData       = IntPtr.Zero;  
    pbstrEditorCaption = "";  
    pguidCmdUI         = Guid.Empty;   
    pgrfCDW            = 0;  
    
    if ((grfCreateDoc & (VSConstants.CEF_OPENFILE |   
          VSConstants.CEF_SILENT)) == 0)  
    {   
        throw new ArgumentException("Only Open or Silent is valid");  
    }  
    if (punkDocDataExisting != IntPtr.Zero)  
    {  
        return VSConstants.VS_E_INCOMPATIBLEDOCDATA;  
    }  
    
    // Instantiate a text buffer of type VsTextBuffer.  
    // Note: we only need an IUnknown (object) interface for   
    // this invocation.  
    Guid clsidTextBuffer = typeof(VsTextBufferClass).GUID;  
    Guid iidTextBuffer   = VSConstants.IID_IUnknown;  
    object pTextBuffer   = pTextBuffer = parentPackage.CreateInstance(  
          ref clsidTextBuffer,  
          ref iidTextBuffer,  
          typeof(object));  
    
    if (pTextBuffer != null)  
    {  
        // "Site" the text buffer with the service provider we were  
        // provided.  
        IObjectWithSite textBufferSite = pTextBuffer as IObjectWithSite;  
        if (textBufferSite != null)  
        {  
            textBufferSite.SetSite(this.serviceProvider);  
        }  
    
        // Instantiate a code window of type IVsCodeWindow.  
        Guid clsidCodeWindow = typeof(VsCodeWindowClass).GUID;  
        Guid iidCodeWindow   = typeof(IVsCodeWindow).GUID;  
        IVsCodeWindow pCodeWindow =  
        (IVsCodeWindow)this.parentPackage.CreateInstance(   
              ref clsidCodeWindow,  
              ref iidCodeWindow,  
              typeof(IVsCodeWindow));  
        if (pCodeWindow != null)  
        {  
            // Give the text buffer to the code window.  
            // We are giving up ownership of the text buffer!  
            pCodeWindow.SetBuffer((IVsTextLines)pTextBuffer);  
    
            // Now tell the caller about all this new stuff   
            // that has been created.  
            ppunkDocView = Marshal.GetIUnknownForObject(pCodeWindow);  
            ppunkDocData = Marshal.GetIUnknownForObject(pTextBuffer);  
    
            // Specify the command UI to use so keypresses are   
            // automatically dealt with.  
            pguidCmdUI = VSConstants.GUID_TextEditorFactory;  
    
            // This caption is appended to the filename and  
            // lets us know our invocation of the core editor   
            // is up and running.  
            pbstrEditorCaption = " [MyPackage]";  
    
            retval = VSConstants.S_OK;  
        }   
    }   
    return retval;   
    
  13. Compilez le projet et ne vérifiez qu’aucune erreur.Compile the project and make sure there are no errors.

Pour inscrire la fabrique d’éditeurTo register the editor factory

  1. Dans l’Explorateur de solutions, double-cliquez sur le fichier Resources.resx pour l’ouvrir à la table de chaînes, dans lequel l’entrée String1 est sélectionné.In Solution Explorer, double-click the Resources.resx file to open it to the string table, in which the entry String1 is selected.

  2. Modifier le nom de l’identificateur à IDS_EDITORNAME et le texte à MyPackage éditeur.Change the name of the identifier to IDS_EDITORNAME and the text to MyPackage Editor. Cette chaîne s’affiche en tant que le nom de votre éditeur.This string will appear as the name of your editor.

  3. Ouvrez le fichier VSPackage.resx et ajoutez une nouvelle chaîne, le nom de la valeur 101 et à la valeur IDS_EDITORNAME.Open the VSPackage.resx file and add a new string, set the name to 101 and the value to IDS_EDITORNAME. Cela fournit un ID de ressource pour accéder à la chaîne que vous venez de créer le package.This provides the package with a resource ID to access the string you just created.

    Note

    Si le fichier VSPackage.resx contient une autre chaîne que le name attribut la valeur 101, remplacez par une autre valeur unique, numeric, ici et dans les étapes suivantes.If the VSPackage.resx file contains another string that the name attribute set to 101, substitute another unique, numeric value, here and in the following steps.

  4. Dans l’Explorateur de solutions, ouvrez le fichier MyPackagePackage.cs.In Solution Explorer, open the MyPackagePackage.cs file.

    Il s’agit du fichier de package principal.This is the main package file.

  5. Ajoutez les attributs d’utilisateur suivant juste avant la Guid attribut.Add the following user attributes just before the Guid attribute.

    <ProvideEditorFactoryAttribute(GetType(EditorFactory), 101)> _  
    <ProvideEditorExtensionAttribute(GetType(EditorFactory), _  
          ".myext", 32, NameResourceID:=101 )> _  
    
    [ProvideEditorFactory(typeof(EditorFactory), 101)]  
    [ProvideEditorExtension(typeof(EditorFactory),   
          ".myext", 32, NameResourceID = 101)]   
    

    Le ProvideEditorExtensionAttribute associe l’extension de fichier .myext à votre fabrique d’éditeur afin que chaque fois un fichier ayant qu’extension est chargée, votre fabrique d’éditeur est appelée.The ProvideEditorExtensionAttribute attribute associates the .myext file extension with your editor factory so that any time a file that has that extension is loaded, your editor factory is invoked.

  6. Ajoutez une variable privée pour le MyPackage classe juste avant le constructeur et lui donner le type EditorFactory.Add a private variable to the MyPackage class, just before the constructor, and give it the type EditorFactory.

    Private editorFactory As EditorFactory  
    
    private EditorFactory editorFactory;  
    
  7. Rechercher les Initialize (méthode) (vous devrez peut-être ouvrir le Package Members zone masquée) et ajoutez le code suivant après l’appel à base.Initialize().Find the Initialize method (you may have to open the Package Members hidden region) and add the following code after the call to base.Initialize().

    'Create our editor factory and register it.   
    Me.editorFactory = New EditorFactory(Me)  
    MyBase.RegisterEditorFactory(Me.editorFactory)  
    
    // Create our editor factory and register it.  
    this.editorFactory = new EditorFactory(this);  
    base.RegisterEditorFactory(this.editorFactory);  
    
  8. Compilez le programme et vérifiez l’absence d’erreurs.Compile the program and make sure there are no errors.

    Cette étape inscrit la fabrique d’éditeur dans la ruche du Registre expérimentale pour Visual StudioVisual Studio.This step registers the editor factory in the experimental registry hive for Visual StudioVisual Studio. Si vous êtes invité à remplacer le fichier resource.h, cliquez sur OK.If you are prompted to override the resource.h file, click OK.

  9. Créer un exemple de fichier nommé TextFile1.myext.Create a sample file named TextFile1.myext.

  10. Appuyez sur F5 pour ouvrir une instance de l’instance expérimentale Visual StudioVisual Studio.Press F5 to open an instance of the experimental Visual StudioVisual Studio.

  11. Dans l’instance expérimentale Visual StudioVisual Studio, dans le fichier menu, pointez sur ouvrir puis cliquez sur fichier.In the experimental Visual StudioVisual Studio, on the File menu, point to Open and then click File.

  12. Recherchez TextFile1.myext, puis cliquez sur ouvrir.Find TextFile1.myext and then click Open.

    Le fichier doit maintenant être chargé.The file should now be loaded.

Programmation fiableRobust Programming

Le Visual StudioVisual Studio éditeur principal gère un large éventail de types de fichier texte et fonctionne en étroite collaboration avec les services de langage pour fournir un ensemble complet de fonctionnalités telles que la mise en surbrillance de syntaxe, la correspondance des accolades et des listes de saisie semi-automatique par word et saisie semi-automatique par membre IntelliSense.The Visual StudioVisual Studio core editor handles a wide range of text-based file types and works closely with language services to provide a rich set of features such as syntax highlighting, brace matching, and IntelliSense word-completion and member-completion lists. Si vous travaillez avec des fichiers texte, vous pouvez utiliser l’éditeur principal avec un service de langage personnalisé qui prend en charge les types de fichiers spécifiques.If you are working with text-based files, then you can use the core editor together with a custom language service that supports your specific file types.

Un VSPackage peut appeler le Visual StudioVisual Studio éditeur principal, vous devez fournir une fabrique d’éditeur.A VSPackage can invoke the Visual StudioVisual Studio core editor by supplying an editor factory. Cette fabrique d’éditeur utilisée chaque fois qu’un fichier qui lui est associé est chargé.This editor factory is used any time a file that is associated with it is loaded. Si le fichier fait partie d’un projet, l’éditeur principal est automatiquement appelée sauf si votre VSPackage.If the file is part of a project, then the core editor is automatically invoked unless overridden by your VSPackage. Toutefois, si le fichier est chargé en dehors d’un projet, puis l’éditeur principal doit être appelé explicitement par votre VSPackage.However, if the file is loaded outside of a project, then the core editor must be explicitly invoked by your VSPackage.

Pour plus d’informations sur l’éditeur principal, consultez à l’intérieur de l’éditeur de base.For more information about the core editor, see Inside the Core Editor.

Voir aussiSee Also

Dans l’éditeur de base Inside the Core Editor
L’instanciation de l’éditeur principal à l’aide de l’API héritéeInstantiating the Core Editor By Using the Legacy API