Passo a passo: exibir preenchimento de declaração

Artigo
10/15/2024

Você pode implementar a conclusão de instrução baseada em idioma definindo os identificadores para os quais deseja fornecer conclusão e, em seguida, disparando uma sessão de conclusão. Você pode definir a conclusão da instrução no contexto de um serviço de idioma, definir sua própria extensão de nome de arquivo e tipo de conteúdo e, em seguida, exibir a conclusão apenas para esse tipo. Ou, você pode disparar a conclusão para um tipo de conteúdo existente — por exemplo, "texto sem formatação". Este passo a passo mostra como disparar a conclusão de instrução para o tipo de conteúdo "texto sem formatação", que é o tipo de conteúdo dos arquivos de texto. O tipo de conteúdo "texto" é o ancestral de todos os outros tipos de conteúdo, incluindo código e arquivos XML.

Normalmente, a conclusão da instrução é acionada digitando determinados caracteres, por exemplo, digitando o início de um identificador, como "usando". Normalmente, ele é descartado pressionando a tecla Barra de espaço, Tab ou Enter para confirmar uma seleção. Você pode implementar os recursos do IntelliSense que são acionados ao digitar um caractere usando um manipulador de comandos para os pressionamentos de tecla (a interface) e um provedor de manipulador que implementa a IOleCommandTarget IVsTextViewCreationListener interface. Para criar a fonte de conclusão, que é a lista de identificadores que participam da conclusão, implemente a interface e um provedor de origem de conclusão (a ICompletionSource ICompletionSourceProvider interface). Os provedores são partes do componente MEF (Managed Extensibility Framework). Eles são responsáveis por exportar as classes de origem e controlador e importar serviços e brokers — por exemplo, o , que permite a navegação no buffer de texto e o ITextStructureNavigatorSelectorService ICompletionBroker, que aciona a sessão de conclusão.

Este passo a passo mostra como implementar a conclusão de instrução para um conjunto embutido de identificadores embutido em código. Em implementações completas, o serviço de idioma e a documentação de idioma são responsáveis por fornecer esse conteúdo.

Criar um projeto MEF

Para criar um projeto MEF

Crie um projeto C# VSIX. (No Caixa de diálogo Novo Projeto, selecione Visual C# / Extensibilidade e, em seguida, Projeto VSIX.) Nomeie a solução CompletionTest.
Adicione um modelo de item Editor Classificador ao projeto. Para obter mais informações, consulte Criar uma extensão com um modelo de item do editor.
Exclua os arquivos de classe existentes.
Adicione as seguintes referências ao projeto e certifique-se de que CopyLocal está definido como false:

Microsoft.VisualStudio.Editor

Microsoft.VisualStudio.Language.Intellisense

Microsoft.VisualStudio.OLE.Interop

Microsoft.VisualStudio.Shell.15.0

Microsoft.VisualStudio.Shell.Immutable.10.0

Microsoft.VisualStudio.TextManager.Interop

Implementar a origem de conclusão

A fonte de conclusão é responsável por coletar o conjunto de identificadores e adicionar o conteúdo à janela de conclusão quando um usuário digita um gatilho de conclusão, como as primeiras letras de um identificador. Neste exemplo, os identificadores e suas descrições são embutidos no AugmentCompletionSession método. Na maioria dos usos do mundo real, você usaria o analisador do seu idioma para obter os tokens para preencher a lista de conclusão.

Para implementar a fonte de conclusão

Adicione um arquivo de classe e nomeie-o TestCompletionSource.

Adicione estas importações:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Operations;
using Microsoft.VisualStudio.Utilities;

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

Modifique a declaração de classe para TestCompletionSource que ela implemente ICompletionSource:

internal class TestCompletionSource : ICompletionSource

Friend Class TestCompletionSource
    Implements ICompletionSource

