[.NET 2.0+] Rolling Dice

[jmcilhinney]

VB version here.

Quite a few people have asked how to "roll dice" for games. Here's the "proper" way. First you define a Die class to represent a die.

public class Die
{
    private static Random faceSelector = new Random();
 
    private int _faceCount;
    private int _value;
 
    public int FaceCount
    {
        get
        {
            return this._faceCount;
        }
        set
        {
            this._faceCount = value;
        }
    }
 
    public int Value
    {
        get
        {
            return this._value;
        }
    }
 
    public Die(int faceCount)
    {
        if (faceCount <= 0)
        {
            throw new ArgumentOutOfRangeException("faceCount", "Dice must have one or more faces.");
        }
 
        this._faceCount = faceCount;
    }
 
    public int Roll()
    {
        this._value = faceSelector.Next(1, this.FaceCount + 1);
        return this.Value;
    }
}

Note that the Die class has a static variable of type Random. This means that there is one and only one Random object for the class. This same object is used to generate random sides for each and every instance of the class.

The Roll method generates the random number based on the number of faces the current die has. It returns this value and it is also available via the Value property thereafter.

Many games use multiple dice though, so it's appropriate to define a class that represents multiple Die objects.

(Note that this code snippet is labelled as VB.NET code but it is obvioulsy C#. It's just that the C# and CSharp code parsers seem to butcher opening square brackets, which is a problem when indexing in C# code.)

public class DieCollection : System.Collections.ObjectModel.Collection<Die>
{
    public int[] RollAll()
    {
        int[] values = new int[this.Count];
 
        for (int index = 0; index < values.Length; index++)
        {
            values[index] = this.Items[index].Roll();
        }
 
        return values;
    }
}

There's very little code to write for this class because it inherits all the standard collection functionality for the generic Collection<Die> class. Inherited functionality includes an indexer of type Die and an Add method that takes a Die parameter.

Here's an example of using these classes. As is supposed to be the case in OOP, using the types is dead simple because all the work is done inside the classes themselves. You simply create a DieCollection, create and add as many Die objects as you need and call RollAll:

// Create the collection to store the dice.
DieCollection dice = new DieCollection();
 
// Add two six-sided dice.
dice.Add(new Die(6));
dice.Add(new Die(6));
 
// Roll all the dice.
int[] rolls = dice.RollAll();
 
// Display the values rolled.
foreach (int roll in rolls)
{
    MessageBox.Show(roll.ToString(), "You rolled a ...");
}

Obviously for a game you would assign your DieCollection to a member variable and then call it's RollAll method each time a player had to roll the dice. You would not create a new DieCollection and Die objects each time you wanted to roll.