Array de controles en C# 2.0

El código para C# (2.0 o superior)

El código de la clase ArrayControles

//-----------------------------------------------------------------------------
// ArrayControles                                                   (09/Abr/07)
//
// Clase-colección para simular un array de controles de Visual Basic 6.0
// Se utilizan clases generic para contener los controles.
//
// Esta clase está basada en ControlArray (09/Ago/2002),
// publicada en mi sitio el 14/Nov/2002:
// http://www.elguille.info/NET/dotnet/arrayControles.htm
//
// ©Guillermo 'guille' Som, 2002, 2007
//-----------------------------------------------------------------------------

using System;
using System.Collections.Generic;
 
using System.Windows.Forms;
using System.Drawing;

namespace elGuille.info.Utilidades
{

/// <summary>
/// Clase para contener controles del tipo indicado,
/// que debe derivarse de Control.
/// </summary>
/// <typeparam name="T">
/// El tipo de control que contendrá la colección.
/// </typeparam>
/// <remarks>
/// Se deriva de List&ltT&gt;
/// Autor: Guillermo 'guille' Som
/// Fecha: 09/Abr/2007
/// </remarks>
public class ArrayControles<T> : List<T>
    where T : Control
    {
 
    private string m_Nombre;
 
    /// <summary>
    /// En el constructor se debe indicar el nombre del control.
    /// </summary>
    /// <param name="elNombre">
    /// El nombre base de los controles del array,
    /// esos controles deben tener el nombre: elNombre_numero.
    /// No se admite una cadena vacía.
    /// </param>
    /// <remarks></remarks>
    public ArrayControles(string elNombre) 
        : base() 
    {
        if( String.IsNullOrEmpty(elNombre) )
        {
            throw new ArgumentException( 
                "El nombre del control no puede ser una cadena vacía");
        }
        // Asignarlo a la propiedad
        // para que se convierta en minúsculas
        // o cualquier otra comprobación.
        this.Nombre = elNombre;
    }  
 
    /// <summary>
    /// Constructor para inicializar directamente la colección de controles
    /// </summary>
    /// <param name="ctrls">
    /// Colección de controles en la que están los que debemos usar.
    /// </param>
    /// <param name="elNombre">
    /// El nombre base de los controles a tener en cuenta.
    /// </param>
    /// <remarks></remarks>
    public ArrayControles(
        string elNombre, 
        Control.ControlCollection ctrls) 
        : this(elNombre) 
    {
        //
        this.Clear();
        asignarLosControles(ctrls);
        this.Reorganizar();
    }  
 
    /// <summary>
    /// Constructor para inicializar directamente la colección de controles
    /// </summary>
    /// <param name="contenedor">
    /// El contenedor que tiene los controles a comprobar.
    /// </param>
    /// <param name="elNombre">
    /// El nombre base de los controles a tener en cuenta.
    /// </param>
    /// <remarks></remarks>
    public ArrayControles(
        string elNombre, 
        ContainerControl contenedor) 
        : this(elNombre, contenedor.Controls) 
    {
    }  

    /// <summary>
    /// Asignar los controles de la colección indicada.
    /// </summary>
    /// <param name="ctrls">
    /// Colección de controles en la que están los que debemos usar.
    /// El nombre usado será el indicado al crear la colección.
    /// </param>
    /// <remarks>
    /// La colección de controles puede ser Me.Controls
    /// ya que aquí solo se tendrán en cuenta los controles
    /// que tengan el nombre usado en esta clase,
    /// y se recorren todas las colecciones de controles que haya.
    /// </remarks>
    public void AsignarControles(Control.ControlCollection ctrls) 
    {
        this.Clear();
        asignarLosControles(ctrls);
        this.Reorganizar();
    }  
 
    /// <summary>
    /// Asignar los controles del contenedor indicado.
    /// </summary>
    /// <param name="contenedor">
    /// El contenedor de los controles en los que se buscarán
    /// los del tipo indicado en esta colección.
    /// </param>
    /// <remarks></remarks>
    public void AsignarControles(ContainerControl contenedor) 
    {
        this.Clear();
        asignarLosControles(contenedor.Controls);
        this.Reorganizar();
    }  
 
    private void asignarLosControles(Control.ControlCollection ctrls) 
    {
        // El tipo debe ser Control, para tener en cuenta todos los controles
        // que haya en la colección indicada.
        foreach(Control ctr in ctrls)
        {
            // Hacer una llamada recursiva por si este control "contiene" otros
            if( ctr.Controls.Count > 0 )
            {
                asignarLosControles(ctr.Controls);
            }

            // No tener en cuenta las mayúsculas o minúsculas
            if( ctr.Name.ToLower().IndexOf(m_Nombre) > -1 )
            {
                this.Add( ctr as T );
            }
        }
    }  

    // Sobrecargas de la propiedad predeterminada
 
    /// <summary>
    /// Propiedad predeterminada para devolver
    /// el control con el nombre indicado.
    /// </summary>
    /// <param name="name">
    /// El nombre del control a buscar.
    /// </param>
    /// <value></value>
    /// <returns>
    /// El control que tiene el nombre indicado.
    /// </returns>
    /// <remarks></remarks>
     public T this[string name] 
     {
        get
        {
            int index = this.Index(name);
            // Si existe, devolverlo, sino, devolver un valor nulo
            if( index == -1 )
            {
                return null;
            }
 
            return this[index];
        }
    }

    /// <summary>
    /// Sobrecarga de la propiedad predeterminada
    /// para permitir el acceso con un valor de tipo Object.
    /// Aunque el tipo debe ser del que contiene la colección,
    /// si no es así, se devuelve un valor nulo.
    /// </summary>
    /// <param name="obj">
    /// El control a comprobar
    /// </param>
    /// <value></value>
    /// <returns>
    /// Si el parámetro es del tipo adecuado,
    /// se devuelve con el tipo de la colección,
    /// si no lo es, se devuelve un valor nulo.
    /// </returns>
    /// <remarks></remarks>
    public T this[object obj]
    {
        get
        {
            // En C# cuando el parámetro es int
            // la sobrecarga de object tiene preferencia.
            if (obj.GetType() == typeof(int))
            {
                return base[(int)obj];
            }

            T ctrl = obj as T;

            return ctrl;
        }
    }
 
    /// <summary>
    /// Devuelve el índice del control de esta colección
    /// que tenga el mismo índice que el del parámetro.
    /// Ese parámetro puede ser cualquier control,
    /// y lo que se tendrá en cuenta será el nombre usado,
    /// el cual debe tener la forma nombre_indice,
    /// de forma que se devolverá el control que tenga ese mismo índice.
    /// </summary>
    /// <param name="obj">
    /// El control a comprobar si existe un índice como el indicado.
    /// Al ser de tipo Object no es necesario que sea del mismo tipo
    /// que los que contiene esta colección.
    /// </param>
    /// <returns>
    /// El índice correspondiente.
    /// Aunque no se comprueba si existe en la colección.
    /// En el caso de que el parámetro no tenga el formato adecuado,
    /// se devuelve -1.
    /// </returns>
    /// <remarks>
    /// Esta sobrecarga se puede usar para buscar el control correspondiente
    /// con el del índice de otro control, por ejemplo:
    /// i = m_TextBox1.Index(sender)
    /// Por supuesto, el parámetro debe ser de tipo Control.
    /// Este método podría estar compartido, pero debido a que su uso
    /// sería: ArrayControles&lt;TIPO&gt;.Index(sender)
    /// he preferido dejarlo como de instancia.
    /// </remarks>
    public int Index(object obj) 
    {
        Control ctrl = obj as Control;
        if( ctrl == null )
        {
            return -1;
        }
        //
        int i = -1;
        i = ctrl.Name.LastIndexOf("_");
        if( i > -1 )
        {
            i = Convert.ToInt32(ctrl.Name.Substring(i + 1));
        }
 
        return i;
    }  
 
    /// <summary>
    /// Devuelve el índice del control con el nombre indicado.
    /// </summary>
    /// <param name="name">
    /// Nombre del control a buscar en la colección.
    /// </param>
    /// <returns>
    /// Un valor de tipo entero con el índice del control.
    /// </returns>
    /// <remarks></remarks>
    public int Index(string name) 
    {
        int hallado = -1;

        for(int i= 0; i< this.Count; i++)
        {
            T ctrl = this[i];
            if( String.Compare(ctrl.Name, name, true) == 0 )
            {
                hallado = i;
                break;
            }
        }
        return hallado;
    }  
 
    /// <summary>
    /// Devuelve el índice del control indicado.
    /// </summary>
    /// <param name="ctrl">
    /// El control del que queremos averiguar el índice.
    /// </param>
    /// <returns>
    /// Un valor de tipo entero con el índice del control.
    /// </returns>
    /// <remarks></remarks>
    public int Index(T ctrl) 
    {
        int i = ctrl.Name.LastIndexOf("_");
        //
        // Si el nombre no tiene el signo _
        if( i == -1 )
        {
            i = this.IndexOf(ctrl);
        }
        else
        {
            i = Convert.ToInt32(ctrl.Name.Substring(i + 1));
        }
 
        return i;
    }  
    //
    /// <summary>
    /// La propiedad Nombre, externamente será de solo lectura.
    /// </summary>
    /// <value>El nombre de la colección de controles</value>
    /// <returns>
    /// El nombre de la colección de controles.
    /// </returns>
    /// <remarks>
    /// </remarks>
    public string Nombre
    {
        get
        {
            return m_Nombre;
        }
        private set
        {
            m_Nombre = value.ToLower();
        }
    }  
    //
    /// <summary>
    /// Reorganizar el contenido de la colección,
    /// ordenando por el índice indicado después del guión bajo
    /// </summary>
    /// <remarks></remarks>
    public void Reorganizar() 
    {
        List<T> ca = new List<T>();
        //
        for(int i= 0; i< this.Count; i++)
        {
            foreach(T ctr in this)
            {
                if( i == this.Index(ctr) )
                {
                    ca.Add(ctr);
                    break;
                }
            }
        }
        //
        this.Clear();
        foreach(T ctr in ca)
        {
            this.Add(ctr);
        }
    }  
}

}

