C sharp - Indexers - Que son y en que momento se usan

   
Vista:

Indexers - Que son y en que momento se usan

Publicado por Nicolas (4 intervenciones) el 18/09/2015 14:52:58
Buenos días Gente,

Estoy leyendo un tutorial intermedio-avanzado de C Sharp y me tope con un tema un poco complicado.

El tutorial en particular abarca el tema de los indices o indexers, de esta forma:

"Un indexador permite a un objeto ser indexado como un array (Arreglo). Cuando defines un indexador para una clase, esta clase se comporta como un virtual array (Arreglo virtual). Puedes, luego, acceder a la instancia de esa clase usando el operador de acceso [ ]. "

Si vamos desde el principio un objeto es en muy pocas palabras la instancia de la clase

1
2
3
4
5
6
7
8
9
10
11
12
Class Miclase
   {
      //Miembros de mi clase sean constructores, variables, propiedades para acceder a esa variables etc.
   }
 
//Instancia de la clase:
 
static void Main(string[] args)
      {
         Miclase uno = new Miclase();
         //Codigo
      }

Por ende lo que yo entiendo es que un indexer o indexador es una forma de indexar estas instancias, como asi tenemos un arreglo de enteros:

1
private int[] nombredearreglo = new string[];

Esto mismo pero con instancias de clase, pero luego explica:
"Definir una propiedad involucra proveerla de un nombre, Indexadores no son definidos con nombres pero con el keyword this que refiere a la instancia del objeto"

Luego pone un ejemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
using System;
namespace IndexerApplication
{
   class IndexedNames
   {
      private string[] namelist = new string[size];
      static public int size = 10;
      public IndexedNames()
      {
         for (int i = 0; i < size; i++)
         namelist[i] = "N. A.";
      }
 
      public string this[int index]
      {
         get
         {
            string tmp;
 
            if( index >= 0 && index <= size-1 )
            {
               tmp = namelist[index];
            }
            else
            {
               tmp = "";
            }
 
            return ( tmp );
         }
         set
         {
            if( index >= 0 && index <= size-1 )
            {
               namelist[index] = value;
            }
         }
      }
 
      static void Main(string[] args)
      {
         IndexedNames names = new IndexedNames();
         names[0] = "Zara";
         names[1] = "Riz";
         names[2] = "Nuha";
         names[3] = "Asif";
         names[4] = "Davinder";
         names[5] = "Sunil";
         names[6] = "Rubic";
         for ( int i = 0; i < IndexedNames.size; i++ )
         {
            Console.WriteLine(names[i]);
         }
 
         Console.ReadKey();
      }
   }
}

Por lo que leo la clase se llama IndexedNames, sus miembros de clase se componen de un arreglo con modificador de acceso private llamado namelist, la cual su cantidad de elementos varia según otra variable de modificador de acceso public del tipo int el cual en este caso es 10, por ende el arreglo tendrá 10 indices (0-9).
Luego hay un método que recorre el array y por cada elemento escribe "N. A.".

Lo que realmente no entiendo es esto:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public string this[int index]
      {
         get
         {
            string tmp;
 
            if( index >= 0 && index <= size-1 )
            {
               tmp = namelist[index];
            }
            else
            {
               tmp = "";
            }
 
            return ( tmp );
         }
         set
         {
            if( index >= 0 && index <= size-1 )
            {
               namelist[index] = value;
            }
         }
      }

Y esta parte es la que en pocas palabras explica lo que es:

"Declarar el comportamiento de un indexer es, en cierto modo, similar a la de una propiedad, similar a las propiedades se usa los accesores get y set para definir un indexer. Aun asi, las propiedades devuelven o setean un miembro especifico mientras que los indexers devuelven o setean un valor particular de la instancia del objeto. En pocas palabras, 'rompe' la instancia de dato en pequeñas partes e indexa cada parte con set y get"

Alguien puede explicarme este párrafo, por lo que tenia entendido HASTA este párrafo un indexer no es mas ni menos que indexar una instancia de la clase, pero a que se refiere con "romper en pequeñas partes" un valor particular de la instancia del objeto?.

Muchas gracias y perdón por lo largo del thread.

Saludos Cordiales,
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder