Tutorial: Mostrar ayuda de firma

La Ayuda de firma (también conocida como Información de parámetros) muestra la firma de un método en una información sobre herramientas cuando un usuario escribe el carácter de inicio de la lista de parámetros (normalmente un paréntesis de apertura). Como parámetro y separador de parámetros (normalmente una coma) se escriben, la información sobre herramientas se actualiza para mostrar el siguiente parámetro en negrita. Puede definir la Ayuda de firma de las maneras siguientes: en el contexto de un servicio de lenguaje, defina su propia extensión de nombre de archivo y tipo de contenido y muestre la Ayuda de firma solo para ese tipo, o muestre la Ayuda de firma para un tipo de contenido existente (por ejemplo, "texto"). En este tutorial se muestra cómo mostrar la Ayuda de firma para el tipo de contenido "texto".

La Ayuda de firma se desencadena normalmente escribiendo un carácter específico, por ejemplo, "(" (paréntesis de apertura) y descartado escribiendo otro carácter, por ejemplo, ")" (paréntesis de cierre). Las características de IntelliSense que se desencadenan escribiendo un carácter se pueden implementar mediante un controlador de comandos para las pulsaciones de tecla (la IOleCommandTarget interfaz) y un proveedor de controladores que implementa la IVsTextViewCreationListener interfaz. Para crear el origen de la Ayuda de firma, que es la lista de firmas que participan en la Ayuda de firma, implemente la ISignatureHelpSource interfaz y un proveedor de origen que ejecute la ISignatureHelpSourceProvider interfaz. Los proveedores son componentes de Managed Extensibility Framework (MEF) y son responsables de exportar las clases de origen y controlador e importar servicios y agentes, por ejemplo, , que ITextStructureNavigatorSelectorServicele permite navegar en el búfer de texto y , ISignatureHelpBrokerque desencadena la sesión de Ayuda de firma.

En este tutorial se muestra cómo configurar la Ayuda de firma para un conjunto codificado de identificadores de forma rígida. En implementaciones completas, el lenguaje es responsable de proporcionar ese contenido.

Creación de un proyecto MEF

Para crear un nuevo proyecto de MEF

1. Cree un proyecto VSIX de C#. (En Cuadro de diálogo Nuevo proyecto , seleccione Visual C# / Extensibilidad y, después , Proyecto VSIX). Asigne un nombre a la solución SignatureHelpTest.

2. Agregue una plantilla de elemento clasificador del editor al proyecto. Para obtener más información, vea Creación de una extensión con una plantilla de elemento de editor.

3. Elimine los archivos de clase existentes.

4. Agregue las siguientes referencias al proyecto y asegúrese de que CopyLocal esté establecido falseen :

   Microsoft.VisualStudio.Editor

   Microsoft.VisualStudio.Language.Intellisense

   Microsoft.VisualStudio.OLE.Interop

   Microsoft.VisualStudio.Shell.14.0

   Microsoft.VisualStudio.TextManager.Interop

Implementar firmas y parámetros de la Ayuda de firma

El origen de la Ayuda de firma se basa en firmas que implementan ISignature, cada una de las cuales contiene parámetros que implementan IParameter. En una implementación completa, esta información se obtendría de la documentación del lenguaje, pero en este ejemplo, las firmas están codificadas de forma rígida.

Para implementar las firmas y parámetros de la Ayuda de firma

1. Agregue un archivo de clase y asígnele el nombre SignatureHelpSource.

