C# | Indexadores – Part 1

Requisito previo: Propiedades en C#

Un indexador permite que una instancia de una clase o estructura se indexe como una array. Si el usuario definirá un indexador para una clase, entonces la clase se comportará como una array virtual. El operador de acceso a la array, es decir ( [ ] ), se usa para acceder a la instancia de la clase que usa un indexador. Un usuario puede recuperar o establecer el valor indexado sin señalar una instancia o un miembro de tipo. Los indexadores son casi similares a las propiedades . La principal diferencia entre los indexadores y las propiedades es que los usuarios de los indexadores tomarán parámetros.

Sintaxis:  

[access_modifier] [return_type] this [argument_list]
{
  get 
  {
     // get block code
  }
  set 
  {
    // set block code
  }

}

En la sintaxis anterior:

• access_modifier: Puede ser público, privado, protegido o interno.
• return_type: puede ser cualquier tipo de C# válido.
• this: Es la palabra clave que apunta al objeto de la clase actual.
• argument_list: Esto especifica la lista de parámetros del indexador.
• get{ } y set { }: estos son los accesores .

Ejemplo: 

// C# program to illustrate the Indexer
using System;
 
// class declaration
class IndexerCreation
{
 
    // class members
    private string[] val = new string[3];
     
    // Indexer declaration
    // public - access modifier
    // string - the return type of the Indexer
      // this - is the keyword having a parameters list
    public string this[int index]
    {
 
        // get Accessor
        // retrieving the values
        // stored in val[] array
        // of strings
        get
        {
 
            return val[index];
        }
 
        // set Accessor
        // setting the value at
        // passed index of val
        set
        {
 
            // value keyword is used
            // to define the value
            // being assigned by the
            // set indexer.
            val[index] = value;
        }
    }
}
 
// Driver Class
class main {
     
    // Main Method
    public static void Main() {
         
        // creating an object of parent class which
        // acts as primary address for using Indexer
        IndexerCreation ic = new IndexerCreation();
 
        // Inserting values in ic[]
        // Here we are using the object
        // of class as an array
        ic[0] = "C";
        ic[1] = "CPP";
        ic[2] = "CSHARP";
 
        Console.Write("Printing values stored in objects used as arrays\n");
         
        // printing values
        Console.WriteLine("First value = {0}", ic[0]);
        Console.WriteLine("Second value = {0}", ic[1]);
        Console.WriteLine("Third value = {0}", ic[2]);
     
    }
}

Producción:  

Printing values stored in objects used as arrays
First value = C
Second value = CPP
Third value = CSHARP

Puntos importantes sobre los indexadores: 

• Hay dos tipos de indexadores, es decir, un indexador unidimensional y un indexador multidimensional . Lo anterior discutido es un indexador unidimensional.
• Los indexadores pueden estar sobrecargados.
• Estos son diferentes de Propiedades .
• Esto permite indexar el objeto de forma similar a las arrays.
• Un descriptor de acceso set siempre asignará el valor mientras que el descriptor de acceso get devolverá el valor.
• La palabra clave » esta » siempre se usa para declarar un indexador.
• Para definir el valor que asigna el indexador establecido, se utiliza la palabra clave » valor «.
• Los indexadores también se conocen como Smart Arrays o propiedad parametrizada en C#.
• Indexer no puede ser un miembro estático ya que es un miembro de instancia de la clase.