Condividi tramite

procedura dettagliata: Visualizzazione delle descrizioni comandi di informazioni rapide

  • Articolo

Informazioni rapide è una funzionalità di IntelliSense per visualizzare le firme del metodo e le descrizioni quando un utente sposta il puntatore sul nome di un metodo. È possibile distribuire le funzionalità a livello di linguaggio quali informazioni rapide definizione di identificatori per il quale si desidera fornire descrizioni di informazioni rapide quindi creando una descrizione comandi in cui viene visualizzato il contenuto. È possibile definire informazioni rapide nel contesto del servizio di linguaggio, oppure è possibile definire diventi proprietaria l'estensione di file e il tipo di contenuto e per la visualizzazione di informazioni rapide solo per tale tipo, oppure è possibile visualizzare informazioni rapide per un tipo di contenuto esistente (ad esempio “testo„). In questa procedura dettagliata viene illustrato come visualizzare informazioni rapide per il tipo di contenuto “text„.

L'esempio di informazioni rapide in questa procedura dettagliata vengono visualizzate le descrizioni comandi quando un utente sposta il puntatore sul nome di un metodo. Questa progettazione è necessario implementare queste quattro interfacce:

  • interfaccia di origine

  • interfaccia provider di origine

  • interfaccia del controller

  • interfaccia provider del controller

I provider del controller e di origine sono elementi gestiti (MEF) del Framework di estensibilità e sono responsabili dell'esportazione del database di origine e classi controller e di includere i servizi e i Service Broker come ITextBufferFactoryService, che crea il buffer di testo di descrizione comando e IQuickInfoBroker, che genera la sessione di informazioni rapide.

In questo esempio, l'origine di informazioni rapide utilizza un elenco specificato a livello di codice dei nomi del metodo e descrizioni, ma nelle implementazioni complete, il servizio di linguaggio e la documentazione del linguaggio sono responsabili della visualizzazione del contenuto.

Prerequisiti

Per completare questa procedura dettagliata, è necessario installare Visual Studio 2010 SDK.

Nota

per ulteriori informazioni su Visual Studio SDK, vedere Cenni preliminari sull'estensione di Visual Studio.Per ulteriori informazioni su come scaricare Visual Studio SDK, vedere Centro per sviluppatori di estensibilità di Visual Studio il sito Web MSDN.

Creare un progetto MEF

Per creare un progetto MEF

  1. Creare un progetto di classificatore editor. Assegnare alla soluzione QuickInfoTest.

  2. Aprire il file Source.extension.vsixmanifest nell'editor del manifesto VSIX.

  3. Assicurarsi che la direzione di Content contenga un tipo di contenuto componente MEF e che Path è impostato su QuickInfoTest.dll.

  4. salvare e chiudere Source.extension.vsixmanifest.

  5. Aggiungere il seguente riferimento al progetto e CopyLocal impostato su false:

    Microsoft.VisualStudio.Language.Intellisense

  6. Eliminare i file di classe esistenti.

Distribuire il database di origine di informazioni rapide

L'origine di informazioni rapide è responsabile della raccolta del set di identificatori e le relative descrizioni e dell'aggiunta di contenuto al buffer di testo di descrizione comando quando uno degli identificatori viene rilevato. In questo esempio, gli identificatori e le relative descrizioni vengono aggiunti solo nel costruttore di origine.

Per distribuire il database di origine di informazioni rapide

  1. Aggiungere il file di classe e denominarlo TestQuickInfoSource.

  2. Aggiungere i seguenti elementi importati.

    Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Text
Imports System.Collections.ObjectModel
Imports System.ComponentModel.Composition
Imports Microsoft.VisualStudio.Language.Intellisense
Imports Microsoft.VisualStudio.Text
Imports Microsoft.VisualStudio.Text.Editor
Imports Microsoft.VisualStudio.Text.Operations
Imports Microsoft.VisualStudio.Text.Tagging
Imports Microsoft.VisualStudio.Utilities

    using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Text.Operations;