2. Agregue las importaciones siguientes.

   C#

   using System;
   using System.Collections.Generic;
   using System.Collections.ObjectModel;
   using System.ComponentModel.Composition;
   using System.Runtime.InteropServices;
   using Microsoft.VisualStudio.Language.Intellisense;
   using Microsoft.VisualStudio.Text;
   using Microsoft.VisualStudio.Text.Editor;
   using Microsoft.VisualStudio.Utilities;
   using Microsoft.VisualStudio.Editor;
   using Microsoft.VisualStudio.Text.Operations;
   using Microsoft.VisualStudio;
   using Microsoft.VisualStudio.TextManager.Interop;
   using Microsoft.VisualStudio.OLE.Interop;
   

   VB

   Imports System
   Imports System.Collections.Generic
   Imports System.Linq
   Imports System.Text
   Imports System.Collections.ObjectModel
   Imports System.ComponentModel.Composition
   Imports System.Runtime.InteropServices
   Imports Microsoft.VisualStudio.Language.Intellisense
   Imports Microsoft.VisualStudio.Text
   Imports Microsoft.VisualStudio.Text.Editor
   Imports Microsoft.VisualStudio.Utilities
   Imports Microsoft.VisualStudio.Editor
   Imports Microsoft.VisualStudio.Text.Operations
   Imports Microsoft.VisualStudio
   Imports Microsoft.VisualStudio.TextManager.Interop
   Imports Microsoft.VisualStudio.OLE.Interop
   

3. Agregue una clase denominada TestParameter que implemente IParameter.

   C#

   internal class TestParameter : IParameter
   

   VB

   Friend Class TestParameter
       Implements IParameter
   

4. Agregue un constructor que establezca todas las propiedades.

   C#

   public TestParameter(string documentation, Span locus, string name, ISignature signature)
   {
       Documentation = documentation;
       Locus = locus;
       Name = name;
       Signature = signature;
   }
   

   VB

   Public Sub New(ByVal documentation As String, ByVal locus As Span, ByVal name As String, ByVal signature As ISignature)
       Me.privateDocumentation = documentation
       Me.privateLocus = locus
       Me.privateName = name
       Me.privateSignature = signature
   End Sub
   

5. Agregue las propiedades de IParameter.

   C#

   public string Documentation { get; private set; }
   public Span Locus { get; private set; }
   public string Name { get; private set; }
   public ISignature Signature { get; private set; }
   public Span PrettyPrintedLocus { get; private set; }
   

   VB

   Private privateDocumentation As String
   ReadOnly Property Documentation() As String Implements IParameter.Documentation
       Get
           Return privateDocumentation
       End Get
   
   End Property
   Private privateLocus As Span
   ReadOnly Property Locus() As Span Implements IParameter.Locus
       Get
           Return privateLocus
       End Get
   End Property
   Private privateName As String
   ReadOnly Property Name() As String Implements IParameter.Name
       Get
           Return privateName
       End Get
   End Property
   Private privateSignature As ISignature
   ReadOnly Property Signature() As ISignature Implements IParameter.Signature
       Get
           Return privateSignature
       End Get
   End Property
   Private privatePrettyPrintedLocus As Span
   ReadOnly Property PrettyPrintedLocus() As Span Implements IParameter.PrettyPrintedLocus
       Get
           Return privatePrettyPrintedLocus
       End Get
   End Property
   

6. Agregue una clase denominada TestSignature que implemente ISignature.

   C#

   internal class TestSignature : ISignature
   

   VB

   Friend Class TestSignature
       Implements ISignature
   

7. Agregue algunos campos privados.

   C#

   private ITextBuffer m_subjectBuffer;
   private IParameter m_currentParameter;
   private string m_content;
   private string m_documentation;
   private ITrackingSpan m_applicableToSpan;
   private ReadOnlyCollection<IParameter> m_parameters;
   private string m_printContent;
   

   VB

   Private m_subjectBuffer As ITextBuffer
   Private m_currentParameter As IParameter
   Private m_content As String
   Private m_documentation As String
   Friend m_applicableToSpan As ITrackingSpan
   Friend m_parameters As ReadOnlyCollection(Of IParameter)
   Private m_printContent As String
   

8. Agregue un constructor que establezca los campos y se suscriba al Changed evento.

   C#

   internal TestSignature(ITextBuffer subjectBuffer, string content, string doc, ReadOnlyCollection<IParameter> parameters)
   {
       m_subjectBuffer = subjectBuffer;
       m_content = content;
       m_documentation = doc;
       m_parameters = parameters;
       m_subjectBuffer.Changed += new EventHandler<TextContentChangedEventArgs>(OnSubjectBufferChanged);
   }
   

   VB

   Friend Sub New(ByVal subjectBuffer As ITextBuffer, ByVal content As String, ByVal doc As String, ByVal parameters As ReadOnlyCollection(Of IParameter))
       m_subjectBuffer = subjectBuffer
       m_content = content
       m_documentation = doc
       m_parameters = parameters
       AddHandler m_subjectBuffer.Changed, AddressOf OnSubjectBufferChanged
   End Sub
   