Adicione campos privados para o provedor de origem, o buffer de texto e uma lista de objetos (que correspondem aos identificadores que participarão da sessão de Completion conclusão):

private TestCompletionSourceProvider m_sourceProvider;
private ITextBuffer m_textBuffer;
private List<Completion> m_compList;

Private m_sourceProvider As TestCompletionSourceProvider
Private m_textBuffer As ITextBuffer
Private m_compList As List(Of Completion)

Adicione um construtor que defina o provedor de origem e o buffer. A TestCompletionSourceProvider classe é definida em etapas posteriores:

public TestCompletionSource(TestCompletionSourceProvider sourceProvider, ITextBuffer textBuffer)
{
    m_sourceProvider = sourceProvider;
    m_textBuffer = textBuffer;
}

Public Sub New(ByVal sourceProvider As TestCompletionSourceProvider, ByVal textBuffer As ITextBuffer)
    m_sourceProvider = sourceProvider
    m_textBuffer = textBuffer
End Sub

Implemente o AugmentCompletionSession método adicionando um conjunto de conclusão que contém as conclusões que você deseja fornecer no contexto. Cada conjunto de conclusão contém um conjunto de conclusões e corresponde a uma guia da janela de Completion conclusão. (Em projetos do Visual Basic, as guias da janela de conclusão são nomeadas Comum e Tudo.) O FindTokenSpanAtPosition método é definido na próxima etapa.

void ICompletionSource.AugmentCompletionSession(ICompletionSession session, IList<CompletionSet> completionSets)
{
    List<string> strList = new List<string>();
    strList.Add("addition");
    strList.Add("adaptation");
    strList.Add("subtraction");
    strList.Add("summation");
    m_compList = new List<Completion>();
    foreach (string str in strList)
        m_compList.Add(new Completion(str, str, str, null, null));

    completionSets.Add(new CompletionSet(
        "Tokens",    //the non-localized title of the tab
        "Tokens",    //the display title of the tab
        FindTokenSpanAtPosition(session.GetTriggerPoint(m_textBuffer),
            session),
        m_compList,
        null));
}

Private Sub AugmentCompletionSession(ByVal session As ICompletionSession, ByVal completionSets As IList(Of CompletionSet)) Implements ICompletionSource.AugmentCompletionSession
    Dim strList As New List(Of String)()
    strList.Add("addition")
    strList.Add("adaptation")
    strList.Add("subtraction")
    strList.Add("summation")

    m_compList = New List(Of Completion)()
    For Each str As String In strList
        m_compList.Add(New Completion(str, str, str, Nothing, Nothing))
    Next str

    completionSets.Add(New CompletionSet(
        "Tokens",
        "Tokens",
        FindTokenSpanAtPosition(session.GetTriggerPoint(m_textBuffer),
            session),
        m_compList,
        Nothing))
End Sub

O método a seguir é usado para localizar a palavra atual a partir da posição do cursor:

private ITrackingSpan FindTokenSpanAtPosition(ITrackingPoint point, ICompletionSession session)
{
    SnapshotPoint currentPoint = (session.TextView.Caret.Position.BufferPosition) - 1;
    ITextStructureNavigator navigator = m_sourceProvider.NavigatorService.GetTextStructureNavigator(m_textBuffer);
    TextExtent extent = navigator.GetExtentOfWord(currentPoint);
    return currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive);
}

Private Function FindTokenSpanAtPosition(ByVal point As ITrackingPoint, ByVal session As ICompletionSession) As ITrackingSpan
    Dim currentPoint As SnapshotPoint = (session.TextView.Caret.Position.BufferPosition) - 1
    Dim navigator As ITextStructureNavigator = m_sourceProvider.NavigatorService.GetTextStructureNavigator(m_textBuffer)
    Dim extent As TextExtent = navigator.GetExtentOfWord(currentPoint)
    Return currentPoint.Snapshot.CreateTrackingSpan(extent.Span, SpanTrackingMode.EdgeInclusive)
