vaciar - limpiar varios textbox c# asp net

¿Cuál es la mejor manera de borrar todos los controles en un formulario C#?

Question

Recuerdo haber visto a alguien preguntar algo sobre estas líneas hace un tiempo, pero hice una búsqueda y no pude encontrar nada.

Estoy tratando de encontrar la forma más limpia de borrar todos los controles de un formulario a sus valores predeterminados (por ejemplo, borrar cuadros de texto, desmarcar casillas de verificación).

¿Cómo haría usted para esto?

Answer 1

A continuación se muestran los métodos que uso para borrar texto de un tipo de control que implementa ITextBox.

Noté que en el ejemplo se establecen los valores booleanos predeterminados. Estoy seguro de que puede modificarlo para establecer valores predeterminados de componentes booleanos.

Pase el método Clear a un tipo de control (TextBox, Label ... etc) y una colección de control, y borrará todo el texto de los controles que implementen ITextBox.

Algo como esto:

//Clears the textboxes
WebControlUtilities.ClearControls<TextBox>(myPanel.Controls);

El método Clear está destinado a una página o página maestra. El tipo de colección de control puede variar. es decir. Formulario, ContentPlaceHolder ... etc.

        /// <summary>
    /// Clears Text from Controls...ie TextBox, Label, anything that implements ITextBox
    /// </summary>
    /// <typeparam name="T">Collection Type, ie. ContentPlaceHolder..</typeparam>
    /// <typeparam name="C">ie TextBox, Label, anything that implements ITextBox</typeparam>
    /// <param name="controls"></param>
    public static void Clear<T, C>(ControlCollection controls)
        where C : ITextControl
        where T : Control
    {
        IEnumerable<T> placeHolders = controls.OfType<T>();
        List<T> holders = placeHolders.ToList();

        foreach (T holder in holders)
        {
            IEnumerable<C> enumBoxes = holder.Controls.OfType<C>();
            List<C> boxes = enumBoxes.ToList();

            foreach (C box in boxes)
            {
                box.Text = string.Empty;
            }
        }
    }

    /// <summary>
    /// Clears the text from control.
    /// </summary>
    /// <typeparam name="C"></typeparam>
    /// <param name="controls">The controls.</param>
    public static void ClearControls<C>(ControlCollection controls) where C : ITextControl
    {
        IEnumerable<C> enumBoxes = controls.OfType<C>();
        List<C> boxes = enumBoxes.ToList();

        foreach (C box in boxes)
        {
            box.Text = string.Empty;
        }
    }

Answer 2

Aquí es lo mismo que propuse en mi primera respuesta, pero en VB, hasta que obtengamos VB10, esto es lo mejor que podemos hacer en VB porque no admite funciones no recurrentes en lambdas:

Solución de VB:

Public Module Extension
    Private Sub ClearTextBox(ByVal T As TextBox)
        T.Clear()
    End Sub

    Private Sub ClearCheckBox(ByVal T As CheckBox)
        T.Checked = False
    End Sub

    Private Sub ClearListBox(ByVal T As ListBox)
        T.Items.Clear()
    End Sub

    Private Sub ClearGroupbox(ByVal T As GroupBox)
        T.Controls.ClearControls()
    End Sub

    <Runtime.CompilerServices.Extension()> _
    Public Sub ClearControls(ByVal Controls As ControlCollection)
        For Each Control In Controls
            If ControlDefaults.ContainsKey(Control.GetType()) Then
                ControlDefaults(Control.GetType()).Invoke(Control)
            End If
        Next
    End Sub

    Private _ControlDefaults As Dictionary(Of Type, Action(Of Control))
    Private ReadOnly Property ControlDefaults() As Dictionary(Of Type, Action(Of Control))
        Get
            If (_ControlDefaults Is Nothing) Then
                _ControlDefaults = New Dictionary(Of Type, Action(Of Control))
                _ControlDefaults.Add(GetType(TextBox), AddressOf ClearTextBox)
                _ControlDefaults.Add(GetType(CheckBox), AddressOf ClearCheckBox)
                _ControlDefaults.Add(GetType(ListBox), AddressOf ClearListBox)
                _ControlDefaults.Add(GetType(GroupBox), AddressOf ClearGroupbox)
            End If
            Return _ControlDefaults
        End Get
    End Property

End Module

Vocación:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
        Me.Controls.ClearControls()
    End Sub

Solo estoy publicando esto aquí para que la gente pueda ver cómo hacer lo mismo en VB.

Answer 3

Las soluciones anteriores parecen ignorar los controles anidados.

Una función recursiva puede ser necesaria, como:

public void ClearControl(Control control)
{
  TextBox tb = control as TextBox;
  if (tb != null)
  {
    tb.Text = String.Empty;
  }
  // repeat for combobox, listbox, checkbox and any other controls you want to clear
  if (control.HasChildren)
  {
    foreach(Control child in control.Controls)
    {
      ClearControl(child)
    }
  }
}

No desea borrar la propiedad Text sin verificar el tipo de controles.

La implementación de una interfaz, como IClearable (como lo sugiere Bill K), en un conjunto de controles derivados reduciría la duración de esta función, pero requeriría más trabajo en cada control.

Answer 4

Puedes repetir el control

foreach (Control ctrl in this)
{
    if(ctrl is TextBox)
        (ctrl as TextBox).Clear();
}

Answer 5

Voté por la solución de Nathan, pero quería agregar un poco más de lo que un comentario puede manejar.

El suyo es en realidad muy bueno, pero creo que la mejor solución sería subconcluir cada uno de los tipos de control que podría estar agregando antes de agregarlos a la GUI. Pídales a todos que implementen una interfaz "Clearable" o algo por el estilo (soy un programador de Java, pero el concepto debería estar allí), luego repítelo como una colección de objetos "Clearable", llamando al único método .clear () en cada

Así es como deberían hacerse las GUI en un sistema OO. Esto hará que su código sea fácil de extender en el futuro; casi demasiado fácil, se sorprenderá.

Editar: (según el comentario de Nathan sobre no cambiar los controles existentes)

Tal vez podría crear clases "Container" que hagan referencia a su control (una para cada tipo de control). En un ciclo como el que configuró en su respuesta, podría instanciar el contenedor correcto, colocar el control real dentro del contenedor y almacenar el contenedor en una colección.

De esta forma, volverás a iterar sobre una colección.

Esta sería una buena solución simple que no es mucho más compleja que la que sugirió, pero infinitamente más ampliable.

Answer 6

Lo que se me ocurrió hasta ahora es algo como esto:

public static class extenstions
{
    private static Dictionary<Type, Action<Control>> controldefaults = new Dictionary<Type, Action<Control>>() { 
            {typeof(TextBox), c => ((TextBox)c).Clear()},
            {typeof(CheckBox), c => ((CheckBox)c).Checked = false},
            {typeof(ListBox), c => ((ListBox)c).Items.Clear()},
            {typeof(RadioButton), c => ((RadioButton)c).Checked = false},
            {typeof(GroupBox), c => ((GroupBox)c).Controls.ClearControls()},
            {typeof(Panel), c => ((Panel)c).Controls.ClearControls()}
    };

    private static void FindAndInvoke(Type type, Control control) 
    {
        if (controldefaults.ContainsKey(type)) {
            controldefaults[type].Invoke(control);
        }
    }

    public static void ClearControls(this Control.ControlCollection controls)
    {
        foreach (Control control in controls)
        {
             FindAndInvoke(control.GetType(), control);
        }
    }

    public static void ClearControls<T>(this Control.ControlCollection controls) where T : class 
    {
        if (!controldefaults.ContainsKey(typeof(T))) return;

        foreach (Control control in controls)
        {
           if (control.GetType().Equals(typeof(T)))
           {
               FindAndInvoke(typeof(T), control);
           }
        }    

    }

}

Ahora puedes simplemente llamar al método de extensión ClearControls así:

 private void button1_Click(object sender, EventArgs e)
    {
        this.Controls.ClearControls();
    }

EDITAR: Acabo de agregar un método genérico ClearControls que borrará todos los controles de ese tipo, que se pueden llamar así:

this.Controls.ClearControls<TextBox>();

Por el momento, solo manejará los controles de nivel superior y no profundizará a través de grupos de grupos y paneles.

Answer 7

private void FormReset () {ViewState.Clear (); Response.Redirect (Request.Url.AbsoluteUri.ToString ()); }

Answer 8

Sé que es una vieja pregunta, pero solo mis 2 centavos. Esta es una clase de ayuda que utilizo para borrar formularios.

using System;
using System.Windows.Forms;

namespace FormClearing
{
    class Helper
    {
        public static void ClearFormControls(Form form)
        {
            foreach (Control control in form.Controls)
            {
                if (control is TextBox)
                {
                    TextBox txtbox = (TextBox)control;
                    txtbox.Text = string.Empty;
                }
                else if(control is CheckBox)
                {
                    CheckBox chkbox = (CheckBox)control;
                    chkbox.Checked = false;
                }
                else if (control is RadioButton)
                {
                    RadioButton rdbtn = (RadioButton)control;
                    rdbtn.Checked = false;
                }
                else if (control is DateTimePicker)
                {
                    DateTimePicker dtp = (DateTimePicker)control;
                    dtp.Value = DateTime.Now;
                }
            }
        }
    }
}

Y llamo al método desde cualquier forma como esta pasando un objeto de formulario como un parámetro.

Helper.ClearFormControls(this);

Puede extenderlo para otros tipos de controles. Solo tienes que lanzarlo.