using Microsoft.VisualStudio.Text.Tagging;
using Microsoft.VisualStudio.Utilities;

  3. Dichiarare una classe che implementa IQuickInfoSourcee denominarla TestQuickInfoSource.

    Friend Class TestQuickInfoSource
    Implements IQuickInfoSource

    internal class TestQuickInfoSource : IQuickInfoSource

  4. Aggiungere campi per il provider di origine di informazioni rapide, il buffer di testo e un set di nomi del metodo e la firma del metodo. In questo esempio, i nomi dei metodi e le firme vengono inizializzati nel costruttore di TestQuickInfoSource .

    Private m_provider As TestQuickInfoSourceProvider
Private m_subjectBuffer As ITextBuffer
Private m_dictionary As Dictionary(Of String, String)

    private TestQuickInfoSourceProvider m_provider;
private ITextBuffer m_subjectBuffer;
private Dictionary<string, string> m_dictionary;

  5. Aggiungere un costruttore che imposta il provider di origine di informazioni rapide e il buffer di testo e popolato il set di nomi del metodo e firme del metodo e descrizioni.

    Public Sub New(ByVal provider As TestQuickInfoSourceProvider, ByVal subjectBuffer As ITextBuffer)
    m_provider = provider
    m_subjectBuffer = subjectBuffer

    'these are the method names and their descriptions
    m_dictionary = New Dictionary(Of String, String)()
    m_dictionary.Add("add", "int add(int firstInt, int secondInt)" & vbLf & "Adds one integer to another.")
    m_dictionary.Add("subtract", "int subtract(int firstInt, int secondInt)" & vbLf & "Subtracts one integer from another.")
    m_dictionary.Add("multiply", "int multiply(int firstInt, int secondInt)" & vbLf & "Multiplies one integer by another.")
    m_dictionary.Add("divide", "int divide(int firstInt, int secondInt)" & vbLf & "Divides one integer by another.")
End Sub

    public TestQuickInfoSource(TestQuickInfoSourceProvider provider, ITextBuffer subjectBuffer)
{
    m_provider = provider;
    m_subjectBuffer = subjectBuffer;

    //these are the method names and their descriptions
    m_dictionary = new Dictionary<string, string>();
    m_dictionary.Add("add", "int add(int firstInt, int secondInt)\nAdds one integer to another.");
    m_dictionary.Add("subtract", "int subtract(int firstInt, int secondInt)\nSubtracts one integer from another.");
    m_dictionary.Add("multiply", "int multiply(int firstInt, int secondInt)\nMultiplies one integer by another.");
    m_dictionary.Add("divide", "int divide(int firstInt, int secondInt)\nDivides one integer by another.");
}

  6. Implementare il metodo AugmentQuickInfoSession. In questo esempio, il metodo trova la parola corrente, o la parola precedente se il cursore si trova alla fine di una riga o di un buffer di testo. Se la parola è uno dei nomi del metodo, la descrizione per il nome del metodo aggiunto al contenuto di informazioni rapide.

    Public Sub AugmentQuickInfoSession(ByVal session As IQuickInfoSession, ByVal qiContent As IList(Of Object), ByRef applicableToSpan As ITrackingSpan) Implements IQuickInfoSource.AugmentQuickInfoSession
    ' Map the trigger point down to our buffer. 
    Dim subjectTriggerPoint As System.Nullable(Of SnapshotPoint) = session.GetTriggerPoint(m_subjectBuffer.CurrentSnapshot)
    If Not subjectTriggerPoint.HasValue Then
        applicableToSpan = Nothing 
        Exit Sub 
    End If 

    Dim currentSnapshot As ITextSnapshot = subjectTriggerPoint.Value.Snapshot
    Dim querySpan As New SnapshotSpan(subjectTriggerPoint.Value, 0)

    'look for occurrences of our QuickInfo words in the span 
    Dim navigator As ITextStructureNavigator = m_provider.NavigatorService.GetTextStructureNavigator(m_subjectBuffer)
    Dim extent As TextExtent = navigator.GetExtentOfWord(subjectTriggerPoint.Value)
    Dim searchText As String = extent.Span.GetText()

    For Each key As String In m_dictionary.Keys
        Dim foundIndex As Integer = searchText.IndexOf(key, StringComparison.CurrentCultureIgnoreCase)
        If foundIndex > -1 Then
            applicableToSpan = currentSnapshot.CreateTrackingSpan(querySpan.Start.Add(foundIndex).Position, 9, SpanTrackingMode.EdgeInclusive)

            Dim value As String = ""
            m_dictionary.TryGetValue(key, value)
            If value IsNot Nothing Then
                qiContent.Add(value)
            Else
                qiContent.Add("")
            End If 

            Exit Sub 
        End If 
    Next

    applicableToSpan = Nothing 