End Function

Implemente o Dispose() método:

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

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

Implementar o provedor de origem de conclusão

O provedor de origem de conclusão é a parte do componente MEF que instancia a fonte de conclusão.

Para implementar o provedor de origem de conclusão

Adicione uma classe chamada TestCompletionSourceProvider que implementa ICompletionSourceProvidero . Exporte essa classe com um de "texto sem formatação" e um ContentTypeAttribute NameAttribute de "conclusão de teste".

[Export(typeof(ICompletionSourceProvider))]
[ContentType("plaintext")]
[Name("token completion")]
internal class TestCompletionSourceProvider : ICompletionSourceProvider

<Export(GetType(ICompletionSourceProvider)), ContentType("plaintext"), Name("token completion")>
Friend Class TestCompletionSourceProvider
    Implements ICompletionSourceProvider

Importe um ITextStructureNavigatorSelectorService, que localiza a palavra atual na fonte de conclusão.

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

<Import()>
Friend Property NavigatorService() As ITextStructureNavigatorSelectorService

Implemente o TryCreateCompletionSource método para instanciar a origem de conclusão.

public ICompletionSource TryCreateCompletionSource(ITextBuffer textBuffer)
{
    return new TestCompletionSource(this, textBuffer);
}

Public Function TryCreateCompletionSource(ByVal textBuffer As ITextBuffer) As ICompletionSource Implements ICompletionSourceProvider.TryCreateCompletionSource
    Return New TestCompletionSource(Me, textBuffer)
End Function

Implementar o provedor de manipulador de comandos de conclusão

O provedor do manipulador de comandos de conclusão é derivado de um , que escuta um evento de criação de modo de exibição de texto e converte o modo de exibição de um — que permite a adição do comando à cadeia de comandos do shell do Visual Studio — em um IVsTextViewCreationListener IVsTextView ITextView. Como essa classe é uma exportação MEF, você também pode usá-la para importar os serviços que são exigidos pelo próprio manipulador de comandos.

Para implementar o provedor de manipulador de comandos de conclusão

Adicione um arquivo chamado TestCompletionCommandHandler.

Adicione estes usando diretivas:

using System;
using System.ComponentModel.Composition;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Editor;
using Microsoft.VisualStudio.Language.Intellisense;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.TextManager.Interop;
using Microsoft.VisualStudio.Utilities;

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

Adicione uma classe chamada TestCompletionHandlerProvider que implementa IVsTextViewCreationListenero . Exporte essa classe com um de "manipulador de conclusão de token", um de "texto sem formatação" e um NameAttribute ContentTypeAttribute TextViewRoleAttribute de .Editable

[Export(typeof(IVsTextViewCreationListener))]
[Name("token completion handler")]
[ContentType("plaintext")]
[TextViewRole(PredefinedTextViewRoles.Editable)]
internal class TestCompletionHandlerProvider : IVsTextViewCreationListener

<Export(GetType(IVsTextViewCreationListener))>
<Name("token completion handler")>
<ContentType("plaintext")> <TextViewRole(PredefinedTextViewRoles.Editable)>
Friend Class TestCompletionHandlerProvider
    Implements IVsTextViewCreationListener

Importe o , que permite a conversão de um para um , um e um SVsServiceProvider IVsTextView ITextView ICompletionBrokerque permite o IVsEditorAdaptersFactoryServiceacesso aos serviços padrão do Visual Studio.

[Import]
internal IVsEditorAdaptersFactoryService AdapterService = null;
[Import]
internal ICompletionBroker CompletionBroker { get; set; }
[Import]
internal SVsServiceProvider ServiceProvider { get; set; }

<Import()>
Friend AdapterService As IVsEditorAdaptersFactoryService = Nothing
<Import()>
Friend Property CompletionBroker() As ICompletionBroker
<Import()>
Friend Property ServiceProvider() As SVsServiceProvider