9. Declare un CurrentParameterChanged evento. Este evento se genera cuando el usuario rellena uno de los parámetros de la firma.

   C#

   public event EventHandler<CurrentParameterChangedEventArgs> CurrentParameterChanged;
   

   VB

   Public Event CurrentParameterChanged As EventHandler(Of CurrentParameterChangedEventArgs) Implements ISignature.CurrentParameterChanged
   

10. Implemente la CurrentParameter propiedad para que genere el CurrentParameterChanged evento cuando se cambie el valor de la propiedad.

    C#

    public IParameter CurrentParameter
    {
        get { return m_currentParameter; }
        internal set
        {
            if (m_currentParameter != value)
            {
                IParameter prevCurrentParameter = m_currentParameter;
                m_currentParameter = value;
                this.RaiseCurrentParameterChanged(prevCurrentParameter, m_currentParameter);
            }
        }
    }
    

    VB

    ReadOnly Property CurrentParameter() As IParameter Implements ISignature.CurrentParameter
        Get
            Return m_currentParameter
        End Get
    End Property
    

11. Agregue un método que genere el CurrentParameterChanged evento.

    C#

    private void RaiseCurrentParameterChanged(IParameter prevCurrentParameter, IParameter newCurrentParameter)
    {
        EventHandler<CurrentParameterChangedEventArgs> tempHandler = this.CurrentParameterChanged;
        if (tempHandler != null)
        {
            tempHandler(this, new CurrentParameterChangedEventArgs(prevCurrentParameter, newCurrentParameter));
        }
    }
    

    VB

    Private Sub RaiseCurrentParameterChanged(ByVal prevCurrentParameter As IParameter, ByVal newCurrentParameter As IParameter)
        Dim tempHandler As EventHandler(Of CurrentParameterChangedEventArgs) = Me.CurrentParameterChangedEvent
        If tempHandler IsNot Nothing Then
            tempHandler(Me, New CurrentParameterChangedEventArgs(prevCurrentParameter, newCurrentParameter))
        End If
    End Sub
    

12. Agregue un método que calcule el parámetro actual comparando el número de comas en con ApplicableToSpan el número de comas de la firma.

    C#

    internal void ComputeCurrentParameter()
    {
        if (Parameters.Count == 0)
        {
            this.CurrentParameter = null;
            return;
        }
    
        //the number of commas in the string is the index of the current parameter
        string sigText = ApplicableToSpan.GetText(m_subjectBuffer.CurrentSnapshot);
    
        int currentIndex = 0;
        int commaCount = 0;
        while (currentIndex < sigText.Length)
        {
            int commaIndex = sigText.IndexOf(',', currentIndex);
            if (commaIndex == -1)
            {
                break;
            }
            commaCount++;
            currentIndex = commaIndex + 1;
        }
    
        if (commaCount < Parameters.Count)
        {
            this.CurrentParameter = Parameters[commaCount];
        }
        else
        {
            //too many commas, so use the last parameter as the current one.
            this.CurrentParameter = Parameters[Parameters.Count - 1];
        }
    }
    

    VB

    Friend Sub ComputeCurrentParameter()
        If Parameters.Count = 0 Then
            Me.m_currentParameter = Nothing
            Return
        End If
    
        'the number of commas in the string is the index of the current parameter
        Dim sigText As String = ApplicableToSpan.GetText(m_subjectBuffer.CurrentSnapshot)
    
        Dim currentIndex As Integer = 0
        Dim commaCount As Integer = 0
        Do While currentIndex < sigText.Length
            Dim commaIndex As Integer = sigText.IndexOf(","c, currentIndex)
            If commaIndex = -1 Then
                Exit Do
            End If
            commaCount += 1
            currentIndex = commaIndex + 1
        Loop
    
        If commaCount < Parameters.Count Then
            Me.m_currentParameter = Parameters(commaCount)
        Else
            'too many commas, so use the last parameter as the current one.
            Me.m_currentParameter = Parameters(Parameters.Count - 1)
        End If
    End Sub
    

