How to use one method to display random dice to 12 picture boxes?

[Chrono Dark]

I have 12 picture boxes and I am calling a method called ShowDice() to show the image of the dice.

Here is what I am doing exactly:

- Generate a random number for 12 integers
- Use a for loop to count which dice is being shown:

for (int count = 1; count < 13; count++)
{
  ShowDice(diceNum, count)
}
 

So, diceNum is a random number ranging from 1 to 6 because dices only have values from 1 to 6. I am displaying 12 dices hence count < 13 because count starts at 1.

In the ShowDice method, I want to be able to display the dice to the appropriate picture box without having to repeat the same lines of code. So here is what I'm doing:

ShowDice(int diceNum, int count)
{
if (count == 1) //First Dice Picture Box
  switch (diceNum)
    {
       case 1:
         picDice1.Image = Dice_Roll.Properties.Resources.Dice1; //Displays the image of a dice of value that is 1
         break;
       case 2:
         etc..
    }
}
 

As you can see, if I repeat the same lines of code, but change the picture box from picDice1 to picDice2, the code will be very inefficient. What is a more efficient way of doing this?

[Joseph Martell]

There are a couple of different ways you could structure this code.

I think that the path I would personally take is to create an array or collection of the picture boxes and an array or collection of the six dice images. Then your assignment basically becomes like this:

picBox[count] = diceImage[diceNum];

The price you pay is the overhead of the collection objects, but the structure of the program and maintainability of the code would make this the better option as far as I'm concerned. Plus, if you get all nerdy and want to have a twenty sided die, you don't have to modify this code :).

[Chrono Dark]

How would I go about to create an array of picture boxes and assign each picture box to an existing picture box on the form. Like:

picDice1.Image = picBox[1].Image;

[HaLo2FrEeEk]

using System.Collections.Generic;
 
List<PictureBox> pictBoxes;
 
private void Form1_Load(object sender, EventArgs e)
{
    pictBoxes = this.Controls.OfType<PictureBox>().ToList<PictureBox>();
}

pictBoxes now contains a dynamically-generated array of all the pictureboxes you have contained in the form. Hopefully order isn't an issue because I got some weird results:

The one labeled 0 is actually named pictureBox10, and the one labeled 1 is actually named pictureBox5. Dunno how to fix that other than maybe naming your picture boxes with standard names and incrementing numbers, like box0, box1, box2, box3. With this, you could access them like this (in a loop):

PictureBox pictBox = (PictureBox)this.Controls["box" + i];
pictBox.image = (your image);

[Joseph Martell]

HaLo2FrEeEk has a good start to a solution. You can do something similar for the 12 dice images.

using System.Collections.Generic;
 
List<PictureBox> pictBoxes;
List<Image> diceImages;
 
private void Form1_Load(object sender, EventArgs e)
{
    pictBoxes = this.Controls.OfType<PictureBox>().ToList<PictureBox>();
 
    diceImages.Add(Dice_Roll.Properties.Resources.Dice1);
    diceImages.Add(Dice_Roll.Properties.Resources.Dice2);
    //etc.
}
 
 

Now you have to collections that contain your picture boxes and the dice images. All you have to do is set your picture box image to the correct image and you're done.

ShowDice(int diceNum, int count)
{
    pictBoxes[diceNum].Image = diceImages[count];
}

As HaLo2FrEeEk noted, your collection index (diceNum) probably won't line up correctly with the actual picture boxes, but that doesn't necessarily matter if all you are trying to do is show the results of rolling 12 dice.

[GaryTexmo]

It looks like you guys have a good handle on working towards a solution so I'll leave it to you; however, I'm going to randomly jump in here with a question!

What is the difference between these two lines?

pictBoxes = new List<PictureBox>();
pictBoxes = this.Controls.OfType<PictureBox>().ToList<PictureBox>();

The first line is the instantiation I'm used to... I'm guessing that second line does the same thing? Why is it written like that and what does it do? Is there any advantage to the way you wrote it?

Thanks!