Implemente o método para instanciar o VsTextViewCreated manipulador de comandos.

public void VsTextViewCreated(IVsTextView textViewAdapter)
{
    ITextView textView = AdapterService.GetWpfTextView(textViewAdapter);
    if (textView == null)
        return;

    Func<TestCompletionCommandHandler> createCommandHandler = delegate() { return new TestCompletionCommandHandler(textViewAdapter, textView, this); };
    textView.Properties.GetOrCreateSingletonProperty(createCommandHandler);
}

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

    Dim createCommandHandler As Func(Of TestCompletionCommandHandler) = Function() New TestCompletionCommandHandler(textViewAdapter, textView, Me)
    textView.Properties.GetOrCreateSingletonProperty(createCommandHandler)
End Sub

Implementar o manipulador de comandos de conclusão

Como a conclusão da instrução é acionada por pressionamentos de tecla, você deve implementar a interface para receber e processar os pressionamentos de tecla que disparam, confirmam e descartam a IOleCommandTarget sessão de conclusão.

Para implementar o manipulador de comandos de conclusão

Adicione uma classe chamada TestCompletionCommandHandler que implementa IOleCommandTarget:

internal class TestCompletionCommandHandler : IOleCommandTarget

Friend Class TestCompletionCommandHandler
    Implements IOleCommandTarget

Adicione campos particulares para o próximo manipulador de comandos (para o qual você passa o comando), o modo de exibição de texto, o provedor do manipulador de comandos (que permite o acesso a vários serviços) e uma sessão de conclusão:

private IOleCommandTarget m_nextCommandHandler;
private ITextView m_textView;
private TestCompletionHandlerProvider m_provider;
private ICompletionSession m_session;

Private m_nextCommandHandler As IOleCommandTarget
Private m_textView As ITextView
Private m_provider As TestCompletionHandlerProvider
Private m_session As ICompletionSession

Adicione um construtor que defina o modo de exibição de texto e os campos do provedor e adicione o comando à cadeia de comandos:

internal TestCompletionCommandHandler(IVsTextView textViewAdapter, ITextView textView, TestCompletionHandlerProvider provider)
{
    this.m_textView = textView;
    this.m_provider = provider;

    //add the command to the command chain
    textViewAdapter.AddCommandFilter(this, out m_nextCommandHandler);
}

Friend Sub New(ByVal textViewAdapter As IVsTextView, ByVal textView As ITextView, ByVal provider As TestCompletionHandlerProvider)
    Me.m_textView = textView
    Me.m_provider = provider

    'add the command to the command chain
    textViewAdapter.AddCommandFilter(Me, m_nextCommandHandler)
End Sub

Implemente o método passando o QueryStatus comando junto:

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

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

Implementar o método de Exec . Quando esse método recebe um pressionamento de tecla, ele deve fazer uma destas coisas:

Permita que o caractere seja gravado no buffer e, em seguida, dispare ou filtre a conclusão. (A impressão de caracteres faz isso.)
Confirme a conclusão, mas não permita que o caractere seja gravado no buffer. (Espaço em branco, Tab e Enter fazem isso quando uma sessão de conclusão é exibida.)

Permita que o comando seja passado para o próximo manipulador. (Todos os outros comandos.)

Como esse método pode exibir a interface do usuário, chame IsInAutomationFunction para certificar-se de que ele não é chamado em um contexto de automação:

public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
    if (VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
    {
        return m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
    }
    //make a copy of this so we can look at it after forwarding some commands
    uint commandID = nCmdID;
    char typedChar = char.MinValue;
    //make sure the input is a char before getting it
    if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
    {
        typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
    }

    //check for a commit character
    if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RETURN
        || nCmdID == (uint)VSConstants.VSStd2KCmdID.TAB
        || (char.IsWhiteSpace(typedChar) || char.IsPunctuation(typedChar)))
    {
        //check for a selection
        if (m_session != null && !m_session.IsDismissed)
        {
            //if the selection is fully selected, commit the current session
            if (m_session.SelectedCompletionSet.SelectionStatus.IsSelected)
            {
                m_session.Commit();
                //also, don't add the character to the buffer
                return VSConstants.S_OK;
            }
            else
            {
                //if there is no selection, dismiss the session
                m_session.Dismiss();
            }
        }
    }

    //pass along the command so the char is added to the buffer
    int retVal = m_nextCommandHandler.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
    bool handled = false;
    if (!typedChar.Equals(char.MinValue) && char.IsLetterOrDigit(typedChar))
    {
        if (m_session == null || m_session.IsDismissed) // If there is no active session, bring up completion
        {
            this.TriggerCompletion();
            m_session.Filter();
        }
        else    //the completion session is already active, so just filter
        {
            m_session.Filter();
        }
        handled = true;
    }
    else if (commandID == (uint)VSConstants.VSStd2KCmdID.BACKSPACE   //redo the filter if there is a deletion
        || commandID == (uint)VSConstants.VSStd2KCmdID.DELETE)
    {
        if (m_session != null && !m_session.IsDismissed)
            m_session.Filter();
        handled = true;
    }
    if (handled) return VSConstants.S_OK;
    return retVal;
}

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
    If VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider) Then
        Return m_nextCommandHandler.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)
    End If
    'make a copy of this so we can look at it after forwarding some commands
    Dim commandID As UInteger = nCmdID
    Dim typedChar As Char = Char.MinValue
    'make sure the input is a char before getting it
    If pguidCmdGroup = VSConstants.VSStd2K AndAlso nCmdID = CUInt(VSConstants.VSStd2KCmdID.TYPECHAR) Then
        typedChar = CChar(ChrW(CUShort(Marshal.GetObjectForNativeVariant(pvaIn))))
    End If

    'check for a commit character
    If nCmdID = CUInt(VSConstants.VSStd2KCmdID.RETURN) OrElse nCmdID = CUInt(VSConstants.VSStd2KCmdID.TAB) OrElse (Char.IsWhiteSpace(typedChar) OrElse Char.IsPunctuation(typedChar)) Then
        'check for a selection
        If m_session IsNot Nothing AndAlso (Not m_session.IsDismissed) Then
            'if the selection is fully selected, commit the current session
            If m_session.SelectedCompletionSet.SelectionStatus.IsSelected Then
                m_session.Commit()
                'also, don't add the character to the buffer
                Return VSConstants.S_OK
            Else
                'if there is no selection, dismiss the session
                m_session.Dismiss()
            End If
        End If
    End If

    'pass along the command so the char is added to the buffer
    Dim retVal As Integer = m_nextCommandHandler.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)
    Dim handled As Boolean = False
    If (Not typedChar.Equals(Char.MinValue)) AndAlso Char.IsLetterOrDigit(typedChar) Then
        If m_session Is Nothing OrElse m_session.IsDismissed Then ' If there is no active session, bring up completion
            Me.TriggerCompletion()
            m_session.Filter()
        Else 'the completion session is already active, so just filter
            m_session.Filter()
        End If
        handled = True
    ElseIf commandID = CUInt(VSConstants.VSStd2KCmdID.BACKSPACE) OrElse commandID = CUInt(VSConstants.VSStd2KCmdID.DELETE) Then 'redo the filter if there is a deletion
        If m_session IsNot Nothing AndAlso (Not m_session.IsDismissed) Then
            m_session.Filter()
        End If
        handled = True
    End If
    If handled Then
        Return VSConstants.S_OK
    End If
    Return retVal
End Function

Esse código é um método privado que dispara a sessão de conclusão:

private bool TriggerCompletion()
{
    //the caret must be in a non-projection location 
    SnapshotPoint? caretPoint =
    m_textView.Caret.Position.Point.GetPoint(
    textBuffer => (!textBuffer.ContentType.IsOfType("projection")), PositionAffinity.Predecessor);
    if (!caretPoint.HasValue)
    {
        return false;
    }

    m_session = m_provider.CompletionBroker.CreateCompletionSession
 (m_textView,
        caretPoint.Value.Snapshot.CreateTrackingPoint(caretPoint.Value.Position, PointTrackingMode.Positive),
        true);

    //subscribe to the Dismissed event on the session 
    m_session.Dismissed += this.OnSessionDismissed;
    m_session.Start();

    return true;
}

Private Function TriggerCompletion() As Boolean
    'the caret must be in a non-projection location 
    Dim caretPoint As SnapshotPoint? = m_textView.Caret.Position.Point.GetPoint(Function(textBuffer) ((Not textBuffer.ContentType.IsOfType("projection"))), PositionAffinity.Predecessor)
    If Not caretPoint.HasValue Then
        Return False
    End If

    m_session = m_provider.CompletionBroker.CreateCompletionSession(m_textView, caretPoint.Value.Snapshot.CreateTrackingPoint(caretPoint.Value.Position, PointTrackingMode.Positive), True)

    'subscribe to the Dismissed event on the session 
    AddHandler m_session.Dismissed, AddressOf OnSessionDismissed
    m_session.Start()

    Return True
End Function

O próximo exemplo é um método privado que cancela a inscrição do Dismissed evento:

private void OnSessionDismissed(object sender, EventArgs e)
{
    m_session.Dismissed -= this.OnSessionDismissed;
    m_session = null;
}

Private Sub OnSessionDismissed(ByVal sender As Object, ByVal e As EventArgs)
    RemoveHandler m_session.Dismissed, AddressOf OnSessionDismissed
    m_session = Nothing
End Sub

Compilar e testar o código

Para testar esse código, compile a solução CompletionTest e execute-a na instância experimental.

Para criar e testar a solução CompletionTest

Compile a solução.
Quando você executa esse projeto no depurador, uma segunda instância do Visual Studio é iniciada.
Crie um arquivo de texto e digite algum texto que inclua a palavra "adicionar".
Ao digitar primeiro "a" e depois "d", uma lista que contém "adição" e "adaptação" deve aparecer. Observe que a adição está selecionada. Quando você digita outro "d", a lista deve conter apenas "adição", que agora está selecionada. Você pode confirmar "adição" pressionando a tecla Barra de espaço, Tab ou Enter, ou descartar a lista digitando Esc ou qualquer outra tecla.

Demonstra Passo a passo: Vincular um tipo de conteúdo a uma extensão de nome de arquivo

Compartilhar via

Passo a passo: exibir preenchimento de declaração

Criar um projeto MEF

Para criar um projeto MEF

Implementar a origem de conclusão

Para implementar a fonte de conclusão

Implementar o provedor de origem de conclusão

Para implementar o provedor de origem de conclusão

Implementar o provedor de manipulador de comandos de conclusão

Para implementar o provedor de manipulador de comandos de conclusão

Implementar o manipulador de comandos de conclusão

Para implementar o manipulador de comandos de conclusão

Compilar e testar o código

Para criar e testar a solução CompletionTest

Recursos adicionais

Compartilhar via

Passo a passo: exibir preenchimento de declaração

Criar um projeto MEF

Para criar um projeto MEF

Implementar a origem de conclusão

Para implementar a fonte de conclusão

Implementar o provedor de origem de conclusão

Para implementar o provedor de origem de conclusão

Implementar o provedor de manipulador de comandos de conclusão

Para implementar o provedor de manipulador de comandos de conclusão

Implementar o manipulador de comandos de conclusão

Para implementar o manipulador de comandos de conclusão

Compilar e testar o código

Para criar e testar a solução CompletionTest

Conteúdo relacionado

Recursos adicionais