13. Agregue un controlador de eventos para el Changed evento que llama al ComputeCurrentParameter() método .

    C#

    internal void OnSubjectBufferChanged(object sender, TextContentChangedEventArgs e)
    {
        this.ComputeCurrentParameter();
    }
    

    VB

    Friend Sub OnSubjectBufferChanged(ByVal sender As Object, ByVal e As TextContentChangedEventArgs)
        Me.ComputeCurrentParameter()
    End Sub
    

14. Implemente la propiedad ApplicableToSpan. Esta propiedad contiene un ITrackingSpan que corresponde al intervalo de texto del búfer al que se aplica la firma.

    C#

    public ITrackingSpan ApplicableToSpan
    {
        get { return (m_applicableToSpan); }
        internal set { m_applicableToSpan = value; }
    }
    

    VB

    ReadOnly Property ApplicableToSpan() As ITrackingSpan Implements ISignature.ApplicableToSpan
        Get
            Return (m_applicableToSpan)
        End Get
    End Property
    

15. Implemente los demás parámetros.

    C#

    public string Content
    {
        get { return (m_content); }
        internal set { m_content = value; }
    }
    
    public string Documentation
    {
        get { return (m_documentation); }
        internal set { m_documentation = value; }
    }
    
    public ReadOnlyCollection<IParameter> Parameters
    {
        get { return (m_parameters); }
        internal set { m_parameters = value; }
    }
    
    public string PrettyPrintedContent
    {
        get { return (m_printContent); }
        internal set { m_printContent = value; }
    }
    

    VB

    ReadOnly Property Content() As String Implements ISignature.Content
        Get
            Return (m_content)
        End Get
    End Property
    
    ReadOnly Property Documentation() As String Implements ISignature.Documentation
        Get
            Return (m_documentation)
        End Get
    End Property
    
    ReadOnly Property Parameters() As ReadOnlyCollection(Of IParameter) Implements ISignature.Parameters
        Get
            Return (m_parameters)
        End Get
    End Property
    
    ReadOnly Property PrettyPrintedContent() As String Implements ISignature.PrettyPrintedContent
        Get
            Return (m_printContent)
        End Get
    End Property
    

Implementación del origen de la Ayuda de firma

El origen de la Ayuda de firma es el conjunto de firmas para las que se proporciona información.

Para implementar el origen de la Ayuda de firma

1. Agregue una clase denominada TestSignatureHelpSource que implemente ISignatureHelpSource.

   C#

   internal class TestSignatureHelpSource : ISignatureHelpSource
   

   VB

   Friend Class TestSignatureHelpSource
       Implements ISignatureHelpSource
   

2. Agregue una referencia al búfer de texto.

   C#

   private ITextBuffer m_textBuffer;
   

   VB

   Private m_textBuffer As ITextBuffer
   

3. Agregue un constructor que establezca el búfer de texto y el proveedor de origen de la Ayuda de firma.

   C#

   public TestSignatureHelpSource(ITextBuffer textBuffer)
   {
       m_textBuffer = textBuffer;
   }
   

   VB

   Public Sub New(ByVal textBuffer As ITextBuffer)
       m_textBuffer = textBuffer
   End Sub
   