El código del formulario:

//-----------------------------------------------------------------------------
// Prueba para usar la clase ArrayControles                         (09/Abr/07)
//
// Utilizando una clase generic para los controles.
//
// Basado en el ejemplo publicado en mi sitio:
// http://www.elguille.info/NET/dotnet/arrayControles.htm
//
// ©Guillermo 'guille' Som, 2002, 2007
//-----------------------------------------------------------------------------

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

using elGuille.info.Utilidades;

namespace arrayControlesGeneric_cs
{

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    // Colecciones (como arrays) para contener los controles

    private ArrayControles<Label> m_Label1;
    private ArrayControles<TextBox> m_TextBox1;
    private ArrayControles<RadioButton> m_RadioButton1;
    //
    // Asignar los eventos a los controles
    private void asignarEventos()
    {
        //
        // Aquí estarán los procedimientos a asignar a cada array de controles
        //
        foreach (RadioButton opt in m_RadioButton1)
        {
            // En C# los delegados los podemos crear
            // de forma "precisa" (indicando el delegado asociado)
            // o bien de forma "relajada" (indicando solo el método).
            opt.KeyPress += RadioButton1_KeyPress;
            //opt.KeyPress += new KeyPressEventHandler(RadioButton1_KeyPress);
            // Para el evento general de recibir foco
            opt.Enter += control_Enter;
            // opt.Enter += new EventHandler(control_Enter);
        }

        foreach (TextBox txt in m_TextBox1)
        {
            txt.Enter += TextBox1_Enter;
            txt.KeyPress += TextBox1_KeyPress;
            txt.Leave += TextBox1_Leave;
            // Para el evento general de recibir foco
            txt.Enter += control_Enter;
        }

        foreach (Label lbl in m_Label1)
        {
            // Para el evento general de recibir foco
            lbl.Enter += control_Enter;
        }
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        // Asignar los controles y reorganizar los índices
        // No importa si el nombre no coincide exactamente,
        // ya que no se diferencian las mayúsculas de las minúsculas.

        m_Label1 = new ArrayControles<Label>("Label1", this);
        m_TextBox1 = new ArrayControles<TextBox>("textBox1", this);
        m_RadioButton1 = new ArrayControles<RadioButton>("RadioButton1", this);

        // Asignar sólo los eventos
        asignarEventos();

        // Asignar unos textos a las cajas de texto
        for (int i = 0; i < m_TextBox1.Count; i++)
        {
            m_TextBox1[i].Text = "Caja de textos " + i;
        }

    }

