List Graphics Rectangles Chess

I am trying to create a list of rectangles derived from a the Winform Client Rectangle. and then have them show on the screen in different colors. Much like a Chess board.

The list should be easily created, but I am just stuck. I can write this out line by line, but I don't want to define each rectangle 64 times. Plus I could shorten the code substantially.

This is what I have started, but I should be able to create an array/list of rectangles and create each one using a for loop.

Code:

---


      private void DrawMyDocument(Graphics graphics, Rectangle rectangle)
        {
             
            int xx = this.ClientRectangle.X;
            int yy = this.ClientRectangle.Y;
            int ww = this.ClientRectangle.Width / 8;
            int hh = this.ClientRectangle.Height/8;

            Rectangle One = new Rectangle(xx, yy, ww, hh);
            graphics.FillRectangle(Brushes.Red, One);

            Rectangle Two = new Rectangle(xx, yy + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, Two);

            Rectangle Three = new Rectangle(xx, Two.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, Three);

            Rectangle Four = new Rectangle(xx, Three.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, Four);

            Rectangle Five = new Rectangle(xx, Four.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, Five);

            Rectangle Six = new Rectangle(xx, Five.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, Six);

            Rectangle Seven = new Rectangle(xx, Six.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, Seven);

            Rectangle Eight = new Rectangle(xx, Seven.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, Eight);

            int xColumn2 = xx + 32;

            Rectangle OneOne = new Rectangle(xColumn2, yy, ww, hh);
            graphics.FillRectangle(Brushes.Gray, OneOne);

            Rectangle TwoTwo = new Rectangle(xColumn2, OneOne.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, TwoTwo);

            Rectangle ThreeThree = new Rectangle(xColumn2, Two.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, ThreeThree);

            Rectangle FourFour = new Rectangle(xColumn2, Three.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, FourFour);

            Rectangle FiveFive = new Rectangle(xColumn2, Four.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, FiveFive);

            Rectangle SixSix = new Rectangle(xColumn2, Five.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, SixSix);

            Rectangle SevenSeven = new Rectangle(xColumn2, Six.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Gray, SevenSeven);

            Rectangle EightEight = new Rectangle(xColumn2, Seven.Y + 32, ww, hh);
            graphics.FillRectangle(Brushes.Red, EightEight);

---

This code will create the start of a chess board, but There has got to be an easier way to do this using a for loop and list of rectangles.

This code generates two columns of rectangles of alternating colors. Just like a chess board, but needs to be drastically shortened.

The answer of course is loops!!

Code:

---

namespace painttest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            this.DoubleBuffered = true;
        }

        private void Form1_Paint(object sender, PaintEventArgs e)
        {
            bool should_be_red = true;

            int width = (int)Math.Ceiling((double)this.ClientRectangle.Width / 8);
            int height = (int)Math.Ceiling((double)this.ClientRectangle.Height / 8);

            for (int a = 0; a < 8; a++) // a = vertical position
            {
                for (int b = 0; b < 8; b++) // b = horizontal position
                {
                    using (SolidBrush sb = new SolidBrush(should_be_red ? Color.Red : Color.Gray))
                        e.Graphics.FillRectangle(sb, new Rectangle(b * width, a * height, width, height));

                    if ((b + 1) % 8 != 0) // starting next line so stagger the color
                        should_be_red = !should_be_red;
                }
            }
        }

        private void Form1_Resize(object sender, EventArgs e)
        {
            this.Invalidate();
        }
    }
}

---

2 loops to be precise. One to handle X position, the other for Y position. Pretty self explanatory however one point of interest was I had to add a condition as to whether to change the color bool, since the grid is 8 squares (even number) wide it meant that simply changing the color each time would not result in the checkered effect you were looking for.

You can remove the boolean and just use the sum of the indexes. If it's odd one color, even the other. Also no need to create a rectangle object as FillRectangle is overloaded to accept coordinates. So the loops become:

Code:

---

for (int a = 0; a < 8; a++) {
    for (int b = 0; b < 8; b++) {
        using (SolidBrush sb = new SolidBrush((a+b) % 2 == 0 ? Color.Red : Color.Gray)) {
            e.Graphics.FillRectangle(sb, b*width, a*height, width, height);
        }
    }
}

---

Saves you a variable, a class construction and a weird check if you are on the next iteration of a by checking the inner loop.

If you are calling that function in a tight loop there is no way the GC is going to clean up that fast. It will clean up just before your system runs out of memory but I bet if you watch task manager you will see your app chewing through memory. If you are going to create that many small objects at runtime in a tight loop you might consider using weak references and/or value types.

Building on what VirtualAce was saying, you're probably better off moving the brushes outside the loops:

Code:

---

Brush red = new SolidBrush(Color.Red);
Brush gray = new SolidBrush(Color.Gray);
Brush[] brushes = new Brush[] { red, gray };

for (int a = 0; a < 8; a++) {
    for (int b = 0; b < 8; b++) {
        e.Graphics.FillRectangle(brushes[(a + b) % 2], b*width, a*height, width, height);
    }
}

red.Dispose();
gray.Dispose();

---

Quote:

---

Originally Posted by VirtualAce

If you are calling that function in a tight loop there is no way the GC is going to clean up that fast. It will clean up just before your system runs out of memory but I bet if you watch task manager you will see your app chewing through memory. If you are going to create that many small objects at runtime in a tight loop you might consider using weak references and/or value types.

---

It's only 64 brushes. It won't eat up that much memory. But yes, I'd move them out of the loops anyway.

I was referring to the rectangles or pretty much anything you new up repeatedly inside of a tight loop. The C# GC is extremely lazy by necessity. According to a blog by a developer who worked on the GC it should clean up gen 0, 1 and 2 objects at 256Kb, 1Mb?, and 2Mb. I'm not sure if the 1Mb value is correct for gen 1 objects. It also stated that the GC is free to alter these values based on the needs of your specific program. I've personally witnessed one of the apps I work on eat memory until the breaking point and then the GC runs and cleans it up.

Here is some good information on the GC:
http://www.csharphelp.com/2006/08/garbage-collection/