Calvin Hsia's WebLog : CSharp

You can develop code faster

Calvin_Hsia — Thu, 17 Dec 2009 03:29:00 GMT

You can make your Visual Studio experience faster.

Often you write some code in Visual Studio, hit F5 to test the code. Repeat.

Here’s a simple way to make this experience faster. (works with managed, native, mixed code).

When a process is started from the debugger, it is started with some special DEBUG flags which tell the entire process to use the Debug heap, which is quite a bit slower than the non-Debug heap.

If you start the process without the debugger (Ctrl-F5 from VS or from Explorer, Start Menu, etc), then Attach the debugger after the process has started, then those flags are not present.

Here’s proof.

Start Visual Studio

We’ll need to set symbols once:

Tools->Options->Debugging->Symbols->Symbol File Locations. Add a single entry:

http://msdl.microsoft.com/download/symbols

Click the checkbox: Search the above locations only when symbols are loaded manually (to make symbol loads faster)

Cache the symbols locally (type in something like C:\Symbols)

Choose File->New Project->VB console application. (similarly with C#)

On the toolbar, make sure to select Release build (so you don’t think this is just with Debug bits)

Enable Project->Properties->Debug->Enable Unmanaged Code Debugging.

Add a single line of code to your fancy program:

MsgBox("hi")

Or in C# if you want the VB MsgBox function: add a references to Microsoft.VisualBasic.dll

Microsoft.VisualBasic.Interaction.MsgBox("hi",Microsoft.VisualBasic.MsgBoxStyle.OkOnly,"title");

Or you can add a reference to System.Windows.Forms.dll (both C# and VB)

System.Windows.Forms.MessageBox.Show("hi");

Hit F5 to start the process under the debugger and see the MsgBox.

Without terminating your fancy program, switch back to VS and choose Debug->Windows->Modules

Right click on NTDLL.dll, load symbols. Hit Ctrl-B to bring up the Breakpoint dialog, paste in “_RtlDebugFreeHeap@12” and make sure the Language says C++.

The breakpoint dialog (Debug->Windows->Breakpoints) will show the Breakpoint with a solid red dot when the breakpoint is resolved. This Breakpoint is in the debug heap code.

Now dismiss the MsgBox

The debugger breaks. Here’s a sample call stack:

ntdll.dll!_RtlpInsertFreeBlock@12() + 0x3299 bytes

ntdll.dll!_RtlpDeCommitFreeBlock@16() + 0x41 bytes

ntdll.dll!@RtlpFreeHeap@16() + 0x2bb9 bytes

ntdll.dll!_RtlFreeHeap@12() + 0x2e49 bytes

ntdll.dll!_RtlDebugFreeHeap@12() + 0x1f8 bytes

ntdll.dll!@RtlpFreeHeap@16() + 0x13cdd bytes

> ntdll.dll!_RtlFreeHeap@12() + 0x2e49 bytes

kernel32.dll!_HeapFree@12() + 0x14 bytes

Now stop debugging, launch the process again, this time without the debugger (Ctrl-F5).

With the MsgBox showing, attach the debugger (Tools->Attach to Process->navigate to ConsoleApplication) in Native mode: select Native in Attach To: Select Code Type.

Repeat loading symbols, and setting the breakpoint. Now when you dismiss the MsgBox, the breakpoint doesn’t get hit because the Debug heap isn’t used.

So, how do I make my experience faster? One way is to hit Ctrl-F5, then Attach (if your fingers are fast).

However, there’s a simpler way:

Control->Panel->System Properties->Advanced System Settings->Environment Variables->System Variables.

Add a new Variable called “_NO_DEBUG_HEAP” with a value of “1”

Now repeat the steps above and you’ll not hit that breakpoint.

Beware of taking performance measurements when you start the process under the debugger. For example, I sometimes use OutputDebugString to output some times of some crude measurements. When running under the debugger, the performance of CPU bound code that doesn’t load modules or have breakpoints is pretty much the same as without a debugger, *IF* you don’t use the debug heap!

Of course, if you’re debugging heap problems, you may not want to set the environment variable.

See also:

Dynamically attaching a debugger

Its easy to create a graph of memory use in Excel

Calvin_Hsia — Tue, 29 Sep 2009 05:40:00 GMT

In this post Examine .Net Memory Leaks I showed how to find a .Net managed memory leak.

Now let’s create a graph of memory and resource use over time.

Start Visual Studio 2008, File->New->Visual Basic (or C#) Windows, WPF application. Dbl click the WPF form to get to the Xaml.cs or Xaml.vb file

Paste in the appropriate version from below.

Hit F5 to run the code for about 2 minutes. Then Excel starts (if you have Excel installed)

When Excel starts, type these keystrokes exactly (we can automate Excel with a macro or use Automation, but that’s another story)

Right Arrow (to skip the iteration column)

Shift-Ctrl-End (to select the entire table)

Alt (to activate the menu shortcuts

N (to choose Insert)

N (to choose Line Graph)

Enter (to choose the first kind of line graph

See how easy it is to create a picture?

Try experimenting with the garbage collection and how it behaves. Try commenting out the UnSubscribe call.

Open the log.csv file from within VS. As the file changes, VS will automatically detect and reload the text, so you can watch as it runs.

Process Explorer and Process Monitor can help you understand a program

Calvin_Hsia — Wed, 29 Jul 2009 08:37:00 GMT

Process Explorer and Process Monitor are must-have free utilities that you can download from http://technet.microsoft.com/en-us/sysinternals/bb795533.aspx

For example you can use ProcExp to examine a particular behavior of Visual Studio.

Start Visual Studio (any version). I was using VS 2008.

Start Process Explorer (as Administrator)

Click on the Devenv.exe process (the main VS process) to select it.

Choose View->Show Lower Pane and View->Lower Pane View->Handles

In VS, try creating a new VB or C# console application.

Now ProcExp shows a list of handles opened by this particular process. A handle can be a file, an Event, a process, a thread, a registry key, etc.

Did you ever get a permission denied error message because the file is “opened by another process” but you didn’t know which process?

If you click on the Name column, the list of handles will be sorted by name.

I chose File->Save As to save the whole shebang to a file. Here’s a portion, showing the handle type (File), the file name, and the handle value:

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG\enterprisesec.config.cch 0x264

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\CONFIG\security.config.cch 0x260

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\Microsoft.VisualBasic.xml 0x14D0

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\mscorlib.xml 0x8C0

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\System.Data.xml 0x89C

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\System.xml 0x13F4

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\Microsoft.CSharp.targets 0x7F4

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\Microsoft.VisualBasic.dll 0x88C

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\Microsoft.VisualBasic.targets 0x7F8

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\Microsoft.WinFX.targets 0x7E8

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\mscorlib.dll 0x86C

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Data.dll 0x13D4

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Deployment.dll 0x924

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll 0x174C

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.XML.dll 0x15B8

File C:\Windows\Microsoft.NET\Framework\v3.5\Microsoft.CompactFramework.CSharp.targets 0x804

File C:\Windows\Microsoft.NET\Framework\v3.5\Microsoft.CompactFramework.VisualBasic.targets 0x808

File C:\Windows\Microsoft.NET\Framework\v3.5\Microsoft.CSharp.targets 0x7EC

File C:\Windows\Microsoft.NET\Framework\v3.5\Microsoft.VisualBasic.targets 0x7F0

File C:\Windows\Microsoft.NET\Framework\v3.5\Microsoft.WinFx.targets 0x80C

File C:\Windows\Microsoft.NET\Framework\v3.5\SqlServer.targets 0x7FC

You can see this portion by scrolling the view to some framework assemblies.

Now play around with Visual Studio to see what files in this folder get opened and closed. The newly opened ones show in green for a couple seconds, while ones that close flash red, then disappear.

In particular, try creating a new VB Console application to see which assemblies get loaded. Close the solution, reopen it a few times. You’ll see these files get opened/closed:

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Data.dll 0x13D4

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Deployment.dll 0x924

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll 0x174C

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.XML.dll 0x15B8

Now type the letter “C” within Sub Main and you’ll see these XML files get opened:

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\Microsoft.VisualBasic.xml 0x14D0

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\mscorlib.xml 0x8C0

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\System.Data.xml 0x89C

File C:\Windows\Microsoft.NET\Framework\v2.0.50727\en\System.xml 0x13F4

They will remain opened until you close the solution.

Now try typing the letter “C” before the Sub Main, but after the Module Module1 line.

No files get opened! Why?

Why does where you type make a difference? What are these files used for?

Here’s an excerpt. Does it provide any clues?

<summary>Provides an object representation of a uniform resource identifier (URI) and easy access to the parts of the URI.</summary>

</member>

<summary>Initializes a new instance of the <see cref="T:System.Uri" /> class with the specified URI.</summary>

<paramref name="uriString" /> is empty.-or- The scheme specified in <paramref name="uriString" /> is not correctly formed. See <see cref="M:System.Uri.CheckSchemeName(System.String)" />.-or- <paramref name="uriString" /> contains too many slashes.-or- The password specified in <paramref name="uriString" /> is not valid.-or- The host name specified in <paramref name="uriString" /> is not valid.-or- The file name specified in <paramref name="uriString" /> is not valid. -or- The user name specified in <paramref name="uriString" /> is not valid.-or- The host or authority name specified in <paramref name="uriString" /> cannot be terminated by backslashes.-or- The port number specified in <paramref name="uriString" /> is not valid or cannot be parsed.-or- The length of <paramref name="uriString" /> exceeds 65534 characters.-or- The length of the scheme specified in <paramref name="uriString" /> exceeds 1023 characters.-or- There is an invalid character sequence in <paramref name="uriString" />.-or- The MS-DOS path specified in <paramref name="uriString" /> must start with c:\\.</exception>

</member>

Now try typing this very slowly and watch the Proc Exp Handles list:

Dim x = New Uri(

(In C#, try “Uri” )

You’ll get Intellisense and the parameter help for the constructor of the Uri. The strings for that help come from this XML file.

The “filterPriority” element indicates whether the item shows up on the Common or the All tab of the Intellisense list (VB only).

(BTW, did you know you can switch between the common and the All tabs Alt-Comma and Alt-Period?)

If you like, you can customize the XML of the framework assemblies. Edit the text and save it.

You can even author your own:

Try this: before Sub Main type 3 apostrophes. (for C#, try 3 slashes) This will appear:

''' <summary>

'''

''' </summary>

''' <remarks></remarks>

Try hitting Enter then “<” after the </summary> tag. Intellisense will prompt you for other XML Doc fields, such as Example, Remarks, See Also, Param.

You can fill out the “XmlDoc” information. On Project->Properties->Compile there’s a checkbox “Generate XML Documentation file” (see How to: Generate XML Documentation for a Project )

Now when your assemblies get referenced, you can provide the strings for intellisense, parameter help, info tips to show!

The “en” in the file path name indicates “English” version of the docs. Other languages will work too, if you have them installed on your machine.

The letter “C” in the VB sample above triggers intellisense. If you’re not within a method, then only a few keywords are allowed that start with “C”, like Class, Const, or Custom. Thus the XML doc files aren’t necessary.

If you’re within the context of a method, you can potentially type the name of a shared method, for example: Console.WriteLine, so the XML files are loaded.

Try experimenting with other project types, such as C#, a Web app, or even start Visual FoxPro to see what files get opened under varying conditions. Try adding references to other assemblies.

We’ll explore more of ProcExp and ProcMon in future posts.

Stack overflow, expand your stack? Change your algorithm!

Calvin_Hsia — Fri, 29 May 2009 03:15:00 GMT

In the last post, Area fill algorithm: crayons and coloring book, I showed a program that emulates a kid drawing in a coloring book.

However, the algorithm wasn’t very efficient, and would explode even if you had a simple drawing: it was using the stack to store where to go.

The heart of the routine:

void AreaFill(Point ptcell)

{

if (ptcell.X >= 0 && ptcell.X < m_numCells.Width)

{

if (ptcell.Y >= 0 && ptcell.Y < m_numCells.Height)

{

// System.Threading.Thread.Sleep(100);

if (DrawACell(ptcell, m_brushFill))

{

m_oColor = Color.FromArgb((int)(((((uint)m_oColor.ToArgb() & 0xffffff) + 140) & 0xffffff) | 0xff000000));

m_brushFill = new SolidBrush(m_oColor);

AreaFill(new Point(ptcell.X - 1, ptcell.Y));

AreaFill(new Point(ptcell.X + 1, ptcell.Y));

AreaFill(new Point(ptcell.X, ptcell.Y + 1));

AreaFill(new Point(ptcell.X, ptcell.Y - 1));

}

It just checks boundaries, Draws the current point, then calls itself to draw the points North, South, East and West. Doing this for thousands of pixels eats up the current thread’s stack very fast.

One way to fix this is to expand the stack size.

You can examine the default stack size of an executable (EXE or DLL) by opening a Visual Studio command prompt (Start->Programs->VS2008->VSToos->VSCommand prompt), then type

link /dump /headers d:\dev\cs\Fill\bin\Debug\Fill.exe

Microsoft (R) COFF/PE Dumper Version 9.00.21022.08

Dump of file Fill.exe

PE signature found

File Type: EXECUTABLE IMAGE

FILE HEADER VALUES

14C machine (x86)

3 number of sections

4A1ECBC2 time date stamp Thu May 28 10:37:06 2009

0 file pointer to symbol table

0 number of symbols

E0 size of optional header

10E characteristics

Executable

Line numbers stripped

Symbols stripped

32 bit word machine

OPTIONAL HEADER VALUES

10B magic # (PE32)

8.00 linker version

2000 size of code

800 size of initialized data

0 size of uninitialized data

3E7E entry point (00403E7E)

2000 base of code

4000 base of data

400000 image base (00400000 to 00407FFF)

2000 section alignment

200 file alignment

4.00 operating system version

0.00 image version

4.00 subsystem version

0 Win32 version

8000 size of image

200 size of headers

0 checksum

2 subsystem (Windows GUI)

540 DLL characteristics

Dynamic base

NX compatible

No structured exception handler

100000 size of stack reserve

1000 size of stack commit

100000 size of heap reserve

1000 size of heap commit

This is a little misleading, because the default stack size is 100000 Hex, which is 1,048,576, or about 1 Megabyte.

You can change the stack size using Editbin.exe

D:\dev\cs\Fill\bin\Debug>link /dump /headers Fill.exe | find "stack"

100000 size of stack reserve

1000 size of stack commit

D:\dev\cs\Fill\bin\Debug>editbin /stack:10000,1000 Fill.exe

Microsoft (R) COFF/PE Editor Version 9.00.21022.08

D:\dev\cs\Fill\bin\Debug>link /dump /headers Fill.exe | find "stack"

2710 size of stack reserve

3E8 size of stack commit

A better way to fix this is to use heap memory , rather than the stack:

//* More efficient algorithm: don't use the stack to store state

void AreaFill(Point ptcell)

{

Queue<Point> queueCells = new Queue<Point>();

queueCells.Enqueue(ptcell);

while (queueCells.Count > 0)

{

ptcell = queueCells.Dequeue();

if (ptcell.X >= 0 && ptcell.X < m_numCells.Width)

{

if (ptcell.Y >= 0 && ptcell.Y < m_numCells.Height)

{

// System.Threading.Thread.Sleep(100);

if (DrawACell(ptcell, m_brushFill))

{

m_oColor = Color.FromArgb((int)(((((uint)m_oColor.ToArgb() & 0xffffff) + 140) & 0xffffff) | 0xff000000));

m_brushFill = new SolidBrush(m_oColor);

queueCells.Enqueue(new Point(ptcell.X - 1, ptcell.Y));

queueCells.Enqueue(new Point(ptcell.X + 1, ptcell.Y));

queueCells.Enqueue(new Point(ptcell.X, ptcell.Y + 1));

queueCells.Enqueue(new Point(ptcell.X, ptcell.Y - 1));

}

This solution is almost the same as the first: however, instead of recurring to go North, etc, the routine just puts the points to work on into a queue.

The VB solution is analogous:

Sub AreaFill(ByVal ptcell As Point)

Dim queueCells = New Queue(Of Point)

queueCells.Enqueue(ptcell)

While queueCells.Count > 0

ptcell = queueCells.Dequeue()

If (ptcell.X >= 0 And ptcell.X < m_numCells.Width) Then

If (ptcell.Y >= 0 And ptcell.Y < m_numCells.Height) Then

' System.Threading.Thread.Sleep(100);

If (DrawACell(ptcell, m_brushFill)) Then

Me.m_oColor = Color.FromArgb((((Me.m_oColor.ToArgb And &HFFFFFF) + 140) And &HFFFFFF) Or &HFF000000)

' m_oColor = Color.FromArgb((int)(((((uint)m_oColor.ToArgb() & 0xffffff) + 140) & 0xffffff) | 0xff000000));

m_brushFill = New SolidBrush(m_oColor)

queueCells.Enqueue(New Point(ptcell.X - 1, ptcell.Y))

queueCells.Enqueue(New Point(ptcell.X + 1, ptcell.Y))

queueCells.Enqueue(New Point(ptcell.X, ptcell.Y + 1))

queueCells.Enqueue(New Point(ptcell.X, ptcell.Y - 1))

End If

End While

End Sub

See also:

Tail Recursion

Cartoon animation program

Comment/Uncomment code to switch versions quickly without using macros

http://msdn.microsoft.com/en-us/library/8cxs58a6.aspx

http://bytes.com/groups/net-c/229335-stack-size

Area fill algorithm: crayons and coloring book

Calvin_Hsia — Thu, 30 Apr 2009 20:40:00 GMT

Kids know how to use crayons and a coloring book. How do you write such a program?

In my last post (Which pixels do you turn on when you draw a line?) I showed how to draw a line. Now suppose you have some lines or shapes already drawn. How would you write code to fill in an area bounded by the drawn pixels?

IOW, imagine you’ve drawn a circle. You want to fill the circle with a color. Right click inside. What code should run? What if the figure were more complex, like a large block “W” or a curled up snake.

More formally: Given an array of pixels that represents the outline of a shape, and a point’s x,y coordinate within that shape, how would you area fill that shape?

Perhaps you could write some code that will check all pixels to the East, North, West, South until it reached a pixel that was already painted. Then what?

What sort of algorithm and data structure would you use?

Below are C# and VB versions of a simple implementation that isn’t very efficient, but is quite simple.

The code is identical to the last post (the drawing parts) except for the areas delimited by “AREA”. This makes it easier for you to cut/paste the code.

Start Visual Studio 2008

Choose File->New->Project->C# or VB->Windows Forms Application.

Choose View->Code

Paste in the VB or C# version of the code below, hit F5 to run it. Draw a shape, right click to fill.

How would you improve it? Why isn’t it efficient?

Try making the form bigger and paint more pixels. What happens?

Clue: look at the source code for MineSweeper that I wrote to take advantage of the (then) new feature Collections. It’s part of the Task Pane for Visual Foxpro 9.0

<C# Sample>

#define AREA

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace WindowsFormsApplication1

{

public partial class Form1 : System.Windows.Forms.Form

{

Size m_numCells = new Size(350, 200);// we'll use an array of Cells

Boolean[,] m_cells; // the array of cells: whether they've been drawn or not

Size m_cellSize = new Size(8, 8); // cell height & width

Size m_Offset = new Size(0, 0);

bool m_MouseDown = false;

Button btnErase;

Point? m_PtOld;

SolidBrush m_brushMouse = new SolidBrush(Color.Red);

SolidBrush m_brushGenerated = new SolidBrush(Color.Black);

delegate bool DrawCellDelegate(Point ptcell, Brush br);

Graphics m_oGraphics;

public Form1()

{

this.Load += new EventHandler(this.Loaded);

}

void Loaded(Object o, EventArgs e)

{

this.Width = 600;

this.Height = 400;

this.btnErase = new Button();

this.btnErase.Text = "&Erase";

this.btnErase.Click += new EventHandler(this.btnErase_Click);

this.Controls.Add(this.btnErase);

this.BackColor = Color.White;

btnErase_Click(null, null);

}

void btnErase_Click(object sender, System.EventArgs e)

{

m_oGraphics = Graphics.FromHwnd(this.Handle);

m_numCells.Width = this.Width / m_cellSize.Width;

m_numCells.Height = this.Height / m_cellSize.Height;

m_cells = new Boolean[m_numCells.Width, m_numCells.Height];

m_oGraphics.FillRectangle(Brushes.White, new Rectangle(0, 0, this.Width, this.Height));

}

Point PointToCell(Point p1)

{

Point ptcell = new Point(

(p1.X - m_Offset.Width) / m_cellSize.Width,

(p1.Y - m_Offset.Height) / m_cellSize.Height);

return ptcell;

}

protected override void OnMouseDown(MouseEventArgs e)

{

if (e.Button == MouseButtons.Left)

{

m_MouseDown = true;

m_PtOld = new Point(e.X, e.Y);

CheckMouseDown(e);

}

#if AREA

else

{

AreaFill(PointToCell(new Point(e.X, e.Y)));

}

#endif

}

protected override void OnMouseMove(MouseEventArgs e)

{

if (m_MouseDown)

{

CheckMouseDown(e);

}

protected override void OnMouseUp(MouseEventArgs e)

{

m_MouseDown = false;

}

void CheckMouseDown(MouseEventArgs e)

{

Point ptMouse = new Point(e.X, e.Y);

Point ptcell = PointToCell(ptMouse);

if (ptcell.X >= 0 && ptcell.X < m_numCells.Width &&

ptcell.Y >= 0 && ptcell.Y < m_numCells.Height)

{

DrawLineOfCells(PointToCell(m_PtOld.Value), ptcell, new DrawCellDelegate(DrawACell));

m_PtOld = ptMouse;

}

bool DrawACell(Point ptcell, Brush br)

{

bool fDidDraw = false;

if (!m_cells[ptcell.X, ptcell.Y]) // if not drawn already

{

m_cells[ptcell.X, ptcell.Y] = true;

//*

m_oGraphics.FillRectangle(br,

m_Offset.Width + ptcell.X * m_cellSize.Width,

m_Offset.Height + ptcell.Y * m_cellSize.Height,

m_cellSize.Width,

m_cellSize.Height);

/*/

g.DrawRectangle(new Pen(Color.Blue,1),

m_Offset.Width + ptcell.X * m_cellSize.Width,

m_Offset.Height + ptcell.Y * m_cellSize.Height,

m_cellSize.Width,

m_cellSize.Height);

//*/

fDidDraw = true;

}

return fDidDraw;

}

void DrawLineOfCells(Point p1, Point p2, DrawCellDelegate drawit)

{

// http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm

Brush br = m_brushMouse;

int x0 = p1.X;

int y0 = p1.Y;

int x1 = p2.X;

int y1 = p2.Y;

int x, cx, deltax, xstep,

y, cy, deltay, ystep,

error;

bool st;

// find largest delta for pixel steps

st = (Math.Abs(y1 - y0) > Math.Abs(x1 - x0));

// if deltay > deltax then swap x,y

if (st)

{

x0 ^= y0; y0 ^= x0; x0 ^= y0; // swap(x0, y0);

x1 ^= y1; y1 ^= x1; x1 ^= y1; // swap(x1, y1);

}

deltax = Math.Abs(x1 - x0);

deltay = Math.Abs(y1 - y0);

error = (deltax / 2);

y = y0;

if (x0 > x1) { xstep = -1; }

else { xstep = 1; }

if (y0 > y1) { ystep = -1; }

else { ystep = 1; }

for (x = x0; (x != (x1 + xstep)); x += xstep)

{

cx = x; cy = y; // copy of x, copy of y

// if x,y swapped above, swap them back now

if (st)

{

cx ^= cy; cy ^= cx; cx ^= cy;

}

if (drawit(new Point(cx, cy), br))

{

br = m_brushGenerated;

}

error -= deltay; // converge toward end of line

if (error < 0)

{ // not done yet

y += ystep;

error += deltax;

}

#if AREA

SolidBrush m_brushFill = new SolidBrush(Color.Blue);

Color m_oColor = Color.Black;

/*/

void AreaFill(Point ptcell)

{

if (ptcell.X >= 0 && ptcell.X < m_numCells.Width)

{

if (ptcell.Y >= 0 && ptcell.Y < m_numCells.Height)

{

// System.Threading.Thread.Sleep(100);

if (DrawACell(ptcell, m_brushFill))

{

m_oColor = Color.FromArgb((int)(((((uint)m_oColor.ToArgb() & 0xffffff) + 140) & 0xffffff) | 0xff000000));

m_brushFill = new SolidBrush(m_oColor);

AreaFill(new Point(ptcell.X - 1, ptcell.Y));

AreaFill(new Point(ptcell.X + 1, ptcell.Y));

AreaFill(new Point(ptcell.X, ptcell.Y + 1));

AreaFill(new Point(ptcell.X, ptcell.Y - 1));

}

//*/

#endif

}

</C# Sample>

#Const AREA = True

Public Class Form1

Dim m_numCells = New Size(350, 300) ' we'll use an array of cells

Dim m_cells(,) As Boolean ' the array of cells: whether they've been drawn or not

Dim m_cellSize = New Size(8, 8) ' cell size & width

Dim m_Offset = New Size(0, 0)

Dim m_MouseDown = False

Dim WithEvents btnErase As Button

Dim m_PtOld As Point?

Dim m_brushGenerated = New SolidBrush(Color.Black)

Dim m_brushMouse = New SolidBrush(Color.Red)

Dim m_oGraphics As Graphics

Delegate Function DrawCellDelegate(ByVal ptCell As Point, ByVal br As Brush) As Boolean

Sub Form_Load() Handles Me.Load

Me.Width = 600

Me.Height = 400

Me.btnErase = New Button()

Me.btnErase.Text = "&Erase"

Me.Controls.Add(Me.btnErase)

Me.BackColor = Color.White

btnErase_Click()

End Sub

Sub btnErase_Click() Handles btnErase.Click

m_oGraphics = Graphics.FromHwnd(Me.Handle)

m_numCells.Width = Me.Width / m_cellSize.Width

m_numCells.Height = Me.Height / m_cellSize.Height

ReDim m_cells(m_numCells.Width, m_numCells.Height)

m_oGraphics.FillRectangle(Brushes.White, New Rectangle(0, 0, Me.Width, Me.Height))

End Sub

Function PointToCell(ByVal p1 As Point) As Point

Dim ptcell = New Point( _

(p1.X - m_Offset.Width) / m_cellSize.Width, _

(p1.Y - m_Offset.Height) / m_cellSize.Height)

Return ptcell

End Function

Protected Overrides Sub OnMouseDown(ByVal e As System.Windows.Forms.MouseEventArgs)

If e.Button = Windows.Forms.MouseButtons.Left Then

m_MouseDown = True

m_PtOld = New Point(e.X, e.Y)

CheckMouseDown(e)

#If AREA Then

Else

AreaFill(PointToCell(New Point(e.X, e.Y)))

#End If

End If

End Sub

Protected Overrides Sub OnMouseMove(ByVal e As System.Windows.Forms.MouseEventArgs)

If m_MouseDown Then

CheckMouseDown(e)

End If

End Sub

Protected Overrides Sub OnMouseUp(ByVal e As System.Windows.Forms.MouseEventArgs)

m_MouseDown = False

End Sub

Sub CheckMouseDown(ByVal e As MouseEventArgs)

Dim ptMouse = New Point(e.X, e.Y)

Dim ptcell = PointToCell(ptMouse)

If (ptcell.X >= 0 And ptcell.X < m_numCells.Width And _

ptcell.Y >= 0 And ptcell.Y < m_numCells.Height) Then

DrawLineOfCells(PointToCell(m_PtOld.Value), ptcell, New DrawCellDelegate(AddressOf DrawACell))

m_PtOld = ptMouse

End If

End Sub

Function DrawACell(ByVal ptCell As Point, ByVal br As Brush) As Boolean

Dim fDidDraw = False

If Not m_cells(ptCell.X, ptCell.Y) Then

m_cells(ptCell.X, ptCell.Y) = True

m_oGraphics.FillRectangle(br, _

m_Offset.Width + ptCell.X * m_cellSize.Width, _

m_Offset.Height + ptCell.Y * m_cellSize.Height, _

m_cellSize.Width, _

m_cellSize.Height)

fDidDraw = True

End If

Return fDidDraw

End Function

Sub DrawLineOfCells(ByVal p0 As Point, ByVal p1 As Point, ByVal drawit As DrawCellDelegate)

Dim br = m_brushMouse

Dim x0 = p0.X

Dim y0 = p0.Y

Dim x1 = p1.X

Dim y1 = p1.Y

Dim fSwapped = False

Dim dx = Math.Abs(x1 - x0)

Dim dy = Math.Abs(y1 - y0)

If dy > dx Then

fSwapped = True ' swap x0<=>y0, x1<->y1

x0 = p0.Y

y0 = p0.X

x1 = p1.Y

y1 = p1.X

dx = Math.Abs(x1 - x0)

dy = Math.Abs(y1 - y0)

End If

Dim err = CInt(dx / 2)

Dim y = y0

Dim xstep = 1

If x0 > x1 Then

xstep = -1

End If

Dim ystep = 1

If y0 > y1 Then

ystep = -1

End If

Dim x = x0

While x <> x1 + xstep

Dim cx = x, cy = y ' copy of x,y

If fSwapped Then

cx = y

cy = x

End If

If drawit(New Point(cx, cy), br) Then ' if it wasn't already drawn

br = m_brushGenerated

End If

err -= dy

If err < 0 Then

y += ystep

err += dx

End If

x += xstep

End While

End Sub

#If AREA Then

Dim m_brushFill = New SolidBrush(Color.Blue)

Dim m_oColor = Color.Black

Sub AreaFill(ByVal ptcell As Point)

If (ptcell.X >= 0 And ptcell.X < m_numCells.Width) Then

If (ptcell.Y >= 0 And ptcell.Y < m_numCells.Height) Then

' System.Threading.Thread.Sleep(100);

If (DrawACell(ptcell, m_brushFill)) Then

Me.m_oColor = Color.FromArgb((((Me.m_oColor.ToArgb And &HFFFFFF) + 140) And &HFFFFFF) Or &HFF000000)

' m_oColor = Color.FromArgb((int)(((((uint)m_oColor.ToArgb() & 0xffffff) + 140) & 0xffffff) | 0xff000000));

m_brushFill = New SolidBrush(m_oColor)

AreaFill(New Point(ptcell.X - 1, ptcell.Y)) ' West

AreaFill(New Point(ptcell.X + 1, ptcell.Y)) ' East

AreaFill(New Point(ptcell.X, ptcell.Y + 1)) ' South

AreaFill(New Point(ptcell.X, ptcell.Y - 1)) ' North

End If

End Sub

#End If

End Class

</VB Sample>

Which pixels do you turn on when you draw a line?

Calvin_Hsia — Mon, 30 Mar 2009 21:46:00 GMT

When I wrote my cartoon animation program almost 30 years ago (see Cartoon animation program) I needed to know how to draw a line.

Of course, nowadays, we just call a library function that will draw a line given two points.

If you think about it, the problem is quite complex. Imagine a rectangular array of pixels. Which ones do you paint in order to “see” a straight line?

If the desired line is horizontal, or vertical, the problem is simple. However, choosing which pixels to draw for an oblique line is an interesting mathematical problem: see Bresenham's line algorithm - Wikipedia, the free encyclopedia

Even back then, I found Bresenham’s algorithm in a book and implemented it for my cartoon program.

Suppose you want to create a simple drawing program. When you move the mouse, you can handle the MouseMove event, and light up the pixel at the position of the mouse.

However, this will only create a dotted line, with fewer dots if the mouse moved quickly.

Let’s see if we can use Bresenham’s algorithm to light up the pixels between successive mouse events.

This sample uses larger “pixels”, so you can actually see them as squares. In the code I called them cells (mainly because I stole a lot of the code from my game of Life (see Cellular Automata: The Game of Life )

The actual mouse down causes a red pixel to be drawn, and the generated ones are black.

Below are C# and VB versions.

Start Visual Studio 2008

Choose File->New->Project->C# or VB->Windows Forms Application.

Choose View->Code

Paste in the VB or C# version of the code below, hit F5 to run it.

Move the mouse slowly and you’ll see more red pixels. Quickly, and you’ll see more black generated pixels.

Note how the code needs to distinguish between 2 sets of x-y coordinates: actual pixels, and cell coordinates.

Try adjusting the Cell size.

Think about what a right click would do.

Remove double spaces from pasted code samples in blog

<C#Sample>

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace WindowsFormsApplication1

{

public partial class Form1 : System.Windows.Forms.Form

{

Size m_numCells = new Size(350, 200);// we'll use an array of Cells

Boolean[,] m_cells; // the array of cells: whether they've been drawn or not

Size m_cellSize = new Size(8, 8); // cell height & width

Size m_Offset = new Size(0, 0);

bool m_MouseDown = false;

Button btnErase;

Point? m_PtOld;

SolidBrush m_brushMouse = new SolidBrush(Color.Red);

SolidBrush m_brushGenerated = new SolidBrush(Color.Black);

delegate bool DrawCellDelegate(Point ptcell, Brush br);

Graphics m_oGraphics;

public Form1()

{

this.Load += new EventHandler(this.Loaded);

}

void Loaded(Object o, EventArgs e)

{

this.Width = 600;

this.Height = 400;

this.btnErase = new Button();

this.btnErase.Text = "&Erase";

this.btnErase.Click += new EventHandler(this.btnErase_Click);

this.Controls.Add(this.btnErase);

this.BackColor = Color.White;

btnErase_Click(null, null);

}

void btnErase_Click(object sender, System.EventArgs e)

{

m_oGraphics = Graphics.FromHwnd(this.Handle);

m_numCells.Width = this.Width / m_cellSize.Width;

m_numCells.Height = this.Height / m_cellSize.Height;

m_cells = new Boolean[m_numCells.Width, m_numCells.Height];

m_oGraphics.FillRectangle(Brushes.White, new Rectangle(0, 0, this.Width, this.Height));

}

Point PointToCell(Point p1)

{

Point ptcell = new Point(

(p1.X - m_Offset.Width) / m_cellSize.Width,

(p1.Y - m_Offset.Height) / m_cellSize.Height);

return ptcell;

}

protected override void OnMouseDown(MouseEventArgs e)

{

if (e.Button == MouseButtons.Left)

{

m_MouseDown = true;

m_PtOld = new Point(e.X, e.Y);

CheckMouseDown(e);

}

#if AREA

else

{

AreaFill(PointToCell(new Point(e.X, e.Y)));

}

#endif

}

protected override void OnMouseMove(MouseEventArgs e)

{

if (m_MouseDown)

{

CheckMouseDown(e);

}

protected override void OnMouseUp(MouseEventArgs e)

{

m_MouseDown = false;

}

void CheckMouseDown(MouseEventArgs e)

{

Point ptMouse = new Point(e.X, e.Y);

Point ptcell = PointToCell(ptMouse);

if (ptcell.X >= 0 && ptcell.X < m_numCells.Width &&

ptcell.Y >= 0 && ptcell.Y < m_numCells.Height)

{

DrawLineOfCells(PointToCell(m_PtOld.Value), ptcell, new DrawCellDelegate(DrawACell));

m_PtOld = ptMouse;

}

bool DrawACell(Point ptcell, Brush br)

{

bool fDidDraw = false;

if (!m_cells[ptcell.X, ptcell.Y]) // if not drawn already

{

m_cells[ptcell.X, ptcell.Y] = true;

//*

m_oGraphics.FillRectangle(br,

m_Offset.Width + ptcell.X * m_cellSize.Width,

m_Offset.Height + ptcell.Y * m_cellSize.Height,

m_cellSize.Width,

m_cellSize.Height);

/*/

g.DrawRectangle(new Pen(Color.Blue,1),

m_Offset.Width + ptcell.X * m_cellSize.Width,

m_Offset.Height + ptcell.Y * m_cellSize.Height,

m_cellSize.Width,

m_cellSize.Height);

//*/

fDidDraw = true;

}

return fDidDraw;

}

void DrawLineOfCells(Point p1, Point p2, DrawCellDelegate drawit)

{

// http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm

Brush br = m_brushMouse;

int x0 = p1.X;

int y0 = p1.Y;

int x1 = p2.X;

int y1 = p2.Y;

int x, cx, deltax, xstep,

y, cy, deltay, ystep,

error;

bool st;

// find largest delta for pixel steps

st = (Math.Abs(y1 - y0) > Math.Abs(x1 - x0));

// if deltay > deltax then swap x,y

if (st)

{

x0 ^= y0; y0 ^= x0; x0 ^= y0; // swap(x0, y0);

x1 ^= y1; y1 ^= x1; x1 ^= y1; // swap(x1, y1);

}

deltax = Math.Abs(x1 - x0);

deltay = Math.Abs(y1 - y0);

error = (deltax / 2);

y = y0;

if (x0 > x1) { xstep = -1; }

else { xstep = 1; }

if (y0 > y1) { ystep = -1; }

else { ystep = 1; }

for (x = x0; (x != (x1 + xstep)); x += xstep)

{

cx = x; cy = y; // copy of x, copy of y

// if x,y swapped above, swap them back now

if (st)

{

cx ^= cy; cy ^= cx; cx ^= cy;

}

if (drawit(new Point(cx, cy), br))

{

br = m_brushGenerated;

}

error -= deltay; // converge toward end of line

if (error < 0)

{ // not done yet

y += ystep;

error += deltax;

}

</C#Sample>

Public Class Form1

Dim m_numCells = New Size(350, 300) ' we'll use an array of cells

Dim m_cells(,) As Boolean ' the array of cells: whether they've been drawn or not

Dim m_cellSize = New Size(8, 8) ' cell size & width

Dim m_Offset = New Size(0, 0)

Dim m_MouseDown = False

Dim WithEvents btnErase As Button

Dim m_PtOld As Point?

Dim m_brushGenerated = New SolidBrush(Color.Black)

Dim m_brushMouse = New SolidBrush(Color.Red)

Dim m_oGraphics As Graphics

Delegate Function DrawCellDelegate(ByVal ptCell As Point, ByVal br As Brush) As Boolean

Sub Form_Load() Handles Me.Load

Me.Width = 600

Me.Height = 400

Me.btnErase = New Button()

Me.btnErase.Text = "&Erase"

Me.Controls.Add(Me.btnErase)

Me.BackColor = Color.White

btnErase_Click()

End Sub

Sub btnErase_Click() Handles btnErase.Click

m_oGraphics = Graphics.FromHwnd(Me.Handle)

m_numCells.Width = Me.Width / m_cellSize.Width

m_numCells.Height = Me.Height / m_cellSize.Height

ReDim m_cells(m_numCells.Width, m_numCells.Height)

m_oGraphics.FillRectangle(Brushes.White, New Rectangle(0, 0, Me.Width, Me.Height))

End Sub

Function PointToCell(ByVal p1 As Point) As Point

Dim ptcell = New Point( _

(p1.X - m_Offset.Width) / m_cellSize.Width, _

(p1.Y - m_Offset.Height) / m_cellSize.Height)

Return ptcell

End Function

Protected Overrides Sub OnMouseDown(ByVal e As System.Windows.Forms.MouseEventArgs)

If e.Button = Windows.Forms.MouseButtons.Left Then

m_MouseDown = True

m_PtOld = New Point(e.X, e.Y)

CheckMouseDown(e)

#If AREA Then

Else

AreaFill(PointToCell(New Point(e.X, e.Y)))

#End If

End If

End Sub

Protected Overrides Sub OnMouseMove(ByVal e As System.Windows.Forms.MouseEventArgs)

If m_MouseDown Then

CheckMouseDown(e)

End If

End Sub

Protected Overrides Sub OnMouseUp(ByVal e As System.Windows.Forms.MouseEventArgs)

m_MouseDown = False

End Sub

Sub CheckMouseDown(ByVal e As MouseEventArgs)

Dim ptMouse = New Point(e.X, e.Y)

Dim ptcell = PointToCell(ptMouse)

If (ptcell.X >= 0 And ptcell.X < m_numCells.Width And _

ptcell.Y >= 0 And ptcell.Y < m_numCells.Height) Then

DrawLineOfCells(PointToCell(m_PtOld.Value), ptcell, New DrawCellDelegate(AddressOf DrawACell))

m_PtOld = ptMouse

End If

End Sub

Function DrawACell(ByVal ptCell As Point, ByVal br As Brush) As Boolean

Dim fDidDraw = False

If Not m_cells(ptCell.X, ptCell.Y) Then

m_cells(ptCell.X, ptCell.Y) = True

m_oGraphics.FillRectangle(br, _

m_Offset.Width + ptCell.X * m_cellSize.Width, _

m_Offset.Height + ptCell.Y * m_cellSize.Height, _

m_cellSize.Width, _

m_cellSize.Height)

fDidDraw = True

End If

Return fDidDraw

End Function

Sub DrawLineOfCells(ByVal p0 As Point, ByVal p1 As Point, ByVal drawit As DrawCellDelegate)

Dim br = m_brushMouse

Dim x0 = p0.X

Dim y0 = p0.Y

Dim x1 = p1.X

Dim y1 = p1.Y

Dim fSwapped = False

Dim dx = Math.Abs(x1 - x0)

Dim dy = Math.Abs(y1 - y0)

If dy > dx Then

fSwapped = True ' swap x0<=>y0, x1<->y1

x0 = p0.Y

y0 = p0.X

x1 = p1.Y

y1 = p1.X

dx = Math.Abs(x1 - x0)

dy = Math.Abs(y1 - y0)

End If

Dim err = CInt(dx / 2)

Dim y = y0

Dim xstep = 1

If x0 > x1 Then

xstep = -1

End If

Dim ystep = 1

If y0 > y1 Then

ystep = -1

End If

Dim x = x0

While x <> x1 + xstep

Dim cx = x, cy = y ' copy of x,y

If fSwapped Then

cx = y

cy = x

End If

If drawit(New Point(cx, cy), br) Then ' if it wasn't already drawn

br = m_brushGenerated

End If

err -= dy

If err < 0 Then

y += ystep

err += dx

End If

x += xstep

End While

End Sub

End Class

</VBSample>

Comment/Uncomment code to switch versions quickly without using macros

Calvin_Hsia — Sat, 28 Mar 2009 09:39:00 GMT

In a typical day, I write or debug programs in several languages: typically Foxpro, C#, VB, C++ and 32 bit assembly, with an occasional MSIL, IDL and 64 bit ASM thrown in.

Sometimes, I like to switch between one version of code and another. This is useful if I want to do side by side comparisons of behavior.

One way to do this is with preprocessor macros, like this:

#If SomeValue

#else

#endif

However, that’s a fair amount of typing.

There’s a shortcut that works with C# and C++ style comments.

In these languages, a line that starts with “//” is a comment.

Also, a block comment (which can span multiple lines) starts with “/*” and ends with “*/”

//*

int sub foo1() {

int x = 2;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo1

return x;

}

/*/

int sub foo2() {

int x = 3;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo2

return x;

}

// */

With a single character change I can switch between foo1 and foo2: just delete the very first “/”. That changes the single line comment into a block comment. The “*/” of the “/*/” now acts like the end of the comment block.

Using an editor that colors the code (like Visual Studio) shows the switch properly

int sub foo1() {

int x = 2;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo1

return x;

}

/*/

int sub foo2() {

int x = 3;

Console.WriteLine((new System.Diagnostics.StackTrace().GetFrames()[0].GetMethod().Name)); // shows Foo2

return x;

}

// */

This technique is useful when creating sample code for others to play with, such as in my next blog post.

Write simple Debug helpers to help you debug and maintain your code

Calvin_Hsia — Thu, 04 Dec 2008 01:55:00 GMT

Much of my time is spent using the Visual Studio debugger examining code to figure out how it works and how to fix it. When stepping through a function, the values the function uses are very useful for code understanding. The debugger shows these values in the Watch/Locals/Auto/Callstack windows. For example, the Locals window shows the Local variables used by the current code while at a breakpoint. Each variable might be a structure or class with many members. You can click to expand to examine sub-members of a value.

I also like to modify code while the debug session is live, so I can see real values while writing. Edit and Continue is a very useful feature, but it doesn’t work in every case, such as creating new methods or types. Also, native code doesn’t support EnC. So I like using an external editor (perhaps another instance of VS) to modify the code. This means that your debug session is still live, and the source code file still matches the binary, until you save the file in the external editor.

The string shown for a variable can be customized to help understand what the code is doing. As you step through the code, if you can understand at a glance what the function is doing, rather than drilling into sub-members, you’re more efficient. Some types have dozens of variables, and some might be more important than others.

For native code (C++, C) you can customize the display string with this: Customize the VS debugger display of your data

For managed code (VB, C#) you can override the ToString method to customize the string. In VS 2008, the debugger will display the results of calling the ToString method.

There are 2 options:

Tools->Options->Debugging->

Enable Property Evaluation and other implicit function calls

Call string conversion function on object in variables windows (C# and javascript only)

The next version of Visual Studio will add VB to this feature!

As a simple workaround, to have the debugger call ToString in VB programs, you need only prefix your types with

<DebuggerDisplay("{tostring}")> _

The line continuation character won’t be needed in the next version either!

If you don’t have the source code or can’t modify it, you can still modify the displayed string: Customize the display of types in the Debugger using Extension Methods and DebuggerDisplay Attribute

Below are a VB and C# program demonstrating how the string can be customized.

Start VS2008, choose File->New->Project->C# or VB->WPF Application, then paste in the code.

Put a Breakpoint on the indicated line and hit F5. You’ll see the string displayed is the result of the ToString function.

See also:

Use temporary projects in Visual Studio

Customize the display of types in the Debugger using Extension Methods and DebuggerDisplay Attribute

Customize the VS debugger display of your data

New Features in Visual Basic 10

Remove double spaces from pasted code samples in blog

Make your code more maintainable: The evils of the Return statement

Very Advanced Debugging tips

Class Window1

Sub dd() Handles Me.Loaded

Dim y = New TestClass

Dim r = "Put a bpt here"

End Sub

End Class

<DebuggerDisplay("{tostring}")> _

Class TestClass

Dim x = "asdf"

Public Overrides Function ToString() As String

Return "here we are in tostring " + x

End Function

End Class

Here’s the C# equivalent Program

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Data;

using System.Windows.Documents;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Imaging;

using System.Windows.Navigation;

using System.Windows.Shapes;

namespace WpfApplication1

{

/// <summary>

/// Interaction logic for Window1.xaml

/// </summary>

public partial class Window1 : Window

{

public Window1()

{

InitializeComponent();

var x = new TestClasss();

var y = "set a bpt here";

}

class TestClasss

{

String foo = "test";

public override string ToString()

{

return "i'm in the test class " + foo;

}

Magnify your pictures using a PictureBox so that you can zoom with the Mouse Wheel

Calvin_Hsia — Thu, 21 Aug 2008 21:15:00 GMT

Today’s digital cameras take pictures with much higher resolution than many computer screens. My Canon PowerShot SD800 IS camera takes pictures at 3072 x 2204 resolution.

One of my laptops died recently, and I noticed that local laptop retailers have machines with 1280 X 1024 resolution. I much prefer a higher resolution display, so I ordered a customizable Dell Inspiron 1525 with 1680 x 1050.

(I’ve been ordering computers from Dell for over 20 years, back in the days when it was called PC’s Limited. Why does Dell distinguish between business/government/home laptops?)

I was playing around with some photos using a PictureBox control, and I wanted to add a feature that would allow click/zoom using the mouse wheel to designate a point to magnify.

It was pretty easy to create my own class MyPictureBox which inherits from PictureBox and handles the MouseWheel and zooming.

Below are C# and VB versions. If I get enough requests, maybe I’ll make a Fox version (although I like this Fox version of zooming: Enable crop and zooming in on your digital photograph display form)

Start Visual Studio 2008 (I think these should work in VS2005)

File->New->Project->VB/C#->Windows Application.

View->Code, then paste the VB/C# code below, hit F5

Move the mouse to designate a zoom anchor point, then mouse wheel to zoom in/out

If you switch back to the form designer, the ToolBox has the MyPictureBox control on it, which you can drag/drop onto a form.

If you already have your own form that uses a PictureBox or several, you can avoid manually changing all the instances by carefully editing the Form1.Designer.vb file to replace the type with MyPictureBox (make a backup first).

As an exercise, try extending this feature by adding the ability to change the anchor point while zoomed or pan the zoomed picture.

Some VB/C# coding issues:

· semicolons

· capitalization

· intermediate arithmetic rounding results

· event handling

Create your own media browser: Display your pictures, music, movies in a XAML tooltip

<VB Code>

Public Class Form1

Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load

Me.Left = 0

Me.Top = 0

Me.Size = My.Computer.Screen.WorkingArea.Size

Dim oPict = New MyPictureBox

oPict.Size = Me.Size

oPict.SizeMode = PictureBoxSizeMode.StretchImage

oPict.Image = New Bitmap("d:\kids.jpg") ' path to some picture

Me.Controls.Add(oPict)

Me.ActiveControl = oPict

End Sub

End Class

Public Class MyPictureBox

Inherits PictureBox

Private zmLevel As Integer = 1

Private zmPt As Point

Overloads Property Image() As Image ' we want to hook when client's set the image to reset the zoom level to unzoomed

Get

Return MyBase.Image

End Get

Set(ByVal value As Image)

zmLevel = 1 ' reinit

MyBase.Image = value

End Set

End Property

Protected Overrides Sub OnPaint(ByVal pe As System.Windows.Forms.PaintEventArgs)

'MyBase.OnPaint(pe) ' don't call baseclass to paint

If Me.Image IsNot Nothing Then

Dim loc As Point

Dim sz As Size

If zmLevel <> 1 Then

sz = New Size(Me.Image.Width / zmLevel, Me.Image.Height / zmLevel)

' center on zmPt

loc = New Point(Me.Image.Width * (zmPt.X / Me.ClientRectangle.Width) - sz.Width / 2, _

Me.Image.Height * (zmPt.Y / Me.ClientRectangle.Height) - sz.Height / 2) '

Else

loc = New Point(0, 0) ' no zoom: we want the entire source picture

sz = Me.Image.Size

End If

Dim rectSrc = New Rectangle(loc, sz)

' now draw the rect of the source picture in the entire client rect of MyPictureBox

pe.Graphics.DrawImage(Me.Image, Me.ClientRectangle, rectSrc, GraphicsUnit.Pixel)

End If

End Sub

Sub PictureBox_MouseWheel(ByVal sender As Object, ByVal e As MouseEventArgs) Handles Me.MouseWheel

If Me.zmLevel = 1 Then ' can only anchor when unzoomed

Me.zmPt = New Point(e.X, e.Y)

End If

If e.Delta > 0 Then

If zmLevel < 20 Then

zmLevel += 1

End If

Else

If e.Delta < 1 Then

If zmLevel > 1 Then

zmLevel -= 1

End If

Me.Invalidate() ' queue msg to repaint

End Sub

End Class

</VB Code>

<C# Code>

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

namespace WindowsFormsApplication1

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

this.Left = 0;

this.Top = 0;

this.Size = Screen.PrimaryScreen.WorkingArea.Size;

var oPict = new MyPictureBox();

oPict.Size = this.Size;

oPict.SizeMode = PictureBoxSizeMode.StretchImage;

oPict.Image = new Bitmap("d:\\kids.jpg");

this.Controls.Add(oPict);

this.ActiveControl = oPict;

}

public class MyPictureBox : PictureBox

{

private int zmLevel = 1;

private Point zmPt;

public MyPictureBox()

{

this.MouseWheel += new MouseEventHandler(MyPictureBox_MouseWheel);

}

void MyPictureBox_MouseWheel(object sender, MouseEventArgs e)

{

if (this.zmLevel == 1)

{

this.zmPt = new Point(e.X, e.Y);

}

if (e.Delta > 0)

{

if (zmLevel < 20)

{

zmLevel += 1;

}

else

{

if (e.Delta < 1)

{

if (zmLevel > 1)

{

zmLevel -= 1;

}

this.Invalidate();

}

new public Image Image // overrides

{

get

{

return base.Image;

}

set

{

zmLevel = 1;

base.Image = value;

}

protected override void OnPaint(PaintEventArgs pe)

{

//base.OnPaint(pe);

if (this.Image != null)

{

Point loc;

Size sz;

if (zmLevel != 1)

{

sz = new Size(this.Image.Width / zmLevel, this.Image.Height / zmLevel);

// center on zmPt. Casts are needed so integer divide doesn't occur (intermediate double result)

loc = new Point((int)(this.Image.Width * (zmPt.X / (double)this.ClientRectangle.Width)) - sz.Width / 2,

(int)(this.Image.Height * (zmPt.Y / (double)this.ClientRectangle.Height)) - sz.Height / 2);

}

else

{

loc = new Point(0, 0);

sz = this.Image.Size;

}

Rectangle rectSrc = new Rectangle(loc, sz);

// now draw the rect of the source picture in the entire client rect of MyPictureBox

pe.Graphics.DrawImage(this.Image, this.ClientRectangle, rectSrc, GraphicsUnit.Pixel);

}

</C# Code>

Make your code more maintainable: The evils of the Return statement

Calvin_Hsia — Tue, 29 Jul 2008 00:34:00 GMT

What does it mean to make code more maintainable? Certainly obfuscated code is hard to understand, by definition.

A big part of maintainability is making it easier for others to read and understand what the code is doing. Your code may have been working for years, but then somebody comes along and wants to add a feature, which might break your code.

Sometimes the behavior of code isn’t quite right, so you might need to investigate somebody else’s code.

(The repro scenario of the issue might be quite complicated, involving several tedious minutes of (perhaps ambiguous) keystrokes and clicks.

You might be single stepping some code, and suddenly you find yourself past the point where something seems to have gone wrong. <Sigh>. You have to restart the entire scenario, putting a breakpoint before the offending code is executed. Or do you? Set Next Statement is your friend. Often you can use Set Next Statement to go back a bit. You can perhaps modify some local variables and try to execute the code again, without having to repeat the tedious repro scenario.)

The Return statement exists in many languages, including C#, VB, FoxPro, C++. This discussion pertains to all of them.

Each of these languages allow you to create a very complex expression, perhaps with inline conditionals, precede it with the keyword “Return” and the value of the expression is the return value of the current method.

Suppose you had “simple” functions Foo and Bar:

int Foo(someparam)

{

return Bar(someparam)->SomeMethod(SomeOtherParam);

}

int Bar(someparam)

{

<...some code...>

return AnotherFoo(SomeFunc(SomeOtherValue));

}

Another return statement sample with 20 calls in it:

return (HasFlag(Flags, GetSomeVal(Flags)) &&

!HasFlag32(Result, SXF_LPE) &&

!(IsSomeValPointer(Result) &&

// Rule out Pointers to values of types.

!(Result->AsSomeValPointerExpression().Left->type == type_WRD &&

Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer &&

!HasFlag32(Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer, SXF_LWORD) &&

ValHelpers::IsValue(Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer->ResultType)&&

// make sure SomeSomeVal() still works for value types(bug 32804)

!(Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer->type == type_SYM &&

Result->AsSomeValPointerExpression().Left->AsWordPointerExpression().BasePointer->AsWordPointerExpression().Word->PVariable()->IsGood()))))

Suppose you’re debugging a program and single stepping and reach the end of Bar(). Even after stepping over this statement, you can’t easily see the value (or intermediate values) that’s being returned. You can’t even see the type of the return value unless you can see the method signature on the screen: “Function MyMethod() As SomeType”

The Autos window does show the return value/type for native code, (but not VB or C#), but I find that the other info it displays is useless. It tries to guess the nearby values that you might want to see: I much prefer the Locals window. It would be nice if the return value from the Autos window were displayed in the Locals window. So I’ve resorted to showing just the top couple of lines of the Auto window under my Locals window. However, the Autos window doesn’t allow you to change a returned value, whereas the Locals window does.

Also, seeing intermediate values by hovering your mouse works for local values, but not for method calls.

(If you’re debugging C++ code, then if you open the Debug->Windows->Registers window, you can see and change simple return values like Bools and Integers in the EAX register (32 bit) or RAX (64 bit), but watch out for implied destructor calls)

So you step out of the function Bar(), then you’re on another complex return statement in Foo(), where you still can’t see the returned value. So you step out again, and yet another Return statement. You might need to step out a few levels before you can see what the value is. If you want to reexamine this path, you can Set Next Statement back, but then you’re at a call stack level that’s far from the original code, so you have to go drill back down the callstack.

Now suppose you think the return value of Bar() isn’t quite right, or you want to reexamine what is happening.

Right click and choose “Step Into Specific” ,which might list 20 different functions into which you could step. However, depending on conditionals and prior values, not all of the 20 may be called. So you Step into the first, see that it’s uninteresting, Step into the Next, etc. until you see something interesting.

(look for a future blog post on Just My Code for native debugging that will remove a lot of the uninteresting Step Intos., like library or template functions or operator overloads)

So we’ve discussed two maintainability issues:

· make the return value of your function more visible while debugging, so the user can verify functionality more easily and can use Set Next Statement.

· Break up complex expressions, especially in Return statements.

The simple solution to both of these issues: Introduce new local variables to have intermediate results and break up nested conditional clauses to be separate If statements.

· Set Next Statement and Breakpoint granularity is finer.

· Intermediate results can be seen and modified in the Locals window

· Mouse hover shows the values

· The local variable names can be further indications of intent.

Simply changing the code from:

Return <ComplexExpr>

Int RetVal = <ComplexExpr>

Return RetVal

will make a huge difference in this debugging scenario. The user can Step Over and the RetVal can be seen in the debugger and, if it’s wrong, the user can Set Next Statement back and reexecute the code, Stepping In, rather than Stepping Over (watch out for side effects of reexecution). The user stays within the method without having to back up a few levels of the call stack. Also, it’s easier to see the type of the return value.

int Foo(someparam)

{

SomeType Barval = Bar(somparam);

Int RetVal = Barval->SomeMethod(SomeOtherParam);

return Retval;

}

int Bar(someparam)

{

<...some code...>

SomeFuncType SomeFuncVal = SomeFunc(SomeOtherValue));

Int Retval = AnotherFoo(SomeFuncVal);

return Retval;

}

Modern optimizing compilers can optimize out those variables and can generate identical code.

I once heard of a chess program written in one (very long) line of code, but imagine trying to maintain that puppy!

Cellular Automata: The Game of Life

Calvin_Hsia — Mon, 14 Jul 2008 21:57:00 GMT

I remember my dad getting a copy of Scientific American magazine every month when I was a kid. He kept back issues on a shelf in our living room. I remember being fascinated by the issue (Oct 1970) which described John Conway’s Game of Life.

A few decades later, in the mid 80’s I wrote my own version using the DeSmet C compiler on an original IBM PC (see Why was the original IBM PC 4.77 Megahertz?). I remember playing with gliders, glider guns and other formations.

A couple decades after that, I wrote one in C# (the date is 2003). Below is my original version from 2003, with one line of code added to make it run with more recent versions of VS.

(A subsequent article in Scientific American (Dec 84) described a cellular automata that simulated the Predator Prey ecosystem called Wator by Alexander Dewdney. This inspired me to write my own version of Wator in C++.)

Start VS 2008. File->New->Project->C#->Windows Forms

Edit the Program.cs code and replace it with the code below, then hit F5. Try moving the mouse around. Button1 results in an error.

The one line I had to add to get it to work was:

Form.CheckForIllegalCrossThreadCalls = false;

Without that line, an exception would occur:

System.InvalidOperationException was unhandled

Message="Cross-thread operation not valid: Control 'Form1' accessed from a thread other than the thread it was created on."

Source="System.Windows.Forms"

StackTrace:

at System.Windows.Forms.Control.get_Handle()

at Life.Form1.DrawCells(Boolean fDrawAll) in C:\Users\calvinh\AppData\Local\Temporary Projects\WindowsFormsApplication1\Program.cs:line 47

at Life.Form1.Shuffle() in C:\Users\calvinh\AppData\Local\Temporary Projects\WindowsFormsApplication1\Program.cs:line 90

at Life.Form1.Generations() in C:\Users\calvinh\AppData\Local\Temporary Projects\WindowsFormsApplication1\Program.cs:line 184

at Life.Form1.MyThread() in C:\Users\calvinh\AppData\Local\Temporary Projects\WindowsFormsApplication1\Program.cs:line 304

at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)

at System.Threading.ThreadHelper.ThreadStart()

InnerException:

Looking at the code, I see that indeed I wrote code that created a background thread that drew to the hWnd directly. So I added the code to set CheckForIllegalCrossThreadCalls false.

using System;

using System.Drawing;

using System.Collections;

using System.ComponentModel;

using System.Windows.Forms;

using System.Data;

using System.Threading;

using System.Runtime.InteropServices;

namespace Life

{

/// <summary>

/// Summary description for Form1.

/// </summary>

public class Form1 : System.Windows.Forms.Form

{

/// <summary>

/// Required designer variable.

/// </summary>

[DllImport("kernel32.dll")]

public static extern bool Beep(int freq, int dura);

private System.ComponentModel.Container components = null;

private TextBox m_box;

private Button m_button;

private Thread m_Thread = null;

bool m_nReset = false;

static int m_numx = 200;

static int m_numy = 200;

static int m_cellx = 5;

static int m_celly = 5;

static int m_Offx = 10;

static int m_Offy = 10;

static int MAXCOLOR = 8;

static int COLORDIV = 16; // # of gens before color changes

bool m_fDrawAll = false;

SolidBrush m_brushBlack = new SolidBrush(Color.Black);

SolidBrush m_brushWhite = new SolidBrush(Color.White);

SolidBrush[] m_brushArray = new SolidBrush[MAXCOLOR];

Queue m_queue = new Queue();

int[,] m_cells = new int[m_numx, m_numy];

private System.Windows.Forms.Button button1;

int[,] m_diff = new int[m_numx, m_numy];

private int DrawCells(bool fDrawAll)

{

int nTotal = 0;

Graphics g = Graphics.FromHwnd(this.Handle);

int x, y;

if (fDrawAll)

{

System.Diagnostics.Debug.Write("\nDraw");

}

for (x = 0; x < m_numx; x++)

{

for (y = 0; y < m_numy; y++)

{

if (fDrawAll || m_diff[x, y] == 1)

{

if (m_cells[x, y] == 0)

{

g.FillRectangle(m_brushWhite, m_Offx + x * m_cellx, m_Offy + y * m_celly, m_cellx - 1, m_celly - 1);

}

else

{

nTotal++;

g.FillRectangle(m_brushArray[m_cells[x, y] / COLORDIV], m_Offx + x * m_cellx, m_Offy + y * m_celly, m_cellx - 1, m_celly - 1);

}

return nTotal;

}

private void Shuffle()

{

int x, y;

Random myrandom = new Random();

for (x = 0; x < m_numx; x++)

{

for (y = 0; y < m_numy; y++)

{

m_diff[x, y] = m_cells[x, y] = myrandom.Next(100) < 50 ? 1 : 0;

}

DrawCells(false);

}

private int CountNeighbors(int x, int y)

{

if (x >= 0 && x < m_numx && y >= 0 && y < m_numy)

{

return m_cells[x, y] > 0 ? 1 : 0;

}

return 0;

}

private int Generation()

{

int[,] tmp = new int[m_numx, m_numy];

int x, y;

for (x = 0; x < m_numx; x++)

{

for (y = 0; y < m_numy; y++)

{

tmp[x, y] = CountNeighbors(x - 1, y - 1) +

CountNeighbors(x - 1, y) +

CountNeighbors(x - 1, y + 1) +

CountNeighbors(x, y - 1) +

CountNeighbors(x, y + 1) +

CountNeighbors(x + 1, y - 1) +

CountNeighbors(x + 1, y) +

CountNeighbors(x + 1, y + 1);

}

for (x = 0; x < m_numx; x++)

{

for (y = 0; y < m_numy; y++)

{

if (tmp[x, y] == 3 && m_cells[x, y] == 0) // an empty cell with exactly 3 neighbors: 1 is born

{

m_diff[x, y] = m_cells[x, y] = 1;

}

else if (tmp[x, y] >= 2 && tmp[x, y] <= 3 && m_cells[x, y] > 0) // a live cell with 2 or more neighbors lives

{

if (m_cells[x, y] == COLORDIV * MAXCOLOR - 1)

{

m_diff[x, y] = 0; // no change

}

else

{

m_cells[x, y]++;

m_diff[x, y] = 1;

}

else

{ // loneliness

if (m_cells[x, y] == 0) // already empty

{

m_diff[x, y] = 0; // no change

}

else

{

m_cells[x, y] = 0;

m_diff[x, y] = 1;

}

if (m_queue.Count > 0)

{

lock (m_queue.SyncRoot)

{

foreach (Point pt in m_queue)

{

m_diff[pt.X, pt.Y] = 1;

if (m_cells[pt.X, pt.Y] == 0)

{

m_cells[pt.X, pt.Y] = 1;

}

else

{

m_cells[pt.X, pt.Y] = 0;

}

m_queue.Clear();

}

int nResult = DrawCells(m_fDrawAll);

m_fDrawAll = false;

return nResult;

}

private void Generations()

{

int nTotal;

while (true)

{

Shuffle();

for (int i = 0; i < 100000; i++)

{

nTotal = Generation();

this.Text = i.ToString() + " : " + nTotal.ToString();

if (m_nReset)

{

m_nReset = false;

break;

}

private void handlethebutton(object sender, EventArgs e)

{

m_nReset = true;

}

private void OnClick(object sender, EventArgs e)

{

}

private void Onmmove(object sender, MouseEventArgs e)

{

Point pt = this.PointToClient(Cursor.Position);

Point ptcell = new Point();

ptcell.X = (pt.X - m_Offx) / m_cellx;

ptcell.Y = (pt.Y - m_Offy) / m_celly;

if (ptcell.X >= 0 && ptcell.X < m_numx && ptcell.Y >= 0 && ptcell.Y < m_numy)

{

lock (m_queue.SyncRoot)

{

m_queue.Enqueue(ptcell);

}

private void OnActivated(object sender, EventArgs e)

{

// Generations();

if (m_Thread == null)

{

m_Thread = new Thread(new ThreadStart(MyThread));

m_Thread.Start();

while (!m_Thread.IsAlive)

{

m_Thread.Abort();

}

else

{

m_fDrawAll = true;

}

private void FormPaint(object sender, PaintEventArgs e)

{

m_fDrawAll = true;

}

/// <summary>

/// Clean up any resources being used.

/// </summary>

protected override void Dispose(bool disposing)

{

if (m_Thread != null && m_Thread.IsAlive)

{

m_Thread.Abort();

}

if (disposing)

{

if (components != null)

{

components.Dispose();

}

base.Dispose(disposing);

}

#region Windows Form Designer generated code

/// <summary>

/// Required method for Designer support - do not modify

/// the contents of this method with the code editor.

/// </summary>

private void InitializeComponent()

{

this.button1 = new System.Windows.Forms.Button();

this.SuspendLayout();

// button1

this.button1.Location = new System.Drawing.Point(392, 0);

this.button1.Name = "button1";

this.button1.TabIndex = 0;

this.button1.Text = "button1";

this.button1.Click += new System.EventHandler(this.button1_Click);

// Form1

this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);

this.ClientSize = new System.Drawing.Size(800, 558);

this.Controls.AddRange(new System.Windows.Forms.Control[] {

this.button1});

this.Name = "Form1";

this.Text = "Life";

this.Click += new System.EventHandler(this.Form1_Click);

this.Load += new System.EventHandler(this.Form1_Load);

this.ResumeLayout(false);

}

#endregion

/// <summary>

/// The main entry point for the application.

/// </summary>

[STAThread]

static void Main()

{

Application.Run(new Form1());

}

private void MyThread()

{

Generations();

}

public Form1()

{

// Required for Windows Form Designer support

InitializeComponent();

this.Height = m_Offy + m_numy * m_celly;

this.Width = m_Offx + m_numx * m_cellx;

this.Left = 00;

this.Top = 0;

this.BackColor = Color.White;

m_box = new TextBox();

m_box.BackColor = Color.Cyan;

m_box.Text = "Hi";

m_box.Size = new Size(100, 100);

m_button = new Button();

m_button.BackColor = Color.Red;

m_button.Location = new Point(150, 00);

m_button.Text = "&Reset";

Controls.Add(m_button);

m_button.Click += new EventHandler(this.handlethebutton);

Controls.Add(m_box);

// this.Paint += new PaintEventHandler(this.FormPaint);

this.Activated += new EventHandler(this.OnActivated);

this.Click += new EventHandler(this.OnClick);

this.MouseMove += new MouseEventHandler(this.Onmmove);

this.Paint += new PaintEventHandler(this.FormPaint);

for (int i = 0; i < MAXCOLOR; i++)

{

Color clr = Color.FromArgb(255, (MAXCOLOR - i - 1) * 32, 0, 0);

m_brushArray[i] = new SolidBrush(clr);

}

private void Form1_Load(object sender, System.EventArgs e)

{

Form.CheckForIllegalCrossThreadCalls = false;

// Beep(1000,1000);

}

private void Form1_Click(object sender, System.EventArgs e)

{

}

private void button1_Click(object sender, System.EventArgs e)

{

Generation();

}

</code sample>

Use a dictionary to help create a mnemonic

Calvin_Hsia — Fri, 06 Jun 2008 22:36:00 GMT

I was using a program that was yet another TLA and I wanted to create a mnemonic to help me remember what it was. One of the letters was “k”, so I wanted to find a word that starts with “k”

Simple: load a dictionary, search for words starting with “k” and browse through them: “Killer” sounded fine!

The Dictionary dll (that you can download from the link below) actually contains 2 separate dictionaries in 679k bytes! The big one (Dictnum=1) has 171,201 words. The smaller (DictNum=2) has 53,869. These dictionaries are spelling dictionaries from the last century.

The samples below also demonstrate a simple LINQ query on the data:

I wanted to use common words, so I used the smaller one.

Fox code:

x=CREATEOBJECT("dictionary.dict")

x.Dictnum=2 && small dictionary

?x.FindMatches("k*")

cnt=x.words.count

CREATE CURSOR words (word c(20))

FOR i = 0 TO cnt-1

?x.Words.Item(i)

INSERT INTO words (word) VALUES (x.words.item(i))

ENDFOR

SELECT * FROM words WHERE AT("ill",word)>0

For VB code, Start VS, File->New->Project->VB->WindowsApplication->Console Application

We don’t have to reference the DLL (unless you want intellisense or use queries directly on the word collection) because late binding works.

(Since the DLL is 32 bit, if you’re using a 64 bit OS, make sure you make Project->Properties->Compile->Advanced Compiler Settings->Target CPU x86)

Module Module1

Sub Main()

Dim x = CreateObject("dictionary.dict")

'Dim x = New Dictionary.CDict ' use early binding: add a ref to Dictionary 1.0 Type Library

x.DictNum = 2 ' small dictionary

x.FindMatches("k*")

Dim col As New List(Of String) ' for late bindinq queries, we'll add to a list

For Each word In x.words

Debug.WriteLine(word)

col.Add(word)

For Each word In From a In col Where a.Contains("ill")

Debug.WriteLine(word)

End Sub

End Module

For C#, add a reference to “Dictionary 1.0 Type Library” in the COM tab.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

class Program

{

static void Main(string[] args)

{

var x = new Dictionary.CDictClass();

x.DictNum = 2;

x.FindMatches("k*");

foreach (var word in x.Words)

{

System.Diagnostics.Debug.WriteLine(word);

}

var q = from string a in x.Words where a.Contains("ill") select a;

foreach (var w in q)

{

System.Diagnostics.Debug.WriteLine(w);

}

Download the dictionary from here: A Discounter Introduces Reductions: Multiple Anagrams

You can create many word related games.

More word games:

Write your own hangman game

The Nametag Game

Create your own typing tutor!

Carburetor is a car part, but prosecutable is not

What mnemonic can you create from your phone number? See Phone Number Challenge update