Fabriques d’éditeurEditor Factories

Une fabrique d’éditeur crée les objets de l’éditeur et les place dans un frame de fenêtre, appelé vue physique.An editor factory creates editor objects and puts them in a window frame, known as a physical view. Il crée les données du document et les objets de vue de document qui sont nécessaires pour créer des éditeurs et concepteurs.It creates the document data and document view objects that are necessary to create editors and designers. Une fabrique d’éditeur est requis pour créer l’éditeur principal de Visual Studio et de n’importe quel éditeur standard.An editor factory is required to create the Visual Studio core editor and any standard editor. Un éditeur personnalisé peut également être créé avec une fabrique d’éditeur.A custom editor can also optionally be created with an editor factory.

Vous créez une fabrique d’éditeur en implémentant le IVsEditorFactory interface.You create an editor factory by implementing the IVsEditorFactory interface. L’exemple suivant illustre comment implémenter IVsEditorFactory pour créer une fabrique d’éditeur :The following example illustrates how to implement IVsEditorFactory to create an editor factory:

<Guid(GuidList.guidEditorFactory)> _
Public NotInheritable Class SingleViewEditorFactory
    Implements IVsEditorFactory
    Implements IDisposable

    Private MyPackage As PackageSingleViewEditor
    Private vsServiceProvider As ServiceProvider

    Public Sub New(ByVal packageEditor As PackageSingleViewEditor)
        Trace.WriteLine(String.Format(CultureInfo.CurrentCulture,
          "Entering {0} constructor", Me.ToString()))
        MyPackage = packageEditor
    End Sub

#Region "IVsEditorFactorySupport"
    Public Function Close() As Integer Implements VisualStudio.Shell.Interop.IVsEditorFactory.Close
        Throw New NotImplementedException
    End Function

    Public Function CreateEditorInstance(ByVal grfCreateDoc As UInteger, ByVal pszMkDocument As String, ByVal pszPhysicalView As String, ByVal pvHier As VisualStudio.Shell.Interop.IVsHierarchy, ByVal itemid As UInteger, ByVal punkDocDataExisting As System.IntPtr, ByRef ppunkDocView As System.IntPtr, ByRef ppunkDocData As System.IntPtr, ByRef pbstrEditorCaption As String, ByRef pguidCmdUI As System.Guid, ByRef pgrfCDW As Integer) As Integer Implements VisualStudio.Shell.Interop.IVsEditorFactory.CreateEditorInstance
        Throw New NotImplementedException
    End Function

    Public Function MapLogicalView(ByRef rguidLogicalView As System.Guid, ByRef pbstrPhysicalView As String) As Integer Implements VisualStudio.Shell.Interop.IVsEditorFactory.MapLogicalView
        Throw New NotImplementedException
    End Function

    Public Function SetSite(ByVal psp As VisualStudio.OLE.Interop.IServiceProvider) As Integer Implements VisualStudio.Shell.Interop.IVsEditorFactory.SetSite
        Throw New NotImplementedException
    End Function
#End Region

#Region "IDisposable Support"
    Public Sub Dispose() Implements IDisposable.Dispose
        Throw New NotImplementedException
    End Sub
#End Region

End Class
[Guid(GuidList.guidEditorFactory)]
public sealed class SingleViewEditorFactory : IVsEditorFactory, IDisposable
{
    private PackageSingleViewEditor MyPackage;
    private ServiceProvider vsServiceProvider;

    public SingleViewEditorFactory(PackageSingleViewEditor packageEditor)
    {
        Trace.WriteLine(string.Format(CultureInfo.CurrentCulture, 
            "Entering {0} constructor", this.ToString()));
        MyPackage = packageEditor;
    }

    #region "IVsEditorFactory Support"
        public int Close()
        {
            throw new NotImplementedException();
        }

        public int CreateEditorInstance(uint grfCreateDoc, string pszMkDocument, string pszPhysicalView, IVsHierarchy pvHier, uint itemid, IntPtr punkDocDataExisting, out IntPtr ppunkDocView, out IntPtr ppunkDocData, out string pbstrEditorCaption, out System.Guid pguidCmdUI, out int pgrfCDW)
        {
            throw new NotImplementedException();
        }

        public int MapLogicalView(ref System.Guid rguidLogicalView, out string pbstrPhysicalView)
        {
            throw new NotImplementedException();
        }

        public int SetSite(Microsoft.VisualStudio.OLE.Interop.IServiceProvider psp)
        {
            throw new NotImplementedException();
        }
    #endregion

    #region "IDisposable Support"
        public void Dispose()
        {
            throw new NotImplementedException();
        }
    #endregion
}

