Indexeurs multiples C #

Est-il possible d'avoir quelque chose comme ce qui suit:

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

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

Si non, quelles sont certaines des façons d'y parvenir? Je sais que je pourrais faire les fonctions appelées getFoo(int i) et getBar(int i), mais j'espérais pour ce faire avec des propriétés.

source d'informationauteur smack0007

  1. 15

    Pas en C#, no.

    Cependant, vous pouvez toujours revenir collections de propriétés, comme suit:

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

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

    IList<T> a un indexeur, de sorte que vous pouvez écrire le code suivant:

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

    Sur les lignes "de retour ...;" vous pouvez retourner tout implémente IList<T>, mais vous risquez de quoi retourner un wrapper en lecture seule autour de votre collection, consultez AsReadOnly() la méthode.

  2. 15

    Ce à partir de C# 3.0

    "La surcharge des indexeurs permet à une classe, struct ou de l'interface de déclarer plusieurs indexeurs, à condition que leurs signatures uniques au sein de cette classe, struct, ou de l'interface." 

    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);  
        }
    }      
}
  3. 4

    Tenter ma IndexProperty classe pour permettre plusieurs indexeurs dans la même classe

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

  4. 4

    Il y a un moyen.. si vous définissez 2 nouveaux types de permettre au compilateur de distinguer les deux signatures différentes...

      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;

  }

    Puis de l'appeler, il aurait fallu écrire: 

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

    Et si vous avez écrit une conversion implicite de l'opérateur:

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

    alors vous ne avez même pas besoin de le faire pour l'utiliser, vous pouvez simplement écrire:

    Employee Bob = MyEmployeeCollection[34];

    Même chose s'applique même si les deux indexeurs de retour différents types...

  5. 3

    Si vous essayez de faire quelque chose comme ceci:

    var myClass = new MyClass();

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

    ensuite, vous devez définir les indexeurs sur le Foo et Bar classes elles-mêmes - c'est à dire mettre tous les Foo objets à l'intérieur de Foos, et de faire des Foos un type d'instance qui prend en charge l'indexation directement.

    De démontrer à l'aide de tableaux pour les propriétés de membre (depuis qu'ils ont déjà le soutien des indexeurs):

    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; } }
}

    vous permettrait de dire:

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

    C# n'a pas de type de retour de la surcharge. Vous pouvez définir plusieurs indexeurs si leurs paramètres d'entrée sont différents.

  7. 0

    Non tu ne peux pas faire. Seules les méthodes qui peuvent avoir leurs signatures ne diffèrent que par le type de retour sont des opérateurs de conversion. Les indexeurs doit avoir différents types de paramètres pour la compiler.