Question

I have what amounts to a multi-dimensional array.

int[][][] MyValues; 

What I want is to access the indexes via a strongly typed equivelent, such as an enumeration. I’m aware that you can get the enumeration values from the Enum type, but it’s a bit long winded for my tastes.

I’d rather have a way to Strongly type the indexes.

For example:

int CarNumber = MyValues[Racetrack.Daytona][Race.Daytona500][Driver.JGordon]; 

This would, by virtue of it being enum-like, prevent any out of bounds exceptions from being thrown, plus it gives all the indexes a nice human readable meaning.

I’ve implemented this using a dictionary approach, but it seems kind of heavy handed:

Dictionary<Racetrack,Dictionary<Race,<Dictionary<Driver,int>>> =     new Dictionary<Racetrack,Dictionary<Race,<Dictionary<Driver,int>>>(); 

which I can then access via enums, but I don’t really like this approach. It seems ‘ugly’.

I’m looking for some alternate methods to represent what is essentially a multi-dimensional array while using human readable indexers, while maintaining type safety (can’t accidently use a Driver for a Race, for instance, so simply using consts is not a good approach).

Any suggestions?

This will be a compile time array (example above is not real, just an illustration) so I don’t have to worry about inserts or deletes or other manipulations of the array. It will stay immutable, both in values, size and layout.

Using a static class with const values is not a good approach either, since it doesn’t enforce that only the set of values defined can be passed as indexers.

Answer 1

It sounds to me that you want to use indexers rather than an array. Assuming the following enums (Formula 1 based!):

public enum Track {     Spielberg,     Adelaide,     Casablanca,     Liverpool,     Melbourne,     Berlin,     Sakhir, }  public enum Constructor {     BMW,     Ferrari,     McLaren,     Toyota,     Williams }  public enum Driver {     Hamilton,     Kovalainen,     Raikkonen,     Nakajima,     Glock } 

the basic structure is as follows:

public class Race {     int Year { get; set; }     Track Track { get; set; }     Driver[] Placings { get; set; }     public int this[Driver driver] { } // placing by driver }  public class Results {     YearResults this[int index] { }     DriverResults this[Driver index] { }     TrackResults this[Track index] { }     ConstructorResults this[Constructor index] { } }  public class YearResults {     YearDriverResults this[Driver index] { } } 

This of course is a partial implementation but you can do some pretty cool things with indexers this way. Like you can access your information with any combination of values in any order (assuming you set up all the intermediate classes).

Its wordier than a multidimensional array or a tuple-keyed Dictionary but I think will give you far more elegant code.