4. Implemente el método AugmentSignatureHelpSession. En este ejemplo, las firmas están codificadas de forma rígida, pero en una implementación completa obtendrá esta información de la documentación del lenguaje.

   C#

   public void AugmentSignatureHelpSession(ISignatureHelpSession session, IList<ISignature> signatures)
   {
       ITextSnapshot snapshot = m_textBuffer.CurrentSnapshot;
       int position = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot);
   
       ITrackingSpan applicableToSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(
        new Span(position, 0), SpanTrackingMode.EdgeInclusive, 0);
   
       signatures.Add(CreateSignature(m_textBuffer, "add(int firstInt, int secondInt)", "Documentation for adding integers.", applicableToSpan));
       signatures.Add(CreateSignature(m_textBuffer, "add(double firstDouble, double secondDouble)", "Documentation for adding doubles.", applicableToSpan));
   
   }
   

   VB

   Public Sub AugmentSignatureHelpSession(ByVal session As ISignatureHelpSession, ByVal signatures As IList(Of ISignature)) Implements ISignatureHelpSource.AugmentSignatureHelpSession
       Dim snapshot As ITextSnapshot = m_textBuffer.CurrentSnapshot
       Dim position As Integer = session.GetTriggerPoint(m_textBuffer).GetPosition(snapshot)
   
       Dim applicableToSpan As ITrackingSpan = m_textBuffer.CurrentSnapshot.CreateTrackingSpan(New Span(position, 0), SpanTrackingMode.EdgeInclusive, 0)
   
       signatures.Add(CreateSignature(m_textBuffer, "add(int firstInt, int secondInt)", "Documentation for adding integers.", applicableToSpan))
       signatures.Add(CreateSignature(m_textBuffer, "add(double firstDouble, double secondDouble)", "Documentation for adding doubles.", applicableToSpan))
   End Sub
   

5. El método CreateSignature() auxiliar se proporciona solo para la ilustración.

   C#

   private TestSignature CreateSignature(ITextBuffer textBuffer, string methodSig, string methodDoc, ITrackingSpan span)
   {
       TestSignature sig = new TestSignature(textBuffer, methodSig, methodDoc, null);
       textBuffer.Changed += new EventHandler<TextContentChangedEventArgs>(sig.OnSubjectBufferChanged);
   
       //find the parameters in the method signature (expect methodname(one, two)
       string[] pars = methodSig.Split(new char[] { '(', ',', ')' });
       List<IParameter> paramList = new List<IParameter>();
   
       int locusSearchStart = 0;
       for (int i = 1; i < pars.Length; i++)
       {
           string param = pars[i].Trim();
   
           if (string.IsNullOrEmpty(param))
               continue;
   
           //find where this parameter is located in the method signature
           int locusStart = methodSig.IndexOf(param, locusSearchStart);
           if (locusStart >= 0)
           {
               Span locus = new Span(locusStart, param.Length);
               locusSearchStart = locusStart + param.Length;
               paramList.Add(new TestParameter("Documentation for the parameter.", locus, param, sig));
           }
       }
   
       sig.Parameters = new ReadOnlyCollection<IParameter>(paramList);
       sig.ApplicableToSpan = span;
       sig.ComputeCurrentParameter();
       return sig;
   }
   

   VB

   Private Function CreateSignature(ByVal textBuffer As ITextBuffer, ByVal methodSig As String, ByVal methodDoc As String, ByVal span As ITrackingSpan) As TestSignature
       Dim sig As New TestSignature(textBuffer, methodSig, methodDoc, Nothing)
       AddHandler textBuffer.Changed, AddressOf sig.OnSubjectBufferChanged
   
       'find the parameters in the method signature (expect methodname(one, two)
       Dim pars() As String = methodSig.Split(New Char() {"("c, ","c, ")"c})
       Dim paramList As New List(Of IParameter)()
   
       Dim locusSearchStart As Integer = 0
       For i As Integer = 1 To pars.Length - 1
           Dim param As String = pars(i).Trim()
   
           If String.IsNullOrEmpty(param) Then
               Continue For
           End If
   
           'find where this parameter is located in the method signature
           Dim locusStart As Integer = methodSig.IndexOf(param, locusSearchStart)
           If locusStart >= 0 Then
               Dim locus As New Span(locusStart, param.Length)
               locusSearchStart = locusStart + param.Length
               paramList.Add(New TestParameter("Documentation for the parameter.", locus, param, sig))
           End If
       Next i
   
       sig.m_Parameters = New ReadOnlyCollection(Of IParameter)(paramList)
       sig.m_ApplicableToSpan = span
       sig.ComputeCurrentParameter()
       Return sig
   End Function
   

