Compatibilidad con la ventana automático en un servicio de lenguaje heredadoSupport for the Autos Window in a Legacy Language Service

El automático ventana muestra expresiones como variables y parámetros que están en ámbito cuando se detenga el programa que se está depurando (ya sea debido a un punto de interrupción o una excepción).The Autos window displays expressions such as variables and parameters that are in scope when the program being debugged is paused (either due to a breakpoint or an exception). Las expresiones pueden incluir variables, locales o globales y los parámetros que se han cambiado en el ámbito local.The expressions can include variables, local or global, and parameters that have been changed in the local scope. El automático ventana también puede incluir creaciones de instancias de una clase, estructura o algún otro tipo.The Autos window can also include instantiations of a class, structure, or some other type. Todo lo que un evaluador de expresiones puede evaluar potencialmente se puede mostrar en el automático ventana.Anything that an expression evaluator can evaluate can potentially be shown in the Autos window.

Managed package framework (MPF) no proporciona compatibilidad directa para la automático ventana.The managed package framework (MPF) does not provide direct support for the Autos window. Sin embargo, si invalida el GetProximityExpressions método, puede devolver una lista de expresiones se presente en el automático ventana.However, if you override the GetProximityExpressions method, you can return a list of expressions to be presented in the Autos window.

Implementar la compatibilidad de la ventana automáticoImplementing Support for the Autos Window

Todo lo que necesita hacer para admitir la automático ventana consiste en implementar la GetProximityExpressions método en la LanguageService clase.All you need to do to support the Autos window is to implement the GetProximityExpressions method in the LanguageService class. Debe decidir su implementación, dada una ubicación en el archivo de origen, las expresiones deben aparecer en el automático ventana.Your implementation must decide, given a location in the source file, which expressions should appear in the Autos window. El método devuelve una lista de cadenas donde cada cadena representa una única expresión.The method returns a list of strings in which each string represents a single expression. Un valor devuelto de S_OK indica que la lista contiene expresiones, mientras S_FALSE indica que no hay ninguna expresión para mostrar.A return value of S_OK indicates that the list contains expressions, while S_FALSE indicates that there are no expressions to show.

Las expresiones reales devueltas son los nombres de las variables o parámetros que aparecen en esa ubicación en el código.The actual expressions returned are the names of the variables or parameters that appear at that location in the code. Estos nombres se pasan al evaluador de expresiones para obtener los valores y tipos que se muestran a continuación, en la automático ventana.These names are passed to the expression evaluator to obtain values and types that are then displayed in the Autos window.

EjemploExample

En el ejemplo siguiente se muestra una implementación de la GetProximityExpressions método que obtiene una lista de expresiones de la ParseSource método utilizando el motivo de análisis ParseReason.The following example shows an implementation of the GetProximityExpressions method that gets a list of expressions from the ParseSource method using the parse reason ParseReason. Cada una de las expresiones se ajusta como un TestVsEnumBSTR que implementa el IVsEnumBSTR interfaz.Each of the expressions is wrapped as a TestVsEnumBSTR that implements the IVsEnumBSTR interface.

Tenga en cuenta que la GetAutoExpressionsCount y GetAutoExpression métodos son métodos personalizados en el TestAuthoringSink de objetos y se agregaron para admitir este ejemplo.Note that the GetAutoExpressionsCount and GetAutoExpression methods are custom methods on the TestAuthoringSink object and were added to support this example. Representan una manera en las expresiones agregadas a la TestAuthoringSink objeto por el analizador (mediante una llamada a la AutoExpression método) puede tener acceso fuera del analizador.They represent one way in which expressions added to the TestAuthoringSink object by the parser (by calling the AutoExpression method) can be accessed outside the parser.

using Microsoft.VisualStudio;  
using Microsoft.VisualStudio.Package;  
using Microsoft.VisualStudio.TextManager.Interop;  
  
namespace TestLanguagePackage  
{  
    public class TestLanguageService : LanguageService  
    {  
        public override int GetProximityExpressions(IVsTextBuffer buffer,  
                                                    int line,  
                                                    int col,  
                                                    int cLines,  
                                                    out IVsEnumBSTR ppEnum)  
        {  
            int retval = VSConstants.E_NOTIMPL;  
            ppEnum = null;  
            if (buffer != null)  
            {  
                IVsTextLines textLines = buffer as IVsTextLines;  
                if (textLines != null)  
                {  
                    Source src = this.GetSource(textLines);  
                    if (src != null)  
                    {  
                        TokenInfo tokenInfo = new TokenInfo();  
                        string text = src.GetText();  
                        ParseRequest req = CreateParseRequest(src,  
                                                              line,  
                                                              col,  
                                                              tokenInfo,  
                                                              text,  
                                                              src.GetFilePath(),  
                                                              ParseReason.Autos,  
                                                              null);  
                        req.Scope = this.ParseSource(req);  
                        TestAuthoringSink sink = req.Sink as TestAuthoringSink;  
  
                        retval = VSConstants.S_FALSE;  
                        int spanCount = sink.GetAutoExpressionsCount();  
                        if (spanCount > 0) {  
                            TestVsEnumBSTR bstrList = new TestVsEnumBSTR();  
                            for (int i = 0; i < spanCount; i++)  
                            {  
                                TextSpan span;  
                                sink.GetAutoExpression(i, out span);  
                                string expression = src.GetText(span.iStartLine,  
                                                                span.iStartIndex,  
                                                                span.iEndLine,  
                                                                span.iEndIndex);  
                                bstrList.AddString(expression);  
                            }  
                            ppEnum = bstrList;  
                            retval = VSConstants.S_OK;  
                        }  
                    }  
                }  
            }  
            return retval;  
        }  
    }  
}