Condividi tramite


procedura dettagliata: Ottiene un elenco di frammenti di codice installati (managed package Framework)

Un frammento di codice è un frammento di codice che può essere inserito nel buffer di origine con un comando di menu (che consente scegliere in un elenco di frammenti di codice installati) o selezionando un collegamento del frammento da un elenco di completamento IntelliSense.

Il metodo di EnumerateExpansions ottiene tutti i frammenti di codice per una lingua specifica GUID. I collegamenti per i frammenti possono essere inseriti in un elenco di completamento IntelliSense.

Vedere Supporto dei frammenti di codice (managed package Framework) per informazioni dettagliate sulla distribuzione dei frammenti di codice in un servizio di linguaggio gestito del framework (MPF) del pacchetto.

Per recuperare un elenco di frammenti di codice

  • Nel codice seguente viene illustrato come ottenere un elenco di frammenti di codice per un linguaggio specificato. I risultati vengono memorizzati in una matrice di strutture di VsExpansion . Questo metodo utilizza il metodo statico di GetGlobalService per ottenere l'interfaccia di IVsTextManager dal servizio di SVsTextManager . Tuttavia, è anche possibile utilizzare il provider di servizi forniti al package VS e chiamare il metodo di QueryService .

    using System;
    using System.Collections;
    using System.Runtime.InteropServices;
    using Microsoft.VisualStudio.Package;
    using Microsoft.VisualStudio.Shell;
    using Microsoft.VisualStudio.TextManager.Interop;
    
    [Guid("00000000-0000-0000-0000-000000000000")] //create a new GUID for the language service
    namespace TestLanguage
    {
        class TestLanguageService : LanguageService
        {
            private void GetSnippets(Guid languageGuid,
                                     ref ArrayList expansionsList)
            {
                IVsTextManager textManager = (IVsTextManager)Package.GetGlobalService(typeof(SVsTextManager));
                if (textManager != null)
                {
                    IVsTextManager2 textManager2 = (IVsTextManager2)textManager;
                    if (textManager2 != null)
                    {
                        IVsExpansionManager expansionManager = null;
                        textManager2.GetExpansionManager(out expansionManager);
                        if (expansionManager != null)
                        {
                            // Tell the environment to fetch all of our snippets.
                            IVsExpansionEnumeration expansionEnumerator = null;
                            expansionManager.EnumerateExpansions(languageGuid,
                            0,     // return all info
                            null,    // return all types
                            0,     // return all types
                            1,     // include snippets without types
                            0,     // do not include duplicates
                            out expansionEnumerator);
                            if (expansionEnumerator != null)
                            {
                                // Cache our expansions in a VsExpansion array 
                                uint count   = 0;
                                uint fetched = 0;
                                VsExpansion expansionInfo = new VsExpansion();
                                IntPtr[] pExpansionInfo   = new IntPtr[1];
    
                                // Allocate enough memory for one VSExpansion structure. This memory is filled in by the Next method.
                                pExpansionInfo[0] = Marshal.AllocCoTaskMem(Marshal.SizeOf(expansionInfo));
    
                                expansionEnumerator.GetCount(out count);
                                for (uint i = 0; i < count; i++)
                                {
                                    expansionEnumerator.Next(1, pExpansionInfo, out fetched);
                                    if (fetched > 0)
                                    {
                                        // Convert the returned blob of data into a structure that can be read in managed code.
                                        expansionInfo = (VsExpansion)Marshal.PtrToStructure(pExpansionInfo[0], typeof(VsExpansion));
    
                                        if (!String.IsNullOrEmpty(expansionInfo.shortcut))
                                        {
                                            expansionsList.Add(expansionInfo);
                                        }
                                    }
                                }
                                Marshal.FreeCoTaskMem(pExpansionInfo[0]);
                            }
                        }
                    }
                }
            }
        }
    }
    

Per chiamare il metodo di GetSnippets

  • Nell'metodo seguente viene illustrato come chiamare il metodo di GetSnippets al completamento di un'operazione di analisi. Il metodo di OnParseComplete viene chiamato dopo un'operazione di analisi che è stata avviata con il motivo Check.

Nota

I listis di matrice di expansionsList memorizzato nella cache per motivi di prestazioni.Le modifiche ai frammenti non vengono visualizzate nell'elenco fino alla chiusura e ricaricatoe il servizio di linguaggio, ad esempio l'arresto e il riavvio Visual Studio).

class TestLanguageService : LanguageService
{
    private ArrayList expansionsList;

    public override void OnParseComplete(ParseRequest req)
    {
        if (this.expansionsList == null)
        {
            this.expansionsList = new ArrayList();
            GetSnippets(this.GetLanguageServiceGuid(),
                ref this.expansionsList);
        }
    }
}

To use the snippet information

  • Nel codice seguente viene illustrato come utilizzare le informazioni del frammento restituite dal metodo di GetSnippets . Il metodo di AddSnippets viene chiamato dal parser in risposta a qualsiasi motivo di traccia per cui viene utilizzato per popolare un elenco di frammenti di codice. Ciò è necessario eseguire dopo che il di analisi completo è stato eseguito per la prima volta.

    Il metodo di AddDeclaration compila un elenco delle dichiarazioni che successivamente viene visualizzato in un elenco di completamento.

    La classe di TestDeclaration contiene tutte le informazioni che possono essere visualizzate in un elenco di completamento nonché nel tipo di dichiarazione.

    class TestAuthoringScope : AuthoringScope
    {
        public void AddDeclarations(TestDeclaration declaration)
        {
            if (m_declarations == null)
                m_declarations = new List<TestDeclaration>();
            m_declarations.Add(declaration);
         }
    }
    class TestDeclaration 
    {
        private string m_name;
        private string m_description;
        private string m_type;
    
        public TestDeclaration(string name, string desc, string type)
        {
            m_name = name;
            m_description = desc;
            m_type = type;
        }
    
    class TestLanguageService : LanguageService
    {
        internal void AddSnippets(ref TestAuthoringScope scope)
        {
            if (this.expansionsList != null && this.expansionsList.Count > 0)
            {
                int count = this.expansionsList.Count;
                for (int i = 0; i < count; i++)
                {
                    VsExpansion expansionInfo = (VsExpansion)this.expansionsList[i];
                    scope.AddDeclaration(new TestDeclaration(expansionInfo.title,
                         expansionInfo.description,
                         "snippet"));
                }
            }
        }
    }
    

Vedere anche

Concetti

Supporto dei frammenti di codice (managed package Framework)