Un éditeur est chargé la première fois que vous ouvrez un type de fichier géré par l’éditeur.An editor is loaded the first time that you open a file type handled by that editor. Vous pouvez choisir d’ouvrir un éditeur spécifique ou l’éditeur par défaut.You can choose to open either a specific editor or the default editor. Si vous sélectionnez l’éditeur par défaut, l’environnement de développement intégré (IDE) détermine l’ouverture de l’éditeur approprié, puis l’ouvre.If you select the default editor, the integrated development environment (IDE) determines the correct editor to open and then opens it. Pour plus d’informations, consultez détermination de l’éditeur ouvre un fichier dans un projet.For more information, see Determining Which Editor Opens a File in a Project.

Inscrire les fabriques d’éditeurRegistering Editor Factories

Avant de pouvoir utiliser un éditeur que vous avez créé, vous devez tout d’abord enregistrer des informations le concernant, y compris les extensions de fichier qu’il peut gérer.Before you can use an editor that you have created, you first must register information about it, including the file extensions it can handle.

Si votre VSPackage est écrit en code managé, vous pouvez utiliser la méthode de Managed Package Framework (MPF) RegisterEditorFactory pour inscrire la fabrique d’éditeur après le chargement de votre VSPackage.If your VSPackage is written in managed code, you can use the Managed Package Framework (MPF) method RegisterEditorFactory to register the editor factory after your VSPackage is loaded. Si votre VSPackage est écrit en code non managé, vous devez enregistrer votre fabrique d’éditeur à l’aide de la SVsRegisterEditors service.If your VSPackage is written in unmanaged code, then you must register your editor factory by using the SVsRegisterEditors service.

Enregistrement d’une fabrique d’éditeur à l’aide du Code managéRegistering an Editor Factory by Using Managed Code

Vous devez enregistrer votre fabrique d’éditeur dans votre VSPackage le Initialize (méthode).You must register your editor factory in your VSPackage's the Initialize method. Tout d’abord appeler base.Initialize, puis appelez RegisterEditorFactory pour chaque fabrique d’éditeurFirst call base.Initialize, and then call RegisterEditorFactory for each editor factory

En code managé, il n’est aucun nécessaire d’annuler l’inscription d’une fabrique d’éditeur, car le VSPackage gère cela pour vous.In managed code, there is no need to unregister an editor factory, because the VSPackage will handle this for you. En outre, si votre fabrique d’éditeur implémente IDisposable, elle est automatiquement supprimée lorsqu’elle est annulée.Also, if your editor factory implements IDisposable, it is automatically disposed when it is unregistered.

L’inscription d’une fabrique d’éditeur à l’aide de code non managéRegistering an editor factory by using unmanaged code

Dans le SetSite implémentation pour votre package de l’éditeur, utilisez le QueryService méthode à appeler SVsRegisterEditors.In the SetSite implementation for your editor package, use the QueryService method to call SVsRegisterEditors. Cette opération retourne un pointeur vers IVsRegisterEditors.Doing this returns a pointer to IVsRegisterEditors. Appelez le RegisterEditor méthode en passant votre implémentation de la IVsEditorFactory interface.Call the RegisterEditor method by passing your implementation of the IVsEditorFactory interface. Vous devez appliquer IVsEditorFactory dans une classe distincte.You must mplement IVsEditorFactory in a separate class.

Le processus d’inscription de fabrique d’éditeurThe Editor Factory Registration Process

Le processus suivant se produit lorsque Visual Studio charge votre éditeur à l’aide de votre fabrique d’éditeur :The following process occurs when Visual Studio loads your editor using your editor factory:

  1. Le Visual StudioVisual Studio appels du système de projet OpenStandardEditor.The Visual StudioVisual Studio project system calls OpenStandardEditor.

  2. Cette méthode retourne la fabrique d’éditeur.This method returns the editor factory. Visual Studio des retards du chargement de package de l’éditeur, toutefois, jusqu'à ce qu’un système de projet a réellement besoin l’éditeur.Visual Studio delays loading the editor's package, however, until a project system actually needs the editor.

  3. Quand un système de projet a besoin de l’éditeur, Visual Studio appelle CreateEditorInstance, une méthode spécialisée qui retourne des objets de données de l’affichage du document et le document.When a project system needs the editor, Visual Studio calls CreateEditorInstance, a specialized method that returns both the document view and the document data objects.

  4. Si appels par Visual Studio à votre fabrique d’éditeur à l’aide CreateEditorInstance retourner un objet de données de document et un objet de vue de document, Visual Studio crée la fenêtre de document, place l’objet de vue de document qu’elle contient, puis crée une entrée dans le document en cours d’exécution table (r & DT) pour l’objet de données du document.If calls by Visual Studio to your editor factory using CreateEditorInstance return both a document data object and a document view object, Visual Studio then creates the document window, places the document view object in it, and makes an entry into the running document table (RDT) for the document data object.

Voir aussiSee Also

IVsEditorFactory
Exécution de la table de documentRunning Document Table