When should you use C# indexers?

I'd like to use indexers more, but I'm not sure when to use them. All I've found online are examples that use classes like MyClass and IndexerClass.

What about in a school system where there are Students and Teachers, and each Teacher has a list of Students that they're in charge of - any need for indexers in that scenario? For simplicity's sake: each Student can only belong to one 开发者_JAVA技巧Teacher.

---

Indexer is a highly specialized property which allows instances of a class (or struct) to be indexed just like an array (properties can be static but indexers cannot).

Why to use indexers:

• instead of a new data structure, the class itself is a data structure.
• simplified syntax - syntactic sugar

When to use:

• if your class needs list(/array) of its instances (example 1)
• if your class represents list(/array) of values directly related to your class (example 2)

Example 1:

public class Person{
    public string Name{get; set;}
    
    private Person[] _backingStore;
    public Person this[int index]
    {
        get{
            return _backingStore[index];
        }
        set{
            _backingStore[index] = value;
        }
    }
}

Person p = new Person();
p[0] = new Person(){Name = "Hassan"};
p[1] = new Person(){Name = "John Skeet"};    

Example 2:

class TempratureRecord{
    private float[] temps = new float[10] { 56.2F, 56.7F, 56.5F, 56.9F, 58.8F, 61.3F, 56.5F, 56.9F, 58.8F, 61.3F};

    public int Length{
        get { return temps.Length; }
    }

    public float this[int index]
    {
        get{
            return temps[index];
        }
        set{
            temps[index] = value;
        }
    }
}

---

Heres a video i have created http://www.youtube.com/watch?v=HdtEQqu0yOY and below is a detailed explanation about the same.

Indexers helps to access contained collection with in a class using a simplified interface. It’s a syntactic sugar.

For instance lets say you have a customer class with addresses collection inside it. Now let’s say we would like to like fetch the addresses collection by “Pincode” and “PhoneNumber”. So the logical step would be that you would go and create two overloaded functions one which fetches by using “PhoneNumber” and the other by “PinCode”. You can see in the below code we have two functions defined.

Customer Customers = new Customer();
Customers.getAddress(1001);
Customers.getAddress("9090");

If you use indexer you can simplify the above code with something as shown in the below code.

Customer Customers = new Customer();
Address o = Customers[10001];
o = Customers["4320948"];

Cheers.

---

You typically use an indexer if the class represents a list, collection or array of objects. In your case, you could provide an indexer to provide index-based access to a teacher's students.

---

An indexer use in your situation would be a TeachersClass class, which would encapsulate the students (collection) and the current teacher. Although you could do the same thing by exposing the list of students, but it does show you an example.

Here is a code example:

public class TeachersClass
    {
        private List<Student> _students;

        public TeachersClass(Teacher currentTeacher, List<Student> students)
        {
            CurrentTeacher = currentTeacher;
            _students = students;
        }

        public Teacher CurrentTeacher { get; set; }

        public Student this[int studentID]
        {
            get
            {
                return (from s in _students
                        where s.Id = studentID
                        select s).First();
            }
        }   
    }

---

Random order access

You would use an enumerator if your data is normally accessed sequentially.

An indexer on the other hand is useful for directly accessing a specific element, no specific order.

This of course assumes you know the index of the element you want. Comboboxes for example have always supported two values: the string shown to the user, and the id that belongs with it. You could use the id from a selected item in a combobox to directly access the index of your collection, instead of having to search the collection.

The nice thing about indexers in C# is that you can overload them, so you can access items through different kind of keys.

---

The simple answer (as stated above) is when the class represents/contains a collection of items, the indexer will return the elements of the collection.

public Student this[int index] { ..

In a more advanced case you can create a default behavior with a class and make it look a bit like a delegate, especially when the class represents a mapping, or a process. For example a class that calculates the cooling rate of a beer in the refrigerator:

Instead of typing

temperature = coorsLight.CalculateFutureTemperature(time);

you can condence this to

temperature = coorsLight[time];

if the expected behavior (and intent) of the class is to return a value.

---

An indexer is a means to select an element from an aggregate such as an array or collection. While I agree in part with Ian Davis, I think indexers represent something more than public API polish.

Indexers are the primary means of accessing arrays and most of the major classes representing collections in the .NET BCL implemented indexers, presumably to provide a common expernce when dealing with types that aggregate other types.

Because indexers are a standard part of the interface to many of the BCLs collection types, and because these types are heavily used, as developers learn .NET as a platform, it is reasonable to suggest that an expectation is created that collections can be accessed using some type of indexer.

If your type's interface matches the expectations that developers have already, then that type becomes easier to use because the developer doesn't have to think. This is true whether the developers in question are internal to your organization or out there in the wild.

Of course there are situations where having an indexer just doesn't make sense, and if thats the case then don't implement an indexer.

---

Indexers allow instances of a class or struct to be indexed just like arrays. Indexers resemble properties except that their accessors take parameters.

Indexers enable objects to be indexed in a similar manner to arrays.

    // C#: INDEXER 
using System; 
using System.Collections; 

class MyClass 
{ 
    private string []data = new string[5]; 
    public string this [int index] 
    { 
       get 
       { 
           return data[index]; 
       } 
       set 
       { 
           data[index] = value; 
       } 
    } 
}

class MyClient 
{ 
   public static void Main() 
   { 
      MyClass mc = new MyClass(); 
      mc[0] = "Rajesh"; 
      mc[1] = "A3-126"; 
      mc[2] = "Snehadara"; 
      mc[3] = "Irla"; 
      mc[4] = "Mumbai"; 
      Console.WriteLine("{0},{1},{2},{3},{4}",mc[0],mc[1],mc[2],mc[3],mc[4]); 
   } 
} 

Code project

---

I remember there was this time when I had a long inside a class, and some digits of that particular long meant something (for example if the third digit was a 3 it meant that the chart had a specific type of encoding, horrible system I know but I didn't invent it)

So I did something like this to return the xth digit of the number:

protected int this[int index]
{
    get
    {
        int tempN = Number;
        if (index > 0)
        {
            tempN /= index * 10;
        }
        return tempN % 10;
    }
}

It was protected because a different method used it, so it was kind of a helper. Of course a simple GetDigit(int a) would've been the same thing (and more self-explanatory) but at the time I thought it was one of the few times I thought using an indexer would make sense. Haven't used them since =(.

---

IMHO, Indexers are probably best if you're trying to spruce up a packaged API - it's not worth the effort for your run of the mill business object.

And if you're making some specialized collection, I'd categorize that as sprucing up your packaged API - even if you keep it all in one module.