End Sub

    public void AugmentQuickInfoSession(IQuickInfoSession session, IList<object> qiContent, out ITrackingSpan applicableToSpan)
{
    // Map the trigger point down to our buffer.
    SnapshotPoint? subjectTriggerPoint = session.GetTriggerPoint(m_subjectBuffer.CurrentSnapshot);
    if (!subjectTriggerPoint.HasValue)
    {
        applicableToSpan = null;
        return;
    }

    ITextSnapshot currentSnapshot = subjectTriggerPoint.Value.Snapshot;
    SnapshotSpan querySpan = new SnapshotSpan(subjectTriggerPoint.Value, 0);

    //look for occurrences of our QuickInfo words in the span
    ITextStructureNavigator navigator = m_provider.NavigatorService.GetTextStructureNavigator(m_subjectBuffer);
    TextExtent extent = navigator.GetExtentOfWord(subjectTriggerPoint.Value);
    string searchText = extent.Span.GetText();

    foreach (string key in m_dictionary.Keys)
    {
        int foundIndex = searchText.IndexOf(key, StringComparison.CurrentCultureIgnoreCase);
        if (foundIndex > -1)
        {
            applicableToSpan = currentSnapshot.CreateTrackingSpan
                (
                querySpan.Start.Add(foundIndex).Position, 9, SpanTrackingMode.EdgeInclusive
                );

            string value;
            m_dictionary.TryGetValue(key, out value);
            if (value != null)
                qiContent.Add(value);
            else
                qiContent.Add("");

            return;
        }
    }

    applicableToSpan = null;
}

  7. È inoltre necessario implementare un metodo di Dispose(), poiché IQuickInfoSource implementa IDisposable:

    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

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

Implementare un provider di origine di informazioni rapide

Il provider dell'origine di informazioni rapide viene utilizzato principalmente per esportare se stessa come elemento MEF e creare un'istanza del database di origine di informazioni rapide. Poiché è un elemento del framework MEF, può includere altri elementi del framework MEF.

Per implementare un provider di origine di informazioni rapide

  1. Dichiarare un provider di origine di informazioni rapide denominato TestQuickInfoSourceProvider che implementa IQuickInfoSourceProvidere esportarlo con NameAttribute “fonti di informazioni rapide di descrizione„, OrderAttribute di Before= " default„ e ContentTypeAttribute di “testo„.

    <Export(GetType(IQuickInfoSourceProvider))> _
<Name("ToolTip QuickInfo Source")> _
<Order(Before:=" Default Quick Info Presenter")> _
<ContentType("text")> _
Friend Class TestQuickInfoSourceProvider
    Implements IQuickInfoSourceProvider

    [Export(typeof(IQuickInfoSourceProvider))]
[Name("ToolTip QuickInfo Source")]
[Order(Before = "Default Quick Info Presenter")]
[ContentType("text")]
internal class TestQuickInfoSourceProvider : IQuickInfoSourceProvider

  2. Includere due servizi dell'editor, ITextStructureNavigatorSelectorService e ITextBufferFactoryService, come proprietà di TestQuickInfoSourceProvider.

    Private _NavigatorService As ITextStructureNavigatorSelectorService
<Import()> _
Friend Property NavigatorService() As ITextStructureNavigatorSelectorService
    Get 
        Return _NavigatorService
    End Get 
    Set(ByVal value As ITextStructureNavigatorSelectorService)
        _NavigatorService = value
    End Set 
End Property 

Private _TextBufferFactoryService As ITextBufferFactoryService
<Import()> _
Friend Property TextBufferFactoryService() As ITextBufferFactoryService
    Get 
        Return _TextBufferFactoryService
    End Get 
    Set(ByVal value As ITextBufferFactoryService)
        _TextBufferFactoryService = value
    End Set 
End Property

    [Import]
internal ITextStructureNavigatorSelectorService NavigatorService { get; set; }

[Import]
internal ITextBufferFactoryService TextBufferFactoryService { get; set; }

  3. TryCreateQuickInfoSource di implementare per restituire nuovo TestQuickInfoSource.

    Public Function TryCreateQuickInfoSource(ByVal textBuffer As ITextBuffer) As IQuickInfoSource Implements IQuickInfoSourceProvider.TryCreateQuickInfoSource
    Return New TestQuickInfoSource(Me, textBuffer)
End Function

    public IQuickInfoSource TryCreateQuickInfoSource(ITextBuffer textBuffer)
{
    return new TestQuickInfoSource(this, textBuffer);
}

Implementare un controller di informazioni rapide

Controller di informazioni rapide determinano quando informazioni rapide deve essere visualizzato. In questo esempio, informazioni rapide viene visualizzato quando il puntatore si trova su una parola che corrisponde a uno dei nomi del metodo. Il controller di informazioni rapide implementa un gestore eventi al passaggio del mouse che attiva una sessione di informazioni rapide.

Per implementare un controller di informazioni rapide

  1. Dichiarare una classe che implementa IIntellisenseControllere denominarla TestQuickInfoController.

    Friend Class TestQuickInfoController
    Implements IIntellisenseController

    internal class TestQuickInfoController : IIntellisenseController

  2. Aggiungere campi privati per la visualizzazione di testo, i buffer di testo rappresentati nella visualizzazione di testo, la sessione di informazioni rapide e il provider del controller di informazioni rapide.

    Private m_textView As ITextView
Private m_subjectBuffers As IList(Of ITextBuffer)
Private m_provider As TestQuickInfoControllerProvider
Private m_session As IQuickInfoSession

    private ITextView m_textView;
private IList<ITextBuffer> m_subjectBuffers;
private TestQuickInfoControllerProvider m_provider;
private IQuickInfoSession m_session;

  3. Aggiungere un costruttore che imposta i campi e viene aggiunto il gestore eventi del passaggio del mouse.

    Friend Sub New(ByVal textView As ITextView, ByVal subjectBuffers As IList(Of ITextBuffer), ByVal provider As TestQuickInfoControllerProvider)
    m_textView = textView
    m_subjectBuffers = subjectBuffers
    m_provider = provider

    AddHandler m_textView.MouseHover, AddressOf Me.OnTextViewMouseHover
End Sub

    internal TestQuickInfoController(ITextView textView, IList<ITextBuffer> subjectBuffers, TestQuickInfoControllerProvider provider)
{
    m_textView = textView;
    m_subjectBuffers = subjectBuffers;
    m_provider = provider;

    m_textView.MouseHover += this.OnTextViewMouseHover;
}

  4. Aggiungere il gestore eventi del passaggio del mouse che attiva la sessione di informazioni rapide.

    Private Sub OnTextViewMouseHover(ByVal sender As Object, ByVal e As MouseHoverEventArgs)
    'find the mouse position by mapping down to the subject buffer 
    Dim point As System.Nullable(Of SnapshotPoint) = m_textView.BufferGraph.MapDownToFirstMatch(New SnapshotPoint(m_textView.TextSnapshot, e.Position), PointTrackingMode.Positive, Function(snapshot) m_subjectBuffers.Contains(snapshot.TextBuffer), PositionAffinity.Predecessor)

    If point IsNot Nothing Then 
        Dim triggerPoint As ITrackingPoint = point.Value.Snapshot.CreateTrackingPoint(point.Value.Position, PointTrackingMode.Positive)

        If Not m_provider.QuickInfoBroker.IsQuickInfoActive(m_textView) Then
            m_session = m_provider.QuickInfoBroker.TriggerQuickInfo(m_textView, triggerPoint, True)
        End If 
    End If 
End Sub

    private void OnTextViewMouseHover(object sender, MouseHoverEventArgs e)
{
    //find the mouse position by mapping down to the subject buffer
    SnapshotPoint? point = m_textView.BufferGraph.MapDownToFirstMatch
         (new SnapshotPoint(m_textView.TextSnapshot, e.Position),
        PointTrackingMode.Positive,
        snapshot => m_subjectBuffers.Contains(snapshot.TextBuffer),
        PositionAffinity.Predecessor);

    if (point != null)
    {
        ITrackingPoint triggerPoint = point.Value.Snapshot.CreateTrackingPoint(point.Value.Position,
        PointTrackingMode.Positive);

        if (!m_provider.QuickInfoBroker.IsQuickInfoActive(m_textView))
        {
            m_session = m_provider.QuickInfoBroker.TriggerQuickInfo(m_textView, triggerPoint, true);
        }
    }
}

  5. Implementare il metodo di Detach in modo da rimuovere il gestore eventi del passaggio del mouse quando il controller viene rimosso dalla visualizzazione di testo.

    Public Sub Detach(ByVal textView As ITextView) Implements IIntellisenseController.Detach
    If m_textView Is textView Then 
        AddHandler m_textView.MouseHover, AddressOf Me.OnTextViewMouseHover
        m_textView = Nothing 
    End If 
End Sub

    public void Detach(ITextView textView)
{
    if (m_textView == textView)
    {
        m_textView.MouseHover -= this.OnTextViewMouseHover;
        m_textView = null;
    }
}

  6. Implementare il metodo di ConnectSubjectBuffer e il metodo di DisconnectSubjectBuffer come metodi vuoti per questo esempio.

    Public Sub ConnectSubjectBuffer(ByVal subjectBuffer As ITextBuffer) Implements IIntellisenseController.ConnectSubjectBuffer

End Sub 

Public Sub DisconnectSubjectBuffer(ByVal subjectBuffer As ITextBuffer) Implements IIntellisenseController.DisconnectSubjectBuffer

End Sub

    public void ConnectSubjectBuffer(ITextBuffer subjectBuffer)
{
}

public void DisconnectSubjectBuffer(ITextBuffer subjectBuffer)
{
}

Implementare il provider del controller di informazioni rapide

Il provider del controller di informazioni rapide viene utilizzato principalmente per esportare se stessa come elemento MEF e creare un'istanza del controller di informazioni rapide. Poiché è un elemento del framework MEF, può includere altri elementi del framework MEF.

Per implementare il provider del controller di informazioni rapide

  1. Dichiarare TestQuickInfoControllerProvider classe denominata che implementa IIntellisenseControllerProvidere esportarlo con NameAttribute “controller di informazioni rapide di descrizione„ e ContentTypeAttribute di “testo„:

    <Export(GetType(IIntellisenseControllerProvider))> _
<Name("ToolTip QuickInfo Controller")> _
<ContentType("text")> _
Friend Class TestQuickInfoControllerProvider
    Implements IIntellisenseControllerProvider

    [Export(typeof(IIntellisenseControllerProvider))]
[Name("ToolTip QuickInfo Controller")]
[ContentType("text")]
internal class TestQuickInfoControllerProvider : IIntellisenseControllerProvider

  2. Importare IQuickInfoBroker come proprietà.

    Private _QuickInfoBroker As IQuickInfoBroker
<Import()> _
Friend Property QuickInfoBroker() As IQuickInfoBroker
    Get 
        Return _QuickInfoBroker
    End Get 
    Set(ByVal value As IQuickInfoBroker)
        _QuickInfoBroker = value
    End Set 
End Property

    [Import]
internal IQuickInfoBroker QuickInfoBroker { get; set; }

  3. Implementare il metodo di TryCreateIntellisenseController creare un'istanza del controller di informazioni rapide.

    Public Function TryCreateIntellisenseController(ByVal textView As ITextView, ByVal subjectBuffers As IList(Of ITextBuffer)) As IIntellisenseController Implements IIntellisenseControllerProvider.TryCreateIntellisenseController
    Return New TestQuickInfoController(textView, subjectBuffers, Me)
End Function

    public IIntellisenseController TryCreateIntellisenseController(ITextView textView, IList<ITextBuffer> subjectBuffers)
{
    return new TestQuickInfoController(textView, subjectBuffers, this);
}

Compilazione e test del codice

Per testare questo codice, compilare la soluzione di QuickInfoTest ed eseguirla nell'istanza sperimentale.

Per compilare e testare la soluzione di QuickInfoTest

  1. Compilare la soluzione.

  2. Quando si esegue il progetto nel debugger, una seconda istanza di Visual Studio viene creata un'istanza.

  3. Creare un file di testo e digitare un testo che include parole “add„ e “sottrarre„.

  4. Spostare il puntatore su una delle occorrenze di “aggiunti„. La firma e la descrizione del metodo di add da visualizzare.

Vedere anche

Attività

procedura dettagliata: Collegare un tipo di contenuto a un'estensione di file