6. Implemente el método GetBestMatch. En este ejemplo, solo hay dos firmas, cada una de las cuales tiene dos parámetros. Por lo tanto, este método no es necesario. En una implementación más completa, en la que hay disponible más de un origen de ayuda de firma, este método se usa para decidir si el origen de ayuda de firma de prioridad más alta puede proporcionar una firma coincidente. Si no es posible, el método devuelve null y se pide al origen de prioridad más alta que proporcione una coincidencia.

   C#

   public ISignature GetBestMatch(ISignatureHelpSession session)
   {
       if (session.Signatures.Count > 0)
       {
           ITrackingSpan applicableToSpan = session.Signatures[0].ApplicableToSpan;
           string text = applicableToSpan.GetText(applicableToSpan.TextBuffer.CurrentSnapshot);
   
           if (text.Trim().Equals("add"))  //get only "add" 
               return session.Signatures[0];
       }
       return null;
   }
   

   VB

   Public Function GetBestMatch(ByVal session As ISignatureHelpSession) As ISignature Implements ISignatureHelpSource.GetBestMatch
       If session.Signatures.Count > 0 Then
           Dim applicableToSpan As ITrackingSpan = session.Signatures(0).ApplicableToSpan
           Dim text As String = applicableToSpan.GetText(applicableToSpan.TextBuffer.CurrentSnapshot)
   
           If text.Trim().Equals("add") Then 'get only "add"
               Return session.Signatures(0)
           End If
       End If
       Return Nothing
   End Function
   

7. Implemente el Dispose() método :

   C#

   private bool m_isDisposed;
   public void Dispose()
   {
       if (!m_isDisposed)
       {
           GC.SuppressFinalize(this);
           m_isDisposed = true;
       }
   }
   

   VB

   Private m_isDisposed As Boolean
   
   Public Sub Dispose() Implements IDisposable.Dispose
       If Not m_isDisposed Then
           GC.SuppressFinalize(Me)
           m_isDisposed = True
       End If
   End Sub
   

Implementación del proveedor de origen de la Ayuda de firma

El proveedor de origen de la Ayuda de firma es responsable de exportar la parte del componente Managed Extensibility Framework (MEF) y para crear instancias del origen de la Ayuda de firma.

Para implementar el proveedor de origen de la Ayuda de firma

1. Agregue una clase denominada TestSignatureHelpSourceProvider que implemente ISignatureHelpSourceProvidery expórtela con un NameAttribute, un ContentTypeAttribute de "texto" y un OrderAttribute valor de Before="default".

   C#

   [Export(typeof(ISignatureHelpSourceProvider))]
   [Name("Signature Help source")]
   [Order(Before = "default")]
   [ContentType("text")]
   internal class TestSignatureHelpSourceProvider : ISignatureHelpSourceProvider
   

   VB

   <Export(GetType(ISignatureHelpSourceProvider)), Name("Signature Help source"), Order(Before:="default"), ContentType("text")>
   Friend Class TestSignatureHelpSourceProvider
       Implements ISignatureHelpSourceProvider
   

2. Implemente TryCreateSignatureHelpSource mediante la creación de instancias de TestSignatureHelpSource.

   C#

   public ISignatureHelpSource TryCreateSignatureHelpSource(ITextBuffer textBuffer)
   {
       return new TestSignatureHelpSource(textBuffer);
   }
   

   VB

   Public Function TryCreateSignatureHelpSource(ByVal textBuffer As ITextBuffer) As ISignatureHelpSource Implements ISignatureHelpSourceProvider.TryCreateSignatureHelpSource
       Return New TestSignatureHelpSource(textBuffer)
   End Function
   

Implementación del controlador de comandos

La Ayuda de firma normalmente se desencadena mediante un carácter de paréntesis de apertura "(" y descartado por un carácter de paréntesis de cierre ")". Puede controlar estas pulsaciones de tecla ejecutando para IOleCommandTarget que desencadene una sesión de Ayuda de firma cuando reciba un carácter de paréntesis de apertura precedido por un nombre de método conocido y descarta la sesión cuando recibe un carácter de paréntesis de cierre.

Para implementar el controlador de comandos

1. Agregue una clase denominada TestSignatureHelpCommand que implemente IOleCommandTarget.

   C#

   internal sealed class TestSignatureHelpCommandHandler : IOleCommandTarget
   

   VB

   Friend NotInheritable Class TestSignatureHelpCommandHandler
       Implements IOleCommandTarget
   