[Joseph Martell]

I wasn't familiar with that particular bit of code either.

The method OfType is called on the Controls collection. It is a LINQ extension to IEnumerable that returns elements of the collection that are of the specified type.

The second line only works if this refers to a form class (or some other class that contains a Controls collection). It returns an instantiated and populated list collection that contains references to all of the controls on the form of the PictureBox type.

[HaLo2FrEeEk]

That's why I only declared the pictBoxes variable and didn't instantiate it. Since the OfType<T>() method returns a populated IEnumerable (converted to list using ToList<T>()), you just need to have the variable declared.

I also messed around and figured something out that I'd mentioned in my original post. I had all my picture boxes named "pictureBox##", so I was able to do this (we'll assume that there are 12 picture boxes, like in the OP):

for(int i = 1; i <= 12; i++) {
  PictureBox pictBox = (PictureBox)this.Controls["pictureBox" + i];
  pictBox.Image = blahblah;
  }

You can see where that's going. It's a faster way of doing it, I think, because you're not creating a list of controls. Also, it keeps things in order.

[Joseph Martell]

HaLo2FrEeEk has a good way to do it without creating a separate data structure. The down side to that method is that every time the picture needs to be set the picture box must be found again. A collection does use more memory, but saves time during run-time by not having to search the entire controls collection for the right picture box. The best solution depends on whether you are optimizing for time or space.

Incidentally, whenever using a List or other collection type and you know the number of elements you have beforehand, you can usually make its use slightly more efficient by declaring how many elements it will have up front:

pictBoxes = new List<PictureBox>(12);

This way the collection is created with 12 spots from the start. This saves time and resources by a) not having to expand the collection's internal memory allotment and b) unused spots are not reserved.

The List class uses an internal array to store its members. As more space is needed the array size is doubled. What is actually happening is a new array is created and the original members copied from the old array to the new one. For our example of a 12 element list the internal array would go from 1, to 2, to 4, to 8, to 16. That is 4 different times a new array must be created and the original values copied over. It also leaves 4 unused elements. By declaring the size at the start, the internal array structure is created with 12 elements. No resizing is necessary and all of the elements will be used.

I think its important to remember that all of the solutions that we are discussing are just shifting the load from one point to another. If you load all of your picture boxes into a collection, by whatever means you choose, then you are emphasizing run-time speed. Referencing the individual picture boxes will be fastest because you have done all of your filtering and searching up front but your memory foot-print and form initialization will be slower. If you find the picture box every time you want to set the image (HaLo2FrEeEk's previous post) your form initialization will be faster and your form slightly smaller because you aren't creating any collections. The individual set operation will be slightly slower because you have to re-find your picture boxes every time.

[HaLo2FrEeEk]

Either way, I think if the main point of your program is to just roll some dice into 12 picture boxes, overhead really won't be much of a concern. Do whatever is easiest for you, but you now have 2 different, valid ways of achieving what you wanted.

[GaryTexmo]

Ah, thanks for explaining that. I see it now... your form had a bunch of picture boxes on it already and that just picked them out.

Also, for the record, the performance on a List is pretty quick. When I was doing performance tests on my QuadTree, I threw 100 000 objects into a list in a for loop and my program loaded up in one second. I don't disagree with your base argument, there is indeed some overhead, but I don't believe it's a big deal in this case.

[Joseph Martell]

@Gary
I agree, Lists are pretty quick in my experience too. It seems like any time some one uses the word "efficient" in a post it tends to spawn a whole slew of discussions about the intricacies of code structure.

I also think that you are correct: The solutions posted here are more than adequate for the problem in the OP.

[GaryTexmo]

It seems like any time some one uses the word "efficient" in a post it tends to spawn a whole slew of discussions about the intricacies of code structure.

Haha that made me chuckle, too true :D People need to be careful throwing that word about!

Speaking of efficiency, in regards to my earlier post, is there any difference in efficiency between using the ToList method of getting all the PictureBox controls on a form over just looping through this.Controls? This may be one of those things I need to look into...