que - C#indexadores múltiples

indexer que es

Question

¿Es posible tener algo como lo siguiente?

class C
{
    public Foo Foos[int i]
    {
        ...
    }

    public Bar Bars[int i]
    {
        ...
    }
}

Si no, ¿cuáles son algunas de las formas en que puedo lograr esto? Sé que podría hacer funciones llamadas getFoo (int i) y getBar (int i), pero esperaba hacer esto con las propiedades.

Answer 1

C # no tiene sobrecarga de tipo de retorno. Puede definir múltiples indexadores si sus parámetros de entrada son diferentes.

Answer 2

No en C #, no.

Sin embargo, siempre puede devolver colecciones de propiedades de la siguiente manera:

public IList<Foo> Foos
{
    get { return ...; }
}

public IList<Bar> Bars
{
    get { return ...; }
}

IList <T> tiene un indexador, por lo que puede escribir lo siguiente:

C whatever = new C();
Foo myFoo = whatever.Foos[13];

En las líneas "regresar ..." puede devolver lo que implemente IList <T>, pero puede que devuelva un contenedor de solo lectura alrededor de su colección, vea el método AsReadOnly ().

Answer 3

No, no puedes hacerlo. Solo los métodos que pueden hacer que sus firmas difieran solo por tipo de devolución son los operadores de conversión. Los indexadores deben tener diferentes tipos de parámetros de entrada para que compile.

Answer 4

Si estás tratando de hacer algo como esto:

var myClass = new MyClass();

Console.WriteLine(myClass.Foos[0]);
Console.WriteLine(myClass.Bars[0]);

luego necesita definir los indexadores en las clases Foo y Bar, es decir, colocar todos los objetos Foo dentro de Foos y hacer de Foos una instancia de tipo que permita indexar directamente.

Para demostrar el uso de matrices para las propiedades de miembros (dado que ya admiten indexadores):

public class C {
    private string[] foos = new string[] { "foo1", "foo2", "foo3" };
    private string[] bars = new string[] { "bar1", "bar2", "bar3" };
    public string[] Foos { get { return foos; } }
    public string[] Bars { get { return bars; } }
}

te permitiría decir:

 C myThing = new C();
 Console.WriteLine(myThing.Foos[1]);
 Console.WriteLine(myThing.Bars[2]);

Answer 5

Esto de la especificación C # 3.0

"La sobrecarga de indexadores permite que una clase, estructura o interfaz declare múltiples indexadores, siempre que sus firmas sean únicas dentro de esa clase, estructura o interfaz".

public class MultiIndexer : List<string>  
{
    public string this[int i]
    {
        get{
            return this[i];
        }
    }
    public string this[string pValue]
    {
        get
        {
            //Just to demonstrate
            return this.Find(x => x == pValue);  
        }
    }      
}

Answer 6

Pruebe mi clase IndexProperty para habilitar varios indizadores en la misma clase

http://www.codeproject.com/Tips/319825/Multiple-Indexers-in-Csharp

Answer 7

Hay una manera ... si defines 2 tipos nuevos para permitir que el compilador distinga las dos firmas diferentes ...

  public struct EmployeeId
  { 
      public int val;
      public EmployeeId(int employeeId) { val = employeeId; }
  }
  public struct HRId
  { 
      public int val;
      public HRId(int hrId) { val = hrId; }
  }
  public class Employee 
  {
      public int EmployeeId;
      public int HrId;
      // other stuff
  }
  public class Employees: Collection<Employee>
  {
      public Employee this[EmployeeId employeeId]
      {
          get
             {
                foreach (Employee emp in this)
                   if (emp.EmployeeId == employeeId.val)
                      return emp;
                return null;
             }
      }
      public Employee this[HRId hrId]
      {
          get
             {
                foreach (Employee emp in this)
                   if (emp.HRId == hrId.val)
                      return emp;
                return null;
             }
      }
      // (or using new C#6+ "expression-body" syntax)
      public Employee this[EmployeeId empId] => 
             this.FirstorDefault(e=>e.EmployeeId == empId .val;
      public Employee this[HRId hrId] => 
             this.FirstorDefault(e=>e.EmployeeId == hrId.val;

  }

Entonces para llamarlo, tendrías que escribir:

Employee Bob = MyEmployeeCollection[new EmployeeID(34)];

Y si escribiste un operador de conversión implícito:

public static implicit operator EmployeeID(int x)
{ return new EmployeeID(x); }

entonces ni siquiera tendrías que hacer eso para usarlo, podrías simplemente escribir:

Employee Bob = MyEmployeeCollection[34];

Lo mismo se aplica incluso si los dos indexadores devuelven tipos diferentes ...