2. Agregue campos privados para el IVsTextView adaptador (que le permite agregar el controlador de comandos a la cadena de controladores de comandos), la vista de texto, el agente de ayuda de firma y la sesión, un ITextStructureNavigatory el siguiente IOleCommandTarget.

   C#

   IOleCommandTarget m_nextCommandHandler;
   ITextView m_textView;
   ISignatureHelpBroker m_broker;
   ISignatureHelpSession m_session;
   ITextStructureNavigator m_navigator;
   

   VB

   Private m_nextCommandHandler As IOleCommandTarget
   Private m_textView As ITextView
   Private m_broker As ISignatureHelpBroker
   Private m_session As ISignatureHelpSession
   Private m_navigator As ITextStructureNavigator
   

3. Agregue un constructor para inicializar estos campos y para agregar el filtro de comandos a la cadena de filtros de comandos.

   C#

   internal TestSignatureHelpCommandHandler(IVsTextView textViewAdapter, ITextView textView, ITextStructureNavigator nav, ISignatureHelpBroker broker)
   {
       this.m_textView = textView;
       this.m_broker = broker;
       this.m_navigator = nav;
   
       //add this to the filter chain
       textViewAdapter.AddCommandFilter(this, out m_nextCommandHandler);
   }
   

   VB

   Friend Sub New(ByVal textViewAdapter As IVsTextView, ByVal textView As ITextView, ByVal nav As ITextStructureNavigator, ByVal broker As ISignatureHelpBroker)
       Me.m_textView = textView
       Me.m_broker = broker
       Me.m_navigator = nav
   
       'add this to the filter chain
       textViewAdapter.AddCommandFilter(Me, m_nextCommandHandler)
   End Sub
   

4. Implemente el Exec método para desencadenar la sesión de ayuda de firma cuando el filtro de comandos recibe un paréntesis de apertura "(" carácter después de uno de los nombres de método conocidos y para descartar la sesión cuando recibe un carácter de paréntesis de cierre ")" mientras la sesión sigue activa. En cada caso, el comando se reenvía.

   C#

   public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
   {
       char typedChar = char.MinValue;
   
       if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
       {
           typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
           if (typedChar.Equals('('))
           {
               //move the point back so it's in the preceding word
               SnapshotPoint point = m_textView.Caret.Position.BufferPosition - 1;
               TextExtent extent = m_navigator.GetExtentOfWord(point);
               string word = extent.Span.GetText();
               if (word.Equals("add"))
                   m_session = m_broker.TriggerSignatureHelp(m_textView);
   
           }
           else if (typedChar.Equals(')') && m_session != null)
           {
               m_session.Dismiss();
               m_session = null;
           }
       }
       return m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
   }
   

   VB

   Public Function Exec(ByRef pguidCmdGroup As Guid, ByVal nCmdID As UInteger, ByVal nCmdexecopt As UInteger, ByVal pvaIn As IntPtr, ByVal pvaOut As IntPtr) As Integer Implements IOleCommandTarget.Exec
       Dim typedChar As Char = Char.MinValue
   
       If pguidCmdGroup = VSConstants.VSStd2K AndAlso nCmdID = CUInt(VSConstants.VSStd2KCmdID.TYPECHAR) Then
           typedChar = CChar(ChrW(CUShort(Marshal.GetObjectForNativeVariant(pvaIn))))
           If typedChar.Equals("("c) Then
               'move the point back so it's in the preceding word
               Dim point As SnapshotPoint = m_textView.Caret.Position.BufferPosition - 1
               Dim extent As TextExtent = m_navigator.GetExtentOfWord(point)
               Dim word As String = extent.Span.GetText()
               If word.Equals("add") Then
                   m_session = m_broker.TriggerSignatureHelp(m_textView)
               End If
   
           ElseIf typedChar.Equals(")"c) AndAlso m_session IsNot Nothing Then
               m_session.Dismiss()
               m_session = Nothing
           End If
       End If
       Return m_nextCommandHandler.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)
   End Function
   

