What collection could I use when arrays may seem out of the question? Does the data need to be immutable and can I have a position?

Not long ago I posted a question about a design decision of my F1 game. One person replying noted my use of Dictionary<int, Driver> and asked what it was for. I use this collection for having a finish position and a Driver at that finish position. He suggested I should use arrays, because arrays have a index that could be used as position.

Having not worked on the game for a while, I picked up where I left and started to think about replacing my Dictionaries with arrays. I started googling arrays and one th开发者_如何学JAVAing let to another and I came across posts here on SO, some blogs (http://blogs.msdn.com/b/ericlippert/archive/2008/09/22/arrays-considered-somewhat-harmful.aspx) about not to use arrays (or, actually, in some very specific cases).

My questions are these:

When data comes from the database, and is only used for comparing and looking up data, what is best used? I have a

• prediction, which contains drivers and a predicted finish position
• result, which also contains drivers and a finish position
• points, which contains the points for every correctly guessed Driver at a certain finish position

The data comes from the database, and shouldn't be edited, added to, or removed.

The data is only used by my code only, but does that mean that I can safely use a collection, or should I really be on the safe side anyway and make sure that what comes back from the database is an immutable collection?

And the second question has to do with the positions. What collection can I use so that I can have finish positions, without maybe the overhead of using a Dictionary?

var prediction = new Driver[3];
            prediction[0] = new Driver(10, "Michael Schumacher");
            prediction[1] = new Driver(7, "Felipe Massa");
            prediction[2] = new Driver(8, "Jensen Button");

            var results = new Driver[3];
            results[0] = new Driver(10, "Michael Schumacher");
            results[1] = new Driver(8, "Jensen Button");
            results[2] = new Driver(9, "Fernando Alonso");

            int[] points = { 25, 18, 15, 12, 10 };

            for (int i = 0; i < prediction.Length; i++)
            {
                if (prediction[i].Equals(results[i]))
                {
                    result += points[i];
                }
            }

It depends on if you want to check by position (e.g. "Who finished third?") or by driver (e.g. "What position did Wilson finish at?"). It also depends on whether you care that much about performance in a scenario which sounds like it won't really make a difference to your application as a whole.

Generally a dictionary would be good for lookups. However, if the range of the keys is known, small, and continuous ("race position" fits all three criteria) then a dictionary does not offer anything more than an array (and has more overhead). So if you want to query by position, use an array because it's the simplest tool that fits the job description.

If you want to query by driver, then first you have to answer the question "how exactly is the identity of a Driver defined?" (an answer might be "each driver is uniquely identified by their last name, first name and date of birth").

You could then make the Driver class implement IEquatable<Driver> using these criteria and put it in a Dictionary<Driver, Positions> where I am using the class below to avoid multiple dictionaries.

class Positions
{
    public int Predicted { get; set; }
    public int Actual { get; set; }
}

However, you have to ask yourself if going to all this trouble makes any sense vs. having an array of e.g. Tuple<Driver, Positions> and looping over the array to find the driver you want each time. This may sound inefficient in theory, but if you have just 20 drivers it will actually be much faster than a dictionary.

Finally, I don't see any need in going out of your way to mark these data structures as immutable and/or enforce immutability. Since your application works in read-only mode, and it does not include code that attempts to push data back to the database, I think it's pretty clear that it's meaningless to go around modifying the data in code.

I use this collection for having a finish position and a Driver at that finish position. He suggested I should use arrays, because arrays have a index that could be used as position.

And for that case, he's pretty much right. An array is really the best way to do that because you know how many positions there are and the index acts as the position. It's going to use the least memory and get the most performance, and it's simple. I mean you could also use a List, which for this purpose is really just a fancier array.

There might be cases where arrays are "harmful", but there's also a case to be made that you should stick to simple tools when that's all you need to do the job. Arrays are simple, easily understood, and fast. When all you need is a Driver and a finish position, an Array is a perfect tool.

When data comes from the database, and is only used for comparing and looking up data, what is best used? I have a

prediction, which contains drivers and a predicted finish position result, which also contains drivers and a finish position points, which contains the points for every correctly guessed Driver at a certain finish position

That depends. Do you want one collection that stores all of that information? If you do, Jon's suggestion of a Dictionary is probably your best bet. I suspect that's going to be a good way to go because it's got everything you need in a single place that you can work with.

If instead you want a different collection for each one, then for results and predicted results you can just use an Array for each one (as the data is perfectly suited for it). For points it's a bit different because the points aren't likely to be a perfectly set of index values and you could have two results with the same score.