Real world use cases for C# indexers ?

Question

I've seen lot of examples for c# Indexers, but in what way will it help me in real life situations.

I know the C# guru wouldn't have added this if it wasn't a serious feature, but i cant think of a real world situation (not the foo bar stuff) to use indexers.

Note:I realize a related question exists, but it doesn't help me much.

Thanks.

Answer 1

Let's say you have a collection of objects that you want to be able to index by something other than the order in which it was placed in a collection. In the example below, you can see how you could use the 'Location' property of some object and using the indexer, return all objects in the collection that match you location, or in the second example, all objects that contain a certain Count() of objects.

class MyCollection {

  public IEnumerable<MyObject> this[string indexer] {
    get{ return this.Where(p => p.Location == indexer); }
  }

  public IEnumerable<MyObject> this[int size] {
    get{ return this.Where(p => p.Count() == size);}
  }
}

Answer 2

Once .NET got generics, the biggest reason for me to implement an indexer (to implement a strongly-typed collection) went away.

Answer 3

Microsoft has an example using an indexer to treat a file as an array of bytes.

http://msdn.microsoft.com/en-us/library/aa288465(VS.71).aspx

Answer 4

It is just syntactical sugar for collection type classes. I never had a reason to write such a class. So I think there are very rare uses of it in "real life", because the classes using it are already implemented.

Answer 5

The most obvious examples, as mentioned by Skurmedel, are List<T> and Dictionary<TKey, TValue>. What would you prefer over:

List<string> list = new List<string> { "a", "b", "c" };
string value = list[1]; // This is using an indexer

Dictionary<string, string> dictionary = new Dictionary<string, string>
{
    { "foo", "bar" },
    { "x", "y" }
};
string value = dictionary["x"]; // This is using an indexer

? Now it may be relatively rare for you need to write an indexer (usually when you're creating a collection-like class), but I suspect you use them reasonably frequently.

Answer 6

The way I look at indexers is that (rightly or wrongly!), accessing something by index should be more efficient than accessing it any other way, because in some way, shape or form, the class whose indexer I'm using stores some form of index that allows it to quickly lookup values when accessed that way.

The classical example is an array, when you access element n of an array by using the code myarray[3], the compiler/interpreter knows how big (memory-wise) elements of the array are and can treat it as an offset from the start of the array. You could also "for(int i = 0; i<myarray.length; i++) { if (i = 3) then { .. do stuff } }" (not that you'd ever want to!), which would be less efficient. It also shows how an array is a bad example.

Say you had a collection class that stores, umm, DVDs, so:

public class DVDCollection
{
  private static Dictionary<string, DVD> store = new Dictionary<string, DVD>();
  private static Dictionary<ProductId, string> dvdsByProductId = new Dictionary<string, string>();

  public DVDCollection()
  {
   // ... gets DVD data from somewhere and stores it *by* TITLE in "store"
   // ... stores a lookup set of DVD ProductId's and names in "dvdsByProductid"
  }

  // Get the DVD concerned, using an index, by product Id
  public DVD this[ProductId index]  
  {
     string title = dvdsByProductId[index];
     return store[title];
  }
}

Just my 2p, but, like I said,.. I've always considered an "indexer" as being an expedient way of getting data out of something.

Answer 7

In ASP.Net, there are a few different times where an indexer is used such as reading something from any of the Request, Session or Application objects. I've seen often where something is stored in either the Session or Application object only to be used again and again.