5. Implemente el QueryStatus método para que siempre reenvíe el comando.

   C#

   public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
   {
       return m_nextCommandHandler.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
   }
   

   VB

   Public Function QueryStatus(ByRef pguidCmdGroup As Guid, ByVal cCmds As UInteger, ByVal prgCmds() As OLECMD, ByVal pCmdText As IntPtr) As Integer Implements IOleCommandTarget.QueryStatus
       Return m_nextCommandHandler.QueryStatus(pguidCmdGroup, cCmds, prgCmds, pCmdText)
   End Function
   

Implementación del proveedor de comandos de la Ayuda de firma

Puede proporcionar el comando Ayuda de firma implementando para IVsTextViewCreationListener crear una instancia del controlador de comandos cuando se crea la vista de texto.

Para implementar el proveedor de comandos de la Ayuda de firma

1. Agregue una clase denominada TestSignatureHelpController que implementa IVsTextViewCreationListener y exporte con , NameAttributeContentTypeAttributey TextViewRoleAttribute.

   C#

   [Export(typeof(IVsTextViewCreationListener))]
   [Name("Signature Help controller")]
   [TextViewRole(PredefinedTextViewRoles.Editable)]
   [ContentType("text")]
   internal class TestSignatureHelpCommandProvider : IVsTextViewCreationListener
   

   VB

   <Export(GetType(IVsTextViewCreationListener)), Name("Signature Help controller"), TextViewRole(PredefinedTextViewRoles.Editable), ContentType("text")>
   Friend Class TestSignatureHelpCommandProvider
       Implements IVsTextViewCreationListener
   

2. IVsEditorAdaptersFactoryService Importe (usado para obtener , ITextViewdado el IVsTextView objeto ), ITextStructureNavigatorSelectorService (que se usa para buscar la palabra actual) y el ISignatureHelpBroker objeto (para desencadenar la sesión de Ayuda de firma).

   C#

   [Import]
   internal IVsEditorAdaptersFactoryService AdapterService;
   
   [Import]
   internal ITextStructureNavigatorSelectorService NavigatorService { get; set; }
   
   [Import]
   internal ISignatureHelpBroker SignatureHelpBroker;
   

   VB

   <Import()>
   Friend AdapterService As IVsEditorAdaptersFactoryService
   
   <Import()>
   Friend Property NavigatorService() As ITextStructureNavigatorSelectorService
   
   <Import()>
   Friend SignatureHelpBroker As ISignatureHelpBroker
   

3. Implemente el método mediante la VsTextViewCreated creación de instancias de TestSignatureCommandHandler.

   C#

   public void VsTextViewCreated(IVsTextView textViewAdapter)
   {
       ITextView textView = AdapterService.GetWpfTextView(textViewAdapter);
       if (textView == null)
           return;
   
       textView.Properties.GetOrCreateSingletonProperty(
            () => new TestSignatureHelpCommandHandler(textViewAdapter,
               textView,
               NavigatorService.GetTextStructureNavigator(textView.TextBuffer),
               SignatureHelpBroker));
   }
   

   VB

   Public Sub VsTextViewCreated(ByVal textViewAdapter As IVsTextView) Implements IVsTextViewCreationListener.VsTextViewCreated
       Dim textView As ITextView = AdapterService.GetWpfTextView(textViewAdapter)
       If textView Is Nothing Then
           Return
       End If
   
       textView.Properties.GetOrCreateSingletonProperty(Function() New TestSignatureHelpCommandHandler(textViewAdapter, textView, NavigatorService.GetTextStructureNavigator(textView.TextBuffer), SignatureHelpBroker))
   End Sub
   

Compilación y prueba del código

Para probar este código, compile la solución SignatureHelpTest y ejecútela en la instancia experimental.

Para compilar y probar la solución SignatureHelpTest

1. Compile la solución.

2. Al ejecutar este proyecto en el depurador, se inicia una segunda instancia de Visual Studio.

3. Cree un archivo de texto y escriba algún texto que incluya la palabra "add" más un paréntesis de apertura.

4. Después de escribir el paréntesis de apertura, debería ver una información sobre herramientas que muestra una lista de las dos firmas para el add() método .

Contenido relacionado

• Tutorial: Vinculación de un tipo de contenido a una extensión de nombre de archivo