Antes de comenzar hablar directamente de los
indizadores, vamos a ver unos ejemplos que nos ayudarán a comprender
mejor las ventajas del uso de la indexación.
Supongamos
que tenemos una clase llamada “Personas” que lo único que hace es
guardar los nombres de distintas personas. Parece lógico que para
implementar esta clase definamos una matriz de tipo String que almacene
los nombres. Por ejemplo podríamos pensar en hacer esto:
class Personas
{
public string[] Nombre = new string[3];
}
Así tenemos definida una clase que almacena 3 nombres de personas en
una matriz de tipo String. Para utilizar solo tendríamos que hacer esto:
static void Main(string[] args)
{
Personas persona = new Personas();
//Rellenamos la matriz.
persona.Nombre[0] = "Mariano";
persona.Nombre[1] = "Pedro";
persona.Nombre[2] = "Maria";
//Mostrar el contenido de la matriz.
foreach (string item in persona.Nombre)
Console.WriteLine(item);
Console.ReadLine();
}
Desde luego esto funciona pero al tener declarada
la matriz como pública no contribuimos a proteger debidamente los
miembros de la clase.
Una solución a este problema de proteger los miembros es declararlos como privados. Es decir:
class Personas
{
private string[] Nombre = new string[3];
}
¿Cómo accedemos ahora a los elementos de la matriz
“persona”?. Al estar declarada como privada no tenemos acceso a este
campo por medio de un objeto de la clase “Personas”.
La
solución es muy sencilla. Añadimos a nuestra clase dos métodos
públicos, una para asignar nombres en la matriz (método Añadir) y otro
para recuperar los valores de los elementos almacenados en la matriz
(método Obtener).
class Personas
{
private string[] Nombre = new string[3];
public void Añadir(string nom, int i)
{
Nombre[i] = nom;
}
public string Obtener(int i)
{
return Nombre[i];
}
}
Ahora la clase podemos utilizarla por medio de los métodos de la siguiente forma.
Personas persona = new Personas();
//Rellenamos la matriz.
persona.Añadir("Mariano", 0);
persona.Añadir("Pedro", 1);
persona.Añadir("Maria", 2);
//Mostrar el contenido de la matriz.
for (int i = 0; i < 3; i++)
Console.WriteLine(persona.Obtener(i));
Console.ReadLine();
Es perfecto. Todo funciona correctamente y tenemos el nivel de protección que deseábamos.
Sin
embargo no estamos utilizando la matriz como si fuera una matriz. No
accedemos a los elementos por medio de un índice dentro del operador de
indexación [] que tantas veces hemos visto en las matrices. Hagamos lo
siguiente:
class Personas
{
private string[] Nombre = new string[3];
public string this[int i]
{
get { return Nombre[i]; }
set { Nombre[i] = value; }
}
}
La forma de utilizar un objeto de clase “Personas”, ahora que ya esta indexada, es la siguiente:
Personas persona = new Personas();
//Rellenamos la matriz.
persona[0] = "Mariano";
persona[1] = "Pedro";
persona[2] = "Maria";
//Mostrar el contenido de la matriz.
for (int i = 0; i < 3; i++)
Console.WriteLine(persona[i]);
Console.ReadLine();
Como vemos la definición de la clase tiene mucho
menos código al no tener que implementar dos métodos, esto ya es una
ventaja. La forma de obtener y establecer los elementos de la matriz es
mucho más natural.
Si una propiedad es una
especie de “método inteligente” de las variables definidas en una
clase. La indexación es “método inteligente” de las matrices definidas
en nuestras clases.
No lo dudéis, si tenéis una clase con varios campos que almacenan datos en matrices, ¡indexar la clase!.