Adición de búsqueda en una ventana de herramientasAdding Search to a Tool Window

Al crear o actualizar una ventana de herramientas en la extensión, puede agregar la misma funcionalidad de búsqueda que aparece en otros lugares en Visual Studio.When you create or update a tool window in your extension, you can add the same search functionality that appears elsewhere in Visual Studio. Esta funcionalidad incluye las siguientes características:This functionality includes the following features:

  • Un cuadro de búsqueda que siempre se encuentra en un área de la barra de herramientas personalizada.A search box that's always located in a custom area of the toolbar.

  • Un indicador de progreso que se superpone en el mismo cuadro de búsqueda.A progress indicator that's overlaid on the search box itself.

  • La capacidad para mostrar los resultados en cuanto escriba cada carácter (búsqueda instantánea) o únicamente después de elegir la tecla ENTRAR (búsqueda a petición).The ability to show results as soon as you enter each character (instant search) or only after you choose the Enter key (search on demand).

  • Una lista que muestra los términos para los que ha buscado en más recientemente.A list that shows terms for which you've searched most recently.

  • La capacidad para filtrar las búsquedas por campos específicos o aspectos de los destinos de búsqueda.The ability to filter searches by specific fields or aspects of the search targets.

    Si sigue este tutorial, aprenderá a realizar las siguientes tareas:By following this walkthrough, you'll learn how to perform the following tasks:

  1. Cree un proyecto de VSPackage.Create a VSPackage project.

  2. Crear una ventana de herramientas que contiene un control de usuario con un cuadro de texto de solo lectura.Create a tool window that contains a UserControl with a read-only TextBox.

  3. Agregar un cuadro de búsqueda a la ventana de herramientas.Add a search box to the tool window.

  4. Agregue la implementación de la búsqueda.Add the search implementation.

  5. Habilitar la búsqueda instantánea y la presentación de una barra de progreso.Enable instant search and display of a progress bar.

  6. Agregar un Coincidir mayúsculas y minúsculas opción.Add a Match case option.

  7. Agregar un buscar únicamente líneas incluso filtro.Add a Search even lines only filter.

Para crear un proyecto de VSIXTo create a VSIX project

  1. Crear un proyecto VSIX denominado TestToolWindowSearch con una ventana de herramientas denominada TestSearch.Create a VSIX project named TestToolWindowSearch with a tool window named TestSearch. Si necesita ayuda para hacerlo, consulte crear una extensión con una ventana de herramientas.If you need help doing this, see Creating an Extension with a Tool Window.

Para crear una ventana de herramientasTo create a tool window

  1. En el TestToolWindowSearch del proyecto, abra el archivo TestSearchControl.xaml.In the TestToolWindowSearch project, open the TestSearchControl.xaml file.

  2. Reemplazar el existente <StackPanel> bloque con el siguiente bloque, lo cual agrega sólo lectura TextBox a la UserControl en la ventana de herramientas.Replace the existing <StackPanel> block with the following block, which adds a read-only TextBox to the UserControl in the tool window.

    <StackPanel Orientation="Vertical">  
        <TextBox Name="resultsTextBox" Height="800.0"  
            Width="800.0"  
            IsReadOnly="True">  
        </TextBox>  
    </StackPanel>  
    
  3. En el archivo TestSearchControl.xaml.cs, agregue la siguiente instrucción using:In the TestSearchControl.xaml.cs file, add the following using statement:

    using System.Text;  
    
  4. Quitar el button1_Click() método.Remove the button1_Click() method.

    En el TestSearchControl de clases, agregue el código siguiente.In the TestSearchControl class, add the following code.

    Este código agrega un complemento público TextBox propiedad denominada SearchResultsTextBox y una propiedad de cadena pública denominada SearchContent.This code adds a public TextBox property named SearchResultsTextBox and a public string property named SearchContent. En el constructor, SearchResultsTextBox se establece en el cuadro de texto y SearchContent se inicializa en un conjunto de cadenas delimitada de nueva línea.In the constructor, SearchResultsTextBox is set to the text box, and SearchContent is initialized to a newline-delimited set of strings. El contenido del cuadro de texto también se inicializa en el conjunto de cadenas.The content of the text box is also initialized to the set of strings.

    public partial class MyControl : UserControl
    {
        public TextBox SearchResultsTextBox { get; set; }
        public string SearchContent { get; set; }
    
        public MyControl()
        {
            InitializeComponent();
    
            this.SearchResultsTextBox = resultsTextBox;
            this.SearchContent = BuildContent();
    
            this.SearchResultsTextBox.Text = this.SearchContent;
        }
    
        private string BuildContent()
        {
            StringBuilder sb = new StringBuilder();
            sb.AppendLine("1 go");
            sb.AppendLine("2 good");
            sb.AppendLine("3 Go");
            sb.AppendLine("4 Good");
            sb.AppendLine("5 goodbye");
            sb.AppendLine("6 Goodbye");
    
            return sb.ToString();
        }
    }
    
    Partial Public Class MyControl
        Inherits System.Windows.Controls.UserControl
    
        Public Property SearchResultsTextBox As System.Windows.Controls.TextBox
        Public Property SearchContent As String
    
        Public Sub New()
    
            ' This call is required by the designer.
            InitializeComponent()
    
            ' Add any initialization after the InitializeComponent() call.
            Me.SearchResultsTextBox = resultsTextBox
            Me.SearchContent = buildContent
    
            Me.SearchResultsTextBox.Text = Me.SearchContent
        End Sub
    
        Private Function BuildContent() As String
            Dim sb As New System.Text.StringBuilder()
    
            sb.AppendLine("1 go")
            sb.AppendLine("2 good")
            sb.AppendLine("3 Go")
            sb.AppendLine("4 Good")
            sb.AppendLine("5 goodbye")
            sb.AppendLine("6 Goodbye")
    
            Return sb.ToString()
        End Function
    End Class
    
  5. Compile la solución y comience la depuración.Build the project and start debugging. Aparece la instancia experimental de Visual Studio.The experimental instance of Visual Studio appears.

  6. En la barra de menús, elija vista, otras ventanas, TestSearch.On the menu bar, choose View, Other Windows, TestSearch.

    Aparece la ventana de herramientas, pero no aparece todavía, el control de búsqueda.The tool window appears, but the search control doesn't yet appear.

Para agregar un cuadro de búsqueda a la ventana de herramientasTo add a search box to the tool window

  1. En el archivo TestSearch.cs, agregue el código siguiente a la TestSearch clase.In the TestSearch.cs file, add the following code to the TestSearch class. El código invalida el SearchEnabled propiedad para que el descriptor de acceso get devuelve true.The code overrides the SearchEnabled property so that the get accessor returns true.

    Para habilitar la búsqueda, es necesario reemplazar el SearchEnabled propiedad.To enable search, you must override the SearchEnabled property. El ToolWindowPane la clase implementa IVsWindowSearch y proporciona una implementación predeterminada que no habilite la búsqueda.The ToolWindowPane class implements IVsWindowSearch and provides a default implementation that doesn't enable search.

    public override bool SearchEnabled  
    {  
        get { return true; }  
    }  
    
  2. Compile la solución y comience la depuración.Build the project and start debugging. Aparece la instancia experimental.The experimental instance appears.

  3. En la instancia experimental de Visual Studio, abra TestSearch.In the experimental instance of Visual Studio, open TestSearch.

    En la parte superior de la ventana de herramientas, aparecerá un control de búsqueda con un búsqueda marca de agua y un icono de lupa.At the top of the tool window, a search control appears with a Search watermark and a magnifying-glass icon. Sin embargo, no funciona aún búsqueda porque no se ha implementado el proceso de búsqueda.However, search doesn't work yet because the search process hasn't been implemented.

Para agregar la implementación de búsquedaTo add the search implementation

Al habilitar la búsqueda en un ToolWindowPane, como en el procedimiento anterior, la ventana de herramientas crea un host de Microsoft search.When you enable search on a ToolWindowPane, as in the previous procedure, the tool window creates a search host. Este host se configura y administra los procesos de búsqueda, que siempre se producen en un subproceso en segundo plano.This host sets up and manages search processes, which always occur on a background thread. Dado que la ToolWindowPane clase administra la creación del host de búsqueda y la configuración de seguridad de la búsqueda, sólo necesita crear una tarea de búsqueda y proporcionar el método de búsqueda.Because the ToolWindowPane class manages the creation of the search host and the setting up of the search, you need only create a search task and provide the search method. El proceso de búsqueda se produce en un subproceso en segundo plano y se realizan llamadas en el control de ventana de herramientas en el subproceso de interfaz de usuario.The search process occurs on a background thread, and calls to the tool window control occur on the UI thread. Por lo tanto, debe utilizar el ThreadHelper.Invoke método para administrar todas las llamadas que se realicen en tratar con el control.Therefore, you must use the ThreadHelper.Invoke method to manage any calls that you make in dealing with the control.

  1. En el archivo TestSearch.cs, agregue las siguientes using instrucciones:In the TestSearch.cs file, add the following using statements:

    using System;  
    using System.Collections.Generic;  
    using System.Runtime.InteropServices;  
    using System.Text;  
    using System.Windows.Controls;  
    using Microsoft.Internal.VisualStudio.PlatformUI;  
    using Microsoft.VisualStudio;  
    using Microsoft.VisualStudio.PlatformUI;  
    using Microsoft.VisualStudio.Shell;  
    using Microsoft.VisualStudio.Shell.Interop;  
    
  2. En la TestSearch de clases, agregue el código siguiente, que lleva a cabo las siguientes acciones:In the TestSearch class, add the following code, which performs the following actions:

    • Invalida el CreateSearch método para crear una tarea de búsqueda.Overrides the CreateSearch method to create a search task.

    • Invalida el ClearSearch método para restaurar el estado del cuadro de texto.Overrides the ClearSearch method to restore the state of the text box. Se llama a este método cuando un usuario cancela una tarea de búsqueda y cuando un usuario establece o unsets otra opción o filtro.This method is called when a user cancels a search task and when a user sets or unsets options or filters. Ambos CreateSearch y ClearSearch se llaman en el subproceso de interfaz de usuario.Both CreateSearch and ClearSearch are called on the UI thread. Por lo tanto, no es necesario obtener acceso al cuadro de texto por medio de la ThreadHelper.Invoke método.Therefore, you don't need to access the text box by means of the ThreadHelper.Invoke method.

    • Crea una clase que se denomina TestSearchTask que herede de VsSearchTask, lo que proporciona una implementación predeterminada de IVsSearchTask.Creates a class that's named TestSearchTask that inherits from VsSearchTask, which provides a default implementation of IVsSearchTask.

      En TestSearchTask, el constructor establece un campo privado que hace referencia a la ventana de herramientas.In TestSearchTask, the constructor sets a private field that references the tool window. Para proporcionar el método de búsqueda, invalidar la OnStartSearch y OnStopSearch métodos.To provide the search method, you override the OnStartSearch and OnStopSearch methods. El OnStartSearch método es donde se implementa el proceso de búsqueda.The OnStartSearch method is where you implement the search process. Este proceso incluye realizar la búsqueda, mostrar los resultados de búsqueda en el cuadro de texto y llamar a la implementación de la clase base de este método para indicar que la búsqueda no es completa.This process includes performing the search, displaying the search results in the text box, and calling the base class implementation of this method to report that the search is complete.

    public override IVsSearchTask CreateSearch(uint dwCookie, IVsSearchQuery pSearchQuery, IVsSearchCallback pSearchCallback)  
    {  
        if (pSearchQuery == null || pSearchCallback == null)  
            return null;  
         return new TestSearchTask(dwCookie, pSearchQuery, pSearchCallback, this);  
    }  
    
    public override void ClearSearch()  
    {  
        TestSearchControl control = (TestSearchControl)this.Content;  
        control.SearchResultsTextBox.Text = control.SearchContent;  
    }  
    
    internal class TestSearchTask : VsSearchTask  
    {  
        private TestSearch m_toolWindow;  
    
        public TestSearchTask(uint dwCookie, IVsSearchQuery pSearchQuery, IVsSearchCallback pSearchCallback, TestSearch toolwindow)  
            : base(dwCookie, pSearchQuery, pSearchCallback)  
        {  
            m_toolWindow = toolwindow;  
        }  
    
        protected override void OnStartSearch()  
        {  
            // Use the original content of the text box as the target of the search.   
            var separator = new string[] { Environment.NewLine };  
            TestSearchControl control = (TestSearchControl)m_toolWindow.Content;  
            string[] contentArr = control.SearchContent.Split(separator, StringSplitOptions.None);  
    
            // Get the search option.   
            bool matchCase = false;  
            // matchCase = m_toolWindow.MatchCaseOption.Value;   
    
                // Set variables that are used in the finally block.  
                StringBuilder sb = new StringBuilder("");  
                uint resultCount = 0;  
                this.ErrorCode = VSConstants.S_OK;  
    
                try  
                {  
                    string searchString = this.SearchQuery.SearchString;  
    
                    // Determine the results.   
                    uint progress = 0;  
                    foreach (string line in contentArr)  
                    {  
                        if (matchCase == true)  
                        {  
                            if (line.Contains(searchString))  
                            {  
                                sb.AppendLine(line);  
                                resultCount++;  
                            }  
                        }  
                        else  
                            {  
                                if (line.ToLower().Contains(searchString.ToLower()))  
                                {  
                                    sb.AppendLine(line);  
                                    resultCount++;  
                                }  
                            }  
    
                            // SearchCallback.ReportProgress(this, progress++, (uint)contentArr.GetLength(0));   
    
                            // Uncomment the following line to demonstrate the progress bar.   
                            // System.Threading.Thread.Sleep(100);  
                        }  
                    }  
                    catch (Exception e)  
                    {  
                        this.ErrorCode = VSConstants.E_FAIL;  
                    }  
                    finally  
                    {  
                        ThreadHelper.Generic.Invoke(() =>  
                        { ((TextBox)((TestSearchControl)m_toolWindow.Content).SearchResultsTextBox).Text = sb.ToString(); });  
    
                        this.SearchResults = resultCount;  
                    }  
    
            // Call the implementation of this method in the base class.   
            // This sets the task status to complete and reports task completion.   
            base.OnStartSearch();  
        }  
    
        protected override void OnStopSearch()  
        {  
            this.SearchResults = 0;  
        }  
    }  
    
  3. Probar la implementación de búsqueda realizando los pasos siguientes:Test your search implementation by performing the following steps:

    1. Recompile el proyecto e iniciar la depuración.Rebuild the project and start debugging.

    2. En la instancia experimental de Visual Studio, vuelva a abrir la ventana de herramientas, escriba algún texto de búsqueda en la ventana Buscar y haga clic en ENTRAR.In the experimental instance of Visual Studio, open the tool window again, enter some search text in the search window, and click ENTER.

      Aparecerán los resultados correctos.The correct results should appear.

Para personalizar el comportamiento de búsquedaTo customize the search behavior

Al cambiar la configuración de búsqueda, puede realizar una serie de cambios en cómo aparece el control de búsqueda y cómo se realizará la búsqueda. Por ejemplo, puede cambiar la marca de agua (el texto predeterminado que aparece en el cuadro de búsqueda), el mínimo y ancho máximo del control de búsqueda y si se debe mostrar una barra de progreso.By changing the search settings, you can make a variety of changes in how the search control appears and how the search is carried out. For example, you can change the watermark (the default text that appears in the search box), the minimum and maximum width of the search control, and whether to show a progress bar. También puede cambiar el punto en los resultados de la búsqueda empiecen a aparecer (a petición o búsqueda instantánea) y si se debe mostrar una lista de términos para los que buscan recientemente.You can also change the point at which search results start to appear (on demand or instant search) and whether to show a list of terms for which you recently searched. Puede encontrar la lista completa de opciones en la SearchSettingsDataSource clase.You can find the complete list of settings in the SearchSettingsDataSource class.

  1. En el archivo TestSearch.cs, agregue el código siguiente a la TestSearch clase.In the TestSearch.cs file, add the following code to the TestSearch class. Este código permite búsqueda instantánea en lugar de la búsqueda a petición (lo que significa que el usuario no tiene que hacer clic en ENTRAR).This code enables instant search instead of on-demand search (meaning that the user doesn't have to click ENTER). El código invalida el ProvideSearchSettings método en el TestSearch (clase), que es necesario cambiar la configuración predeterminada.The code overrides the ProvideSearchSettings method in the TestSearch class, which is necessary to change the default settings.

    public override void ProvideSearchSettings(IVsUIDataSource pSearchSettings)  
    {  
        Utilities.SetValue(pSearchSettings,   
            SearchSettingsDataSource.SearchStartTypeProperty.Name,   
            (uint)VSSEARCHSTARTTYPE.SST_INSTANT);}  
    
  2. Probar la nueva configuración por volver a generar la solución y reiniciar el depurador.Test the new setting by rebuilding the solution and restarting the debugger.

    Resultados de la búsqueda aparecen cada vez que se escribe un carácter en el cuadro de búsqueda.Search results appear every time that you enter a character in the search box.

  3. En el ProvideSearchSettings método, agregue la siguiente línea, que permite la presentación de una barra de progreso.In the ProvideSearchSettings method, add the following line, which enables the display of a progress bar.

    public override void ProvideSearchSettings(IVsUIDataSource pSearchSettings)  
    {  
        Utilities.SetValue(pSearchSettings,   
            SearchSettingsDataSource.SearchStartTypeProperty.Name,   
             (uint)VSSEARCHSTARTTYPE.SST_INSTANT);  
        Utilities.SetValue(pSearchSettings,   
            SearchSettingsDataSource.SearchProgressTypeProperty.Name,   
             (uint)VSSEARCHPROGRESSTYPE.SPT_DETERMINATE);  
    }  
    

    En la barra de progreso que aparezca, deberá indicarse el progreso.For the progress bar to appear, the progress must be reported. Para informar sobre el progreso, quite el siguiente código en el OnStartSearch método de la TestSearchTask clase:To report the progress, uncomment the following code in the OnStartSearch method of the TestSearchTask class:

    SearchCallback.ReportProgress(this, progress++, (uint)contentArr.GetLength(0));  
    
  4. Para disminuir la velocidad de procesamiento suficiente que el progreso de la barra está visible, elimine la línea siguiente en el OnStartSearch método de la TestSearchTask clase:To slow processing enough that the progress bar is visible, uncomment the following line in the OnStartSearch method of the TestSearchTask class:

    System.Threading.Thread.Sleep(100);  
    
  5. Probar la nueva configuración, volver a generar la solución y comenzar a depurar.Test the new settings by rebuilding the solution and starting to debug.

    La barra de progreso aparece en la ventana de búsqueda (como una línea azul debajo del cuadro de texto de búsqueda) cada vez que lleva a cabo una búsqueda.The progress bar appears in the search window (as a blue line below the search text box) every time that you perform a search.

Permitir a los usuarios restringir las búsquedasTo enable users to refine their searches

Puede que los usuarios pueden restringir las búsquedas por medio de opciones como Coincidir mayúsculas y minúsculas o palabras completas.You can allow users to refine their searches by means of options such as Match case or Match whole word. Opciones pueden ser booleanos, que aparecen como comandos, que aparecen como botones o casillas de verificación.Options can be boolean, which appear as check boxes, or commands, which appear as buttons. En este tutorial, creará una opción de tipo boolean.For this walkthrough, you'll create a boolean option.

  1. En el archivo TestSearch.cs, agregue el código siguiente a la TestSearch clase.In the TestSearch.cs file, add the following code to the TestSearch class. El código invalida el SearchOptionsEnum método, que permite la implementación de la búsqueda detectar si una opción determinada está activada o desactivada.The code overrides the SearchOptionsEnum method, which allows the search implementation to detect whether a given option is on or off. El código en SearchOptionsEnum agrega una opción para hacer coincidir mayúsculas y minúsculas para un IVsEnumWindowSearchOptions enumerador.The code in SearchOptionsEnum adds an option to match case to an IVsEnumWindowSearchOptions enumerator. La opción Coincidir mayúsculas y minúsculas se pone a disposición como el MatchCaseOption propiedad.The option to match case is also made available as the MatchCaseOption property.

    private IVsEnumWindowSearchOptions m_optionsEnum;  
    public override IVsEnumWindowSearchOptions SearchOptionsEnum  
    {  
        get  
        {  
            if (m_optionsEnum == null)  
            {  
                List<IVsWindowSearchOption> list = new List<IVsWindowSearchOption>();  
    
                list.Add(this.MatchCaseOption);  
    
                m_optionsEnum = new WindowSearchOptionEnumerator(list) as IVsEnumWindowSearchOptions;  
            }  
            return m_optionsEnum;  
        }  
    }  
    
    private WindowSearchBooleanOption m_matchCaseOption;  
    public WindowSearchBooleanOption MatchCaseOption  
    {  
        get  
        {  
            if (m_matchCaseOption == null)  
            {  
                m_matchCaseOption = new WindowSearchBooleanOption("Match case", "Match case", false);  
            }  
            return m_matchCaseOption;  
        }  
    }  
    
  2. En el TestSearchTask de la clase, quite el comentario de la siguiente línea en el OnStartSearch método:In the TestSearchTask class, uncomment the following line in the OnStartSearch method:

    matchCase = m_toolWindow.MatchCaseOption.Value;
    
  3. Pruebe la opción:Test the option:

    1. Compile la solución y comience la depuración.Build the project and start debugging. Aparece la instancia experimental.The experimental instance appears.

    2. En la ventana de herramientas, elija la flecha de lista desplegable del lado derecho del cuadro de texto.In the tool window, choose the Down arrow on the right side of the text box.

      El Coincidir mayúsculas y minúsculas aparece la casilla de verificación.The Match case check box appears.

    3. Seleccione el Coincidir mayúsculas y minúsculas casilla de verificación y, a continuación, realice alguna de las búsquedas.Select the Match case check box, and then perform some searches.

Para agregar un filtro de búsquedaTo add a search filter

Puede agregar filtros de búsqueda que permiten a los usuarios redefinir el conjunto de destinos de búsqueda.You can add search filters that allow users to refine the set of search targets. Por ejemplo, puede filtrar archivos en el Explorador de archivos, las fechas en el que se han modificado más recientemente y sus extensiones de nombre de archivo.For example, you can filter files in File Explorer by the dates on which they were modified most recently and their file name extensions. En este tutorial, agregará un filtro incluso únicamente para las líneas.In this walkthrough, you'll add a filter for even lines only. Cuando el usuario elige ese filtro, el host de búsqueda agrega las cadenas que especifican en la consulta de búsqueda.When the user chooses that filter, the search host adds the strings that you specify to the search query. A continuación, puede identificar estas cadenas dentro del método de búsqueda y filtrar los destinos de búsqueda en consecuencia.You can then identify these strings inside your search method and filter the search targets accordingly.

  1. En el archivo TestSearch.cs, agregue el código siguiente a la TestSearch clase.In the TestSearch.cs file, add the following code to the TestSearch class. El código implementa SearchFiltersEnum agregando un WindowSearchSimpleFilter que especifica para filtrar los resultados de búsqueda para que aparezcan solo incluso las líneas.The code implements SearchFiltersEnum by adding a WindowSearchSimpleFilter that specifies to filter the search results so that only even lines appear.

    public override IVsEnumWindowSearchFilters SearchFiltersEnum  
    {  
        get  
        {  
            List<IVsWindowSearchFilter> list = new List<IVsWindowSearchFilter>();  
            list.Add(new WindowSearchSimpleFilter("Search even lines only", "Search even lines only", "lines", "even"));  
            return new WindowSearchFilterEnumerator(list) as IVsEnumWindowSearchFilters;  
        }  
    }  
    

    Ahora, el control de búsqueda muestra el filtro de búsqueda Search even lines only.Now the search control displays the search filter Search even lines only. Cuando el usuario elige el filtro, la cadena lines:"even" aparece en el cuadro de búsqueda.When the user chooses the filter, the string lines:"even" appears in the search box. Otros criterios de búsqueda pueden aparecer al mismo tiempo que el filtro.Other search criteria can appear at the same time as the filter. Cadenas de búsqueda pueden aparecer antes que el filtro, después el filtro, o ambas cosas.Search strings may appear before the filter, after the filter, or both.

  2. En el archivo TestSearch.cs, agregue los métodos siguientes para la TestSearchTask (clase), que se encuentra en la TestSearch clase.In the TestSearch.cs file, add the following methods to the TestSearchTask class, which is in the TestSearch class. Estos métodos admiten la OnStartSearch método, que modificará en el paso siguiente.These methods support the OnStartSearch method, which you'll modify in the next step.

    private string RemoveFromString(string origString, string stringToRemove)  
    {  
        int index = origString.IndexOf(stringToRemove);  
        if (index == -1)  
            return origString;  
        else   
             return (origString.Substring(0, index) + origString.Substring(index + stringToRemove.Length)).Trim();  
    }  
    
    private string[] GetEvenItems(string[] contentArr)  
    {  
        int length = contentArr.Length / 2;  
        string[] evenContentArr = new string[length];  
    
        int indexB = 0;  
        for (int index = 1; index < contentArr.Length; index += 2)  
        {  
            evenContentArr[indexB] = contentArr[index];  
            indexB++;  
        }  
    
        return evenContentArr;  
    }  
    
  3. En el TestSearchTask clase, actualice el OnStartSearch método por el código siguiente.In the TestSearchTask class, update the OnStartSearch method with the following code. Este cambio actualiza el código para admitir el filtro.This change updates the code to support the filter.

    protected override void OnStartSearch()  
    {  
        // Use the original content of the text box as the target of the search.   
        var separator = new string[] { Environment.NewLine };  
        string[] contentArr = ((TestSearchControl)m_toolWindow.Content).SearchContent.Split(separator, StringSplitOptions.None);  
    
        // Get the search option.   
        bool matchCase = false;  
        matchCase = m_toolWindow.MatchCaseOption.Value;  
    
        // Set variables that are used in the finally block.  
        StringBuilder sb = new StringBuilder("");  
        uint resultCount = 0;  
        this.ErrorCode = VSConstants.S_OK;  
    
        try  
        {  
            string searchString = this.SearchQuery.SearchString;  
    
            // If the search string contains the filter string, filter the content array.   
            string filterString = "lines:\"even\"";  
    
            if (this.SearchQuery.SearchString.Contains(filterString))  
            {  
                // Retain only the even items in the array.  
                contentArr = GetEvenItems(contentArr);  
    
                // Remove 'lines:"even"' from the search string.  
                searchString = RemoveFromString(searchString, filterString);  
            }  
    
            // Determine the results.   
            uint progress = 0;  
            foreach (string line in contentArr)  
            {  
                if (matchCase == true)  
                {  
                    if (line.Contains(searchString))  
                    {  
                        sb.AppendLine(line);  
                        resultCount++;  
                    }  
                }  
                else  
                {  
                    if (line.ToLower().Contains(searchString.ToLower()))  
                    {  
                        sb.AppendLine(line);  
                        resultCount++;  
                    }  
                }  
    
                SearchCallback.ReportProgress(this, progress++, (uint)contentArr.GetLength(0));  
    
                // Uncomment the following line to demonstrate the progress bar.   
                // System.Threading.Thread.Sleep(100);  
            }  
        }  
        catch (Exception e)  
        {  
            this.ErrorCode = VSConstants.E_FAIL;  
        }  
        finally  
        {  
            ThreadHelper.Generic.Invoke(() =>  
            { ((TextBox)((TestSearchControl)m_toolWindow.Content).SearchResultsTextBox).Text = sb.ToString(); });  
    
            this.SearchResults = resultCount;  
        }  
    
        // Call the implementation of this method in the base class.   
        // This sets the task status to complete and reports task completion.   
        base.OnStartSearch();  
    }  
    
  4. Probar el código.Test your code.

  5. Compile la solución y comience la depuración.Build the project and start debugging. En la instancia experimental de Visual Studio, abra la ventana de herramientas y, a continuación, elija la flecha de lista desplegable en el control de búsqueda.In the experimental instance of Visual Studio, open the tool window, and then choose the Down arrow on the search control.

    El Coincidir mayúsculas y minúsculas casilla de verificación y buscar únicamente líneas incluso aparecen de filtro.The Match case check box and the Search even lines only filter appear.

  6. Elija el filtro.Choose the filter.

    El cuadro de búsqueda contiene líneas: "incluso", y aparecen los siguientes resultados:The search box contains lines:"even", and the following results appear:

    buena 22 good

    4 buena4 Good

    Adiós 66 Goodbye

  7. Eliminar lines:"even" en el cuadro de búsqueda, seleccione la Coincidir mayúsculas y minúsculas casilla de verificación y, a continuación, escriba g en el cuadro de búsqueda.Delete lines:"even" from the search box, select the Match case check box, and then enter g in the search box.

    Aparecen los siguientes resultados:The following results appear:

    Ir de 11 go

    buena 22 good

    Adiós 55 goodbye

  8. Elija la X en el lado derecho del cuadro de búsqueda.Choose the X on the right side of the search box.

    La búsqueda está desactivada, y se mostrará el contenido original.The search is cleared, and the original contents appear. Sin embargo, el Coincidir mayúsculas y minúsculas todavía está activada la casilla de verificación.However, the Match case check box is still selected.