Question: I am trying to build a simple graphics application in WPF C#. The purpose is to draw 10000\*10000 rectangles of size 4 pixels each.

I have modified the OnRender method of the canvas to draw the rectangles. Drawings are performed for smaller number of rectangles (say 50\*50 or 100\*100 rectangles of 4 pixel each) but it is slowing down as I am increasing the no. of rectangles. 

Following is my code:

```
  protected override void OnRender(DrawingContext dc)
    {
        base.OnRender(dc);

        FillCells(dc);

        if (_ShowGrids)
        {
            DrawGrid(dc); // draw grid lines
        }
    }
 void FillCells(DrawingContext dc)
    {

        int cellSize=4;

        for (int i = 0; i < MaxRow; i++)
        {
            for (int j = 0; j < MaxColumn; j++)
            {
                dc.DrawRectangle(GetRectBrush(i,j), GetRectPen(i,j), new Rect(j * cellSize , i * cellSize , cellSize - 1, cellSize - 1));

            }
        }
    }

```

The above code takes more than a minute to draw 1000\*1000 rectangles.

Is there any method to make this process faster? Is there any other thing I can use in place of this?

Thanks.

Answer: 
You should try StreamGeometry then.
<http://msdn.microsoft.com/en-us/library/system.windows.media.streamgeometry.aspx>

> 
> For complex geometries that don’t need
>  to be modified after they are created,
>  you should consider using
>  StreamGeometry rather than
>  PathGeometry as a performance
>  optimization. StreamGeometry works
>  like PathGeometry, except that it can
>  only be filled via procedural code.
>  Its odd name refers to an
>  implementation detail: To use less
>  memory (and less of the CPU), its
>  PathFigures and PathSegments are
>  stored as a compact byte stream rather
>  than a graph of .NET objects.
> 
> 
> 

Quoted from Adam Nathan's book WPF Unleashed.
Perhaps try overlaying the canvas with a VisualBrush.  

To this visualBrush simply add the 4\*4 rectangle and have it repeat in a tile mode. Alternatively you could just add the lines to it so that it doesnt overlap the edges of the rectangle... your choice :)

Your problem is in the creation of the brush... A test run indicated that this code

```
int limit = 10000 * 10000;
var converter = new BrushConverter();
for (int i = 0; i < limit; i++)
{
    var blueBrush = converter.ConvertFromString("Blue") as Brush;
}

```

took 53 seconds to run. You are trying to create 100,000,000 brushes :) If it is patternable, use a patterned visual brush, if it is not patternable... perhapse look for another solution. The overhead of storing that many brushes in memory is in the Gigabytes