c# - google - eliminar sugerencias de la barra de direcciones chrome

Cuadro de texto de sugerencias de Google(autocompletar)

Question

¿Cuál sería la mejor manera de desarrollar un cuadro de texto que recuerde el último x número de entradas que se pusieron en él? Esta es una aplicación independiente escrita con C #.

Answer 1

Esto es realmente bastante fácil, especialmente en términos de mostrar la parte de "Autocompletar". En términos de recordar las últimas x número de entradas, tendrá que decidir sobre un evento en particular (o eventos) que considere como una entrada que se está completando y escribir esa entrada en una lista ... una AutoCompleteStringCollection para ser preciso.

La clase TextBox tiene las siguientes 3 propiedades que necesitará:

• AutoCompleteCustomSource
• AutoCompleteMode
• AutoCompleteSource

Establezca AutoCompleteMode en SuggestAppend y AutoCompleteSource en CustomSource.

Luego, en tiempo de ejecución, cada vez que se realiza una nueva entrada, use el método Add () de AutoCompleteStringCollection para agregar esa entrada a la lista (y desactívela si lo desea). En realidad, puede realizar esta operación directamente en la propiedad AutoCompleteCustomSource del TextBox, siempre que ya la haya inicializado.

Ahora, cada vez que escribas en el TextBox te sugerirá entradas anteriores :)

Vea este artículo para un ejemplo más completo: http://www.c-sharpcorner.com/UploadFile/mahesh/AutoCompletion02012006113508AM/AutoCompletion.aspx

Autocompletar también tiene algunas características integradas como FileSystem y URL (aunque solo hace cosas que se escribieron en IE ...)

Answer 2

Guardo la lista de finalización en el registro.

El código que uso está abajo. Es reutilizable, en tres pasos:

1. reemplace el espacio de nombres y el nombre de clase en este código con lo que sea que use.
2. Llame a FillFormFromRegistry () en el evento Load del formulario y llame a SaveFormToRegistry en el evento de cierre .
3. Compila esto en tu proyecto.

Necesita decorar el conjunto con dos atributos: [assembly: AssemblyProduct("...")] y [assembly: AssemblyCompany("...")] . (Estos atributos normalmente se configuran automáticamente en proyectos creados en Visual Studio, por lo que no lo considero un paso).

Administrar el estado de esta manera es totalmente automático y transparente para el usuario.

Puede usar el mismo patrón para almacenar cualquier tipo de estado para su aplicación WPF o WinForms. Me gusta el estado de los cuadros de texto, casillas de verificación, desplegables. También puede almacenar / restaurar el tamaño de la ventana , realmente útil, la próxima vez que el usuario ejecute la aplicación, se abrirá en el mismo lugar y con el mismo tamaño que cuando la cerraron. Puede almacenar la cantidad de veces que se ejecutó una aplicación . Muchas posibilidades

namespace Ionic.ExampleCode
{
    public partial class NameOfYourForm
    {
        private void SaveFormToRegistry()
        {
            if (AppCuKey != null)
            {
                // the completion list
                var converted = _completions.ToList().ConvertAll(x => x.XmlEscapeIexcl());
                string completionString = String.Join("¡", converted.ToArray());
                AppCuKey.SetValue(_rvn_Completions, completionString);
            }
        }

        private void FillFormFromRegistry()
        {
            if (!stateLoaded)
            {
                if (AppCuKey != null)
                {
                    // get the MRU list of .... whatever
                    _completions = new System.Windows.Forms.AutoCompleteStringCollection();
                    string c = (string)AppCuKey.GetValue(_rvn_Completions, "");
                    if (!String.IsNullOrEmpty(c))
                    {
                        string[] items = c.Split(''¡'');
                        if (items != null && items.Length > 0)
                        {
                            //_completions.AddRange(items);
                            foreach (string item in items)
                                _completions.Add(item.XmlUnescapeIexcl());
                        }
                    }

                    // Can also store/retrieve items in the registry for
                    //   - textbox contents
                    //   - checkbox state
                    //   - splitter state
                    //   - and so on
                    //
                    stateLoaded = true;
                }
            }
        }

        private Microsoft.Win32.RegistryKey AppCuKey
        {
            get
            {
                if (_appCuKey == null)
                {
                    _appCuKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(AppRegistryPath, true);
                    if (_appCuKey == null)
                        _appCuKey = Microsoft.Win32.Registry.CurrentUser.CreateSubKey(AppRegistryPath);
                }
                return _appCuKey;
            }
            set { _appCuKey = null; }
        }

        private string _appRegistryPath;
        private string AppRegistryPath
        {
            get
            {
                if (_appRegistryPath == null)
                {
                    // Use a registry path that depends on the assembly attributes,
                    // that are presumed to be elsewhere. Example:
                    // 
                    //   [assembly: AssemblyCompany("Dino Chiesa")]
                    //   [assembly: AssemblyProduct("XPathVisualizer")]

                    var a = System.Reflection.Assembly.GetExecutingAssembly();
                    object[] attr = a.GetCustomAttributes(typeof(System.Reflection.AssemblyProductAttribute), true);
                    var p = attr[0] as System.Reflection.AssemblyProductAttribute;
                    attr = a.GetCustomAttributes(typeof(System.Reflection.AssemblyCompanyAttribute), true);
                    var c = attr[0] as System.Reflection.AssemblyCompanyAttribute;

                    _appRegistryPath = String.Format("Software//{0}//{1}",
                                                     p.Product, c.Company);
                }
                return _appRegistryPath;
            }
        }

        private Microsoft.Win32.RegistryKey _appCuKey;
        private string _rvn_Completions = "Completions";
        private readonly int _MaxMruListSize = 14;
        private System.Windows.Forms.AutoCompleteStringCollection _completions;
        private bool stateLoaded;
    }

    public static class Extensions
    {
        public static string XmlEscapeIexcl(this String s)
        {
            while (s.Contains("¡"))
            {
                s = s.Replace("¡", "¡");
            }
            return s;
        }
        public static string XmlUnescapeIexcl(this String s)
        {
            while (s.Contains("¡"))
            {
                s = s.Replace("¡", "¡");
            }
            return s;
        }

        public static List<String> ToList(this System.Windows.Forms.AutoCompleteStringCollection coll)
        {
            var list = new List<String>();
            foreach (string  item in coll)
            {
                list.Add(item);
            }
            return list;
        }
    }
}

Algunas personas evitan usar el Registro para almacenar el estado , pero me parece que es muy fácil y conveniente. Si lo desea, puede crear fácilmente un instalador que elimine todas las claves de registro durante la desinstalación.

Answer 3

@Ethan

Me olvidé del hecho de que querrías guardar eso, así que no fue solo por sesión: P Pero sí, estás completamente en lo correcto.

Esto es fácil de hacer, especialmente debido a que solo se trata de cadenas básicas, simplemente escriba los contenidos de AutoCompleteCustomSource desde el TextBox en un archivo de texto, en líneas separadas.

Tenía unos minutos, así que escribí un ejemplo de código completo ... Lo habría hecho antes, ya que siempre trato de mostrar el código, pero no tenía tiempo. De todos modos, aquí está todo (menos el código de diseñador).

namespace AutoComplete
{
    public partial class Main : Form
    {
        //so you don''t have to address "txtMain.AutoCompleteCustomSource" every time
        AutoCompleteStringCollection acsc;
        public Main()
        {
            InitializeComponent();

            //Set to use a Custom source
            txtMain.AutoCompleteSource = AutoCompleteSource.CustomSource;
            //Set to show drop down *and* append current suggestion to end
            txtMain.AutoCompleteMode = AutoCompleteMode.SuggestAppend;
            //Init string collection.
            acsc = new AutoCompleteStringCollection();
            //Set txtMain''s AutoComplete Source to acsc
            txtMain.AutoCompleteCustomSource = acsc;
        }

        private void txtMain_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                //Only keep 10 AutoComplete strings
                if (acsc.Count < 10)
                {
                    //Add to collection
                    acsc.Add(txtMain.Text);
                }
                else
                {
                    //remove oldest
                    acsc.RemoveAt(0); 
                    //Add to collection
                    acsc.Add(txtMain.Text);
                }
            }
        }

        private void Main_FormClosed(object sender, FormClosedEventArgs e)
        {
            //open stream to AutoComplete save file
            StreamWriter sw = new StreamWriter("AutoComplete.acs");

            //Write AutoCompleteStringCollection to stream
            foreach (string s in acsc)
                sw.WriteLine(s);

            //Flush to file
            sw.Flush();

            //Clean up
            sw.Close();
            sw.Dispose();
        }

        private void Main_Load(object sender, EventArgs e)
        {
            //open stream to AutoComplete save file
            StreamReader sr = new StreamReader("AutoComplete.acs");

            //initial read
            string line = sr.ReadLine();
            //loop until end
            while (line != null)
            {
                //add to AutoCompleteStringCollection
                acsc.Add(line);
                //read again
                line = sr.ReadLine();
            }

            //Clean up
            sr.Close();
            sr.Dispose();
        }
    }
}

Este código funcionará exactamente como está, solo necesita crear la GUI con un TextBox llamado txtMain y conectar los eventos KeyDown, Closed y Load al TextBox y al formulario principal.

También tenga en cuenta que, para este ejemplo y para hacerlo simple, simplemente elegí detectar la tecla Enter presionada como mi activador para guardar la cadena en la colección. Probablemente haya más / diferentes eventos que serían mejores, según sus necesidades.

Además, el modelo utilizado para poblar la colección no es muy "inteligente". Simplemente borra la cadena más antigua cuando la colección llega al límite de 10. Esto probablemente no sea ideal, pero funciona para el ejemplo. Probablemente quieras algún tipo de sistema de clasificación (especialmente si realmente quieres que sea Google-ish)

Una nota final, las sugerencias aparecerán en el orden en que están en la colección. Si por alguna razón quieres que aparezcan de manera diferente, simplemente ordena la lista como prefieras.

¡Espero que ayude!