    private void control_Enter(object sender, EventArgs e)
    {
        Control ctrl = sender as Control;

        this.labelInfo.Text = "El control con el foco es: " + ctrl.Name;
    }

    private void TextBox1_Enter(object sender, EventArgs e)
    {
        // También se puede evaluar el índice
        // y usar los que correspondan con ese valor.
        //
        // Fíjate que en el Label, los valores son _0, _1 y _2
        // y en el TextBox son _00, _01 y _02,
        // aunque parece que "no coinciden",
        // lo que importa es que el valor numérico sea el adecuado.

        int index = m_TextBox1.Index(sender);
        m_TextBox1[index].SelectAll();
        // resaltar la etiqueta
        m_Label1[index].BackColor = Color.FromKnownColor(KnownColor.ControlDark);
    }

    private void TextBox1_Leave(object sender, EventArgs e)
    {
        // En este caso, esto es más cómodo:
        // ya que solo queremos el índice.
        int index = m_TextBox1.Index(sender);

        // poner la etiqueta con el color normal
        m_Label1[index].BackColor = Color.FromKnownColor(KnownColor.Control);
    }

    private void TextBox1_KeyPress(object sender, KeyPressEventArgs e)
    {
        if (e.KeyChar == (int)Keys.Return)
        {
            int index = m_TextBox1.Index(sender);

            if (index == m_TextBox1.Count - 1)
            {
                m_RadioButton1[0].Focus();
            }
            else
            {
                m_TextBox1[index + 1].Focus();
            }

            // Evitar el pitido
            e.Handled = true;
        }
    }

    private void RadioButton1_KeyPress(object sender, KeyPressEventArgs e)
    {
        if (e.KeyChar == (int)Keys.Return)
        {
            int index = m_RadioButton1.Index(sender);
            //
            if (index == 0)
            {
                m_RadioButton1[index + 1].Focus();
            }
            else
            {
                m_TextBox1[0].Focus();
            }
        }
    }

    private void btnSalir_Click(object sender, EventArgs e)
    {
        this.Close();
    }
}

}