Calvin Hsia's WebLog : Visual FoxPro

Make your Task Switcher Window bigger

Calvin_Hsia — Sat, 22 Aug 2009 00:51:00 GMT

One of the best features of Windows is the ability to Cut and Paste data within an application or from one application to another.

You can alt-tab or click on the task bar to switch between actively running applications, like Word and Visual Studio. When you hit Alt-Tab, a window comes up.

This Task switcher window, by default has 3 rows of 7 icons. If you have more than 21 top level windows open, that dialog gets confusing.

Without tabbed browsing a few years ago (the ability of Internet Explorer to open multiple Tabs to view multiple web pages in a single top level IE Window), I had tons of these windows. (Try Window Key Tab to switch applications on any machine with Aero enabled!)

In fact, sometimes I run so many I get confused when I Alt-Tab and see the behavior of the default 21 (3 row by 7 column) icon display. So, I just modify this to be 5 rows by 9 columns.

Open RegEdit and change these keys:

HKEY_CURRENT_USER\Control Panel\Desktop\CoolSwitchRows

HKEY_CURRENT_USER\Control Panel\Desktop\CoolSwitchColumns

See also CoolSwitchRows: http://technet.microsoft.com/en-us/library/cc978607.aspx

In the old days (the late 70's to early 80's, when a 5 Meg hard disk was cool!), you could only run one application on your computer at a time. To transfer data from one program to another, you would open one application, save the information temporarily to a file on (floppy) disk, then open the other application, import the temporary file.

Then along came Borland's Sidekick and AutoDesq DesqView. I think Sidekick had a way of storing text data: it was a TSR: a Terminate and Stay Resident program. That means it was always available even if you were running another application. Once you start it, it would “terminate” but still be running. It would always be in memory, reducing the memory available to other programs.

I remember writing various TSRs. One was a simple program that could flash on the screen any message at any time interval and duration:

Flashmsg /m:"You're getting hungry" /t:200 /d:1

Another would monitor key strokes. Every 100^th keystroke it could double a keystroke, substitute another, record, or suppress one. I didn't circulate these evil programs. (do you believe me? J)

A more useful one came about because a fellow ice hockey teammate and client heard I knew something about computers and wanted his business's Contact List to be instantly available at any time. So I wrote a TSR that would display a simple database of names and phone numbers around 1982. Over the years, I migrated the database maintenance to FoxBase and eventually FoxPro (1990?). So while the client was using WordPerfect, he could hit a key combination to bring up his Contact List instantly.

A TSR can monitor various interrupts, such as the keyboard, by just replacing the interrupt vector with its own. The interrupt vector was just a pointer to the code to run if the keyboard is hit. My TSR would just forward most requests to the original ISR (Interrupt Service Routine). Back in those DOS days, it was easy to replace system memory. “Protected mode” was unheard of.

DesqView was another TSR, but it allowed you to run multiple applications "simultaneously". If I remember right, it "paged" out one app for another, writing to disk the 256K that one was using for the other. This was an immense boost in productivity.

In those days, I was using a really great text editor called PC-Write (one of the first "shareware" programs) from Bob Wallace (Microsoft Employee #9). (It was around this time that dBase, FoxBase were born.)

When Windows 3.1 came out around the early 90's, you could use OLE (Object Linking and Embedding, which sort of got renamed to ActiveX later) and DDE (Dynamic Data Exchange) to have applications communicate with each other. The big demo was a Word Document or Fox database embedding an Excel spreadsheet or a photograph.

You can still embed a photo or spreadsheet in Foxpro using a General field (on XP, Vista and Windows Server08 R2(which is Win7 under the hood)):

CREATE CURSOR temp (name c(10), gen g)

INSERT INTO temp (name) VALUES ("Photo")

APPEND GENERAL gen FROM d:\kids.jpg

MODIFY GENERAL gen

INSERT INTO temp (name) VALUES ("Excel")

APPEND GENERAL gen FROM d:\2008.07.xlsx

BROWSE

You can double click the image or Excel spreadsheet to see or edit it within Fox. You can also use the Edit->Insert Special menu to insert other kinds of objects.

For fun, try this:

x=DDEINITIATE("visualfoxpro","")

_cliptext="This text goes on the clipboard"

Or notice the intellisense when you try this from the Fox Command window

x=CREATEOBJECT("Excel.Application")

x.Visible=1

x.Workbooks.Add

x.Cells(1,1).Value="Hi"

Try starting Visual Studio and choose File->Open->File-> navigate to a photo or spreadsheet!

Create or open an existing VB project which has no build errors and then

Dim x=CREATEOBJECT("Excel.Application")

Stop

F5 to hit the breakpoint, Debug->Window->Immediate to open the immediate window.

Then resize VS so you can see Excel, type

x.Visible=1

x.Workbooks.Add

x.Cells(1,1).Value="Hi"

Try something similar in C# (add a reference to Microsoft.VisualBasic.Dll)

Object x = Microsoft.VisualBasic.Interaction.CreateObject("excel.application","");

var z = "Put a bpt here";

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>

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.

Cartoon animation program

Calvin_Hsia — Thu, 29 Jan 2009 23:16:00 GMT

A cartoon can be thought of as a series of drawings. To simulate movement, the drawings can be slightly different from each other.

Remember drawing simple cartoons using a pad of paper? Simply flipping through the pages made the drawings come to life.

This was tedious work: a computer can help.

Just after first IBM PC came out in Aug 81, I wrote a cartoon animation program in C++ and assembly code. The concept was very simple: just use the mouse (I had to write my own mouse driver for a RS-232 serial mouse and had to hijack the COM1 port for my DOS program) to let the user draw some lines on the screen. Then the user could save those lines as a cartoon frame, and then draw another frame. The program could then calculate multiple frames in between the user created frames, creating smooth animation.

That early 80's version of cartoon still runs on XP (although it writes directly to the video memory so it requires full screen mode.

It doesn't run on Vista (I think you can download a DOS compatible window to make it work.)

A zip file of the 80's version is available here. Unzip the contents to a folder (check out the date stamps!), then run cartoon.exe and hit Shift-A.

It includes some stored samples, like flying birds, alphabet, basketball. Because this was written before Windows, it won't work with your mouse. You can see the main menu bar at the top. The only thing you can do with this program is run the stored samples by hitting Shift-A. Q will Quit. Try typing other chars to invoke various commands.

If you get it to run on Vista, please let me know the details.

About 10 years ago, I wrote another version of Cartoon in Foxpro and it was modified and published as a Solution Sample.

Start Visual Foxpro, Task Pane, Solution Samples. In the "Search for sample" text, box, type in Animation. "Display line animation in a form"

You can run the form, or click on the button on the right of the task pane that opens the form in the Form Designer, so you can see the source code.

You can also open the form in the Class Browser, then export the code into a single file using the "View Class Code" button.

Foxpro excerpt of the inbetween algorithm (notice how cursors (in-memory data tables) are used)

SELECT (lcTable)

DO WHILE !EOF("shadow")

mr = recno()

mr2 = recno("shadow")

FOR nb = 0 TO nBetween

THISFORMSET.frmAnimation.cls

GO mr

IF mr2 < RECCOUNT("shadow")

GO mr2 IN shadow

ENDIF

nFrames1 = &lcTable..frameno

nFrames2 = shadow.frameno

SCAN WHILE &lcTable..frameno = nFrames1

nx1 = &lcTable..x1 + nb * (shadow.x1 - &lcTable..x1) / nBetween

ny1 = &lcTable..y1 + nb * (shadow.y1 - &lcTable..y1) / nBetween

nx2 = &lcTable..x2 + nb * (shadow.x2 - &lcTable..x2) / nBetween

ny2 = &lcTable..y2 + nb * (shadow.y2 - &lcTable..y2) / nBetween

THISFORMSET.frmAnimation.line(nx1,ny1,nx2,ny2)

IF !EOF("shadow")

SKIP IN shadow

IF shadow.frameno # nFrames2

SKIP -1 IN shadow

ENDIF

ENDSCAN

SELECT shadow

IF !EOF()

SKIP

LOCATE REST FOR shadow.Frameno # nFrames2

ENDIF

SELECT (lcTable)

wait wind "" time .05

ENDFOR

ENDDO

USE IN shadow

SCAN REST

THISFORMSET.frmAnimation.line(x1,y1,x2,y2)

ENDSCAN

THISFORMSET.frmAnimation.frameno = nFrames1 + 1

Below is a more up to date example using WPF. The equivalent animation code is in tmr_tick().

Try running it, hitting the Demo button.

Start Visual Studio 2008.

Choose File->New Project->Visual Basic->WPF Application.

(This also works with Temporary projects)

Open Window1.xaml.vb. Paste in the code below, then hit F5 to run.

I had my wife and kids playing with it for quite a while!

Try adding a frame or MouseWheel while a cartoon is playing.

Try right click and then draw: it changes the way you draw.

Experiment with using a touchpad and a mouse for drawing.

Try using variable frame rates. Add a feature to save/restore the current cartoon.

Try drawing your name, or the letters of the alphabet.

My original had features like copy/paste from frames, color fill

See also:

My toys over the years

Why was the original IBM PC 4.77 Megahertz?

Class Window1

Private WithEvents btnNewFrame As Button

Private WithEvents btnErase As Button

Private WithEvents btnPlay As Button

Private WithEvents btnDemo As Button

Private WithEvents btnReset As Button

Private txtStatus As TextBlock

Private _AnimControl As AnimControl

Sub Load() Handles MyBase.Loaded

Me.Width = 800

Me.Height = 600

Dim xaml = _

<DockPanel

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" LastChildFill="True">

<TextBlock>Draw to create lines for a cartoon frame. Add a new frame, hit play</TextBlock>

<TextBlock>Rebirth of Calvin's cartoon program circa 1982

<Hyperlink>http://blogs.msdn.com/calvin_hsia</Hyperlink>

</TextBlock>

</StackPanel>

<Button Name="btnNewFrame" ToolTip="Add current drawing to cartoon, so you can create a new one">_New Frame</Button>

<Button Name="btnErase">_Erase</Button>

<Button Name="btnReset" ToolTip="Erase all frames">_Reset</Button>

</StackPanel>

</Border>

</DockPanel>

Dim dPanel = CType(System.Windows.Markup.XamlReader.Load(xaml.CreateReader), DockPanel)

Dim MyCtrl = CType(dPanel.FindName("MyCtrl"), UserControl)

_AnimControl = New AnimControl(Me)

MyCtrl.Content = _AnimControl

btnPlay = CType(dPanel.FindName("btnPlay"), Button)

btnNewFrame = CType(dPanel.FindName("btnNewFrame"), Button)

btnPlay = CType(dPanel.FindName("btnPlay"), Button)

btnDemo = CType(dPanel.FindName("btnDemo"), Button)

btnErase = CType(dPanel.FindName("btnErase"), Button)

btnReset = CType(dPanel.FindName("btnReset"), Button)

txtStatus = CType(dPanel.FindName("txtStatus"), TextBlock)

Me.Content = dPanel

End Sub

Sub btnNewFrame_Click() Handles btnNewFrame.Click

_AnimControl.NewFrame()

RefreshStatus()

End Sub

Sub btnPlay_Click() Handles btnPlay.Click

btnNewFrame_Click() ' save any currently drawn changes first

_AnimControl.Play()

End Sub

Sub btnDemo_Click() Handles btnDemo.Click

_AnimControl.Demo()

End Sub

Sub btnErase_Click() Handles btnErase.Click

_AnimControl.EraseBtn()

End Sub

Sub btnReset_Click() Handles btnReset.Click

_AnimControl.Reset()

End Sub

Friend Sub RefreshStatus()

Me.txtStatus.Text = String.Format("Frame count = {0} CurLineCnt = {1} CurFrame= {2} Between = {3}", _

_AnimControl._UserFrameList.Count, _AnimControl._CurLineList.Count, _

_AnimControl._ndxUserFrame, _AnimControl._nBetween)

End Sub

End Class

Public Class AnimControl

Inherits FrameworkElement

Private WithEvents _timer As New System.Windows.Threading.DispatcherTimer

Private _Window1 As Window1

Friend _nBetween As Integer = 10 ' # of frames being calc'd between user frames

Friend _ndxUserFrame As Integer ' index into user created frames.

Private _ndxBetween As Integer ' from 0 to nBetween

Friend _nBetweenDyn As Integer = 0 ' # to add to _nBetween for next animation: adjustable by mousewheel

Private _ptCurrent As Point?

Private _ptOld As Point?

Private _fPenDown As Boolean

Private _oPen = New Pen(Brushes.Black, 2)

Private _PenModeDrag As Boolean = True ' Click to create line segs, or continuous drag to create multiple segs

' lines to draw for current image: could be while composing, or playing. Could be real frame or calc'd frame

Friend _CurLineList As New List(Of cFrameLine)

'Frames stored by user

Friend _UserFrameList As New List(Of cCartoonFrame)

Sub New(ByVal w As Window1)

_Window1 = w

End Sub

Sub Reset()

Me._timer.IsEnabled = False 'stop playback, if any

Me._UserFrameList.Clear() ' erase all user data

Me._nBetweenDyn = 0

EraseBtn()

End Sub

Sub EraseBtn() ' erase current frame

_CurLineList.Clear()

Me._ptOld = Nothing

Me._fPenDown = False

Me.InvalidateVisual()

End Sub

Sub Demo()

Reset()

Me._CurLineList.Add(New cFrameLine(New Point(10, 10), New Point(10, 300)))

Me._CurLineList.Add(New cFrameLine(New Point(10, 300), New Point(300, 300)))

Me._CurLineList.Add(New cFrameLine(New Point(300, 300), New Point(300, 10)))

Me._CurLineList.Add(New cFrameLine(New Point(300, 10), New Point(10, 10)))

Me._UserFrameList.Add(New cCartoonFrame(Me._CurLineList, 30))

Me._CurLineList.Clear() ' reset for next frame

Me._CurLineList.Add(New cFrameLine(New Point(10, 10), New Point(300, 10)))

Me._CurLineList.Add(New cFrameLine(New Point(300, 10), New Point(300, 300)))

Me._CurLineList.Add(New cFrameLine(New Point(300, 300), New Point(10, 300)))

Me._CurLineList.Add(New cFrameLine(New Point(10, 300), New Point(10, 10)))

Me._UserFrameList.Add(New cCartoonFrame(Me._CurLineList, 50))

Me._CurLineList.Clear() ' reset for next frame

Me._CurLineList.Add(New cFrameLine(New Point(10, 10), New Point(300, 10)))

Me._UserFrameList.Add(New cCartoonFrame(Me._CurLineList, 10))

Play()

End Sub

Sub NewFrame()

If _CurLineList.Count > 0 Then

Dim curFrame = New cCartoonFrame(_CurLineList, 10)

_UserFrameList.Add(curFrame)

EraseBtn()

End If

End Sub

Friend Sub Play()

If _UserFrameList.Count < 2 Then

MsgBox("Need at least 2 frames to animate")

Return

End If

If _timer.IsEnabled Then ' if we're already playing, stop

_timer.IsEnabled = False

Else

_timer.Interval = New TimeSpan(0, 0, 0, 0, 50) ' days,hrs,mins,secs,msecs

_timer.IsEnabled = True

End If

Me._fPenDown = False

Me._ndxUserFrame = 0

Me._ndxBetween = 1 ' 1st is drawn now, next by timer tick

Me._CurLineList.Clear()

Me._CurLineList.AddRange(Me._UserFrameList(0)._Lines) 'get the 1st frame

Me.InvalidateVisual() ' show it

End Sub

Sub tmr_tick() Handles _timer.Tick ' let's do the animating

If _ndxUserFrame = Me._UserFrameList.Count - 1 Then ' we've reached the end: let's restart

Me._ndxUserFrame = 0

Me._ndxBetween = 0

End If

Me._CurLineList.Clear()

Dim frmLeft = Me._UserFrameList(Me._ndxUserFrame) ' the frame on the left

Dim frmRight = Me._UserFrameList(Me._ndxUserFrame + 1) ' the frame on the right

_nBetween = Math.Max(0, frmLeft._nBetween + Me._nBetweenDyn) ' recorded value plus mousewheel adjustment

Dim nLinesToDraw = Math.Max(frmLeft._Lines.Count, frmRight._Lines.Count) - 1

For ndx = 0 To nLinesToDraw ' calc the lines to draw

Dim lineLeft = frmLeft._Lines(Math.Min(ndx, frmLeft._Lines.Count - 1))

Dim lineRight = frmRight._Lines(Math.Min(ndx, frmRight._Lines.Count - 1))

Dim pt0 As New Point With _

{.X = lineLeft.pt0.X + Me._ndxBetween * (lineRight.pt0.X - lineLeft.pt0.X) / (_nBetween + 1), _

.Y = lineLeft.pt0.Y + Me._ndxBetween * (lineRight.pt0.Y - lineLeft.pt0.Y) / (_nBetween + 1)}

Dim pt1 As New Point With _

{.X = lineLeft.pt1.X + Me._ndxBetween * (lineRight.pt1.X - lineLeft.pt1.X) / (_nBetween + 1), _

.Y = lineLeft.pt1.Y + Me._ndxBetween * (lineRight.pt1.Y - lineLeft.pt1.Y) / (_nBetween + 1)}

Dim newLine = New cFrameLine(pt0, pt1)

Me._CurLineList.Add(newLine)

If Me._ndxBetween > Me._nBetween Then ' we've reached the right

Me._ndxUserFrame += 1 ' advance to next user frame

Me._ndxBetween = 0 ' we don't want to redraw frmRight when it becomes frmLeft

End If

Me._ndxBetween += 1 ' advance to next frame

Me.InvalidateVisual()

End Sub

Protected Overrides Sub OnRender(ByVal drawingContext As System.Windows.Media.DrawingContext)

drawingContext.DrawRectangle(Brushes.AliceBlue, New Pen(Brushes.Purple, 1), New Rect(0, 0, Me.RenderSize.Width, Me.RenderSize.Height))

For Each fr In Me._CurLineList ' draw the lines in the current frame

drawingContext.DrawLine(_oPen, fr.pt0, fr.pt1)

If Me._fPenDown Then

If Me._ptOld.HasValue Then

drawingContext.DrawLine(_oPen, Me._ptOld, Me._ptCurrent)

Else

drawingContext.DrawLine(_oPen, Me._ptOld, Me._ptCurrent)

End If

_Window1.RefreshStatus()

End Sub

Protected Overrides Sub OnMouseDown(ByVal e As System.Windows.Input.MouseButtonEventArgs)

If e.RightButton = MouseButtonState.Pressed Then

Me._PenModeDrag = Not Me._PenModeDrag ' toggle modes on right click

Else

If Me._PenModeDrag Then

Me._ptOld = e.GetPosition(Me)

Else

If e.RightButton = MouseButtonState.Pressed Then

Me._fPenDown = False

Me._ptOld = Nothing

Else

Me._fPenDown = True

Me._ptCurrent = e.GetPosition(Me) ' get cur pos rel to self

If Not Me._ptOld.HasValue Then

Me._ptOld = Me._ptCurrent ' same

End If

Me.InvalidateVisual()

End If

End Sub

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

If Me._PenModeDrag Then

If e.LeftButton = MouseButtonState.Pressed Then

If Me._ptOld.HasValue Then

Me._ptCurrent = e.GetPosition(Me)

Dim newFrameLine = New cFrameLine(Me._ptOld, Me._ptCurrent)

Me._CurLineList.Add(newFrameLine)

Me._ptOld = Me._ptCurrent

Me.InvalidateVisual()

End If

Else

If Me._fPenDown Then

If Me._ptOld.HasValue Then

Me._ptCurrent = e.GetPosition(Me)

End If

Me.InvalidateVisual()

End If

End Sub

Protected Overrides Sub OnMouseUp(ByVal e As System.Windows.Input.MouseButtonEventArgs)

If Me._fPenDown Then

Me._ptCurrent = e.GetPosition(Me) ' get cur pos rel to self

Dim newFrameLine = New cFrameLine(Me._ptOld, Me._ptCurrent)

Me._CurLineList.Add(newFrameLine)

Me._ptOld = Me._ptCurrent

Me._fPenDown = False

Me.InvalidateVisual()

End If

End Sub

Protected Overrides Sub OnMouseWheel(ByVal e As System.Windows.Input.MouseWheelEventArgs)

If Me._timer.IsEnabled Then ' only when playing

Me._nBetweenDyn += If(e.Delta > 0, 2, -2)

End If

End Sub

<DebuggerDisplay("{ToString()}")> _

Public Class cCartoonFrame ' User created cartoon frame

Public ReadOnly _Lines As New List(Of cFrameLine) ' a frame is a list of lines

' # of frames to gen between real user frames

Public ReadOnly _nBetween As Integer

Sub New(ByVal lst As List(Of cFrameLine), ByVal nBetween As Integer)

_Lines.AddRange(lst)

_nBetween = nBetween

End Sub

Public Overrides Function ToString() As String

Return String.Format("LineCount = {0}", _Lines.Count)

End Function

End Class

'A line to be animated. Could belong to a real or gen'd user frame, or while user is actively drawing

<DebuggerDisplay("{ToString()}")> _

Public Class cFrameLine ' User created cartoon line. It's just 2 points.

Friend ReadOnly pt0 As Point

Friend ReadOnly pt1 As Point

Sub New(ByVal pt0 As Point, ByVal pt1 As Point)

Me.pt0 = pt0

Me.pt1 = pt1

End Sub

Public Overrides Function ToString() As String

Return String.Format("Line = ({0}) - ({1})", pt0.ToString, pt1.ToString)

End Function

End Class

</Cartoon Code>

Overload Operator new to detect memory leaks

Calvin_Hsia — Tue, 20 Jan 2009 05:47:00 GMT

There are various leak detection methods for memory allocators. A popular one is to tag each allocation with some information about the caller. When there’s a memory leak, you just need to look at that tag info to find the line of code that allocated the memory.

However, this requires that the caller pass in the parameters, such as file and line number, for each allocation. (Perhaps we want to do this only on debug builds.) Also, there could be thousands of callers: we want to avoid changing all the call sites.

The __FILE__ and __LINE__ predefined macros and default parameters can help eliminate the need to modify thousands of lines of source code. They are the file and line number of the currently compiled line. Then we can store the file/line with every allocation.

We can create an allocation method with 2 default parameters, and use these predefined macros as the defaults:

void * MyAlloc(size_t cbSize, char *szFile = __FILE__, UINT nLineNo = __LINE__)

Now a caller to MyAlloc will automatically pass in the file and line number parameters with no change to the original source.

void *ptemp = MyAlloc(100);// let's allocate 100 bytes (Default params are __FILE__ and __LINE__

Although this works with direct calls to MyAlloc, many allocations are via the “new” operator. We can override the default module implementation with our own:

// the single override of the module's new operator:

void * _cdecl operator new (size_t cbSize)

void *p = MyAlloc(cbSize, __FILE__, __LINE__); // this line will show for all New operator calls<sigh>

return p;

}

Using this technique, every “new” allocation will point to this same file/line of code. Not very useful: we want to know which line of code called “new”, not where the “new” operator override is.

But how do we pass in default parameters (so we don’t have to modify thousands of lines of source)?

If we try this:

void * _cdecl operator new (size_t cbSize, char *szFile = __FILE__, UINT nLineNo = __LINE__)

we get a linker error:

1>d:\dev\vc\overnew\overnew.cpp(99) : error C2668: 'operator new' : ambiguous call to overloaded function

1> d:\dev\vc\overnew\overnew.cpp(45): could be 'void *operator new(size_t,char *,UINT)'

1> d:\dev\vc\overnew\predefined c++ types (compiler internal)(23): or 'void *operator new(size_t)'

1> while trying to match the argument list '(unsigned int)'

That makes sense: the linker has no idea which operator new to call because there’s only 1 parameter: the size, and both implementations match operator new with 1 integer parameter.

We also have problems when trying to link in COM, ATL or STD Lib code which also call “new”

One way to avoid this is to use an overload (not an override). What’s the difference?

An override replaces existing functionality, whereas the overload adds functionality, and the called code is determined by it’s signature.

If we add a parameter to operator New (like a simple integer), then we have overloaded it. If we then modify every caller to pass in the parameter, then we can use the predefined macros and default parameter trick:

void * _cdecl operator new (size_t cbSize, int nAnyIntParam, char *szFile = __FILE__, UINT nLineNo = __LINE__)

The big drawback is we have to modify all the call sites.

If the call sites already have a parameter and are thus calling the overload, then no big deal: this is what the FoxPro code base does: each memory handle is marked with the kind of memory (Data Engine, Property Sheet, Form Designer, UserCode, etc). It was simple to add the File/LineNo default parameters to debug builds.

However, this still doesn’t work with COM, ATL, STD code. IMalloc, IMallocSpy can be used for mapping COM calls through our code.

A solution is to recall that the main task at hand is to find which line of code allocated a leaking block: instead of recording __LINE__, which could be the same for all new calls, let’s use the same recording mechanism to record the caller’s address (they’re both just 32 bit DWORDS.)

// the single override of the module's new operator:

void * _cdecl operator new (size_t cbSize)

{

UINT *EbpRegister ; // the Base Pointer: the stack frame base

_asm { mov EbpRegister, ebp};

UINT CallerAddr = *(((size_t *)EbpRegister)+1) ; // the return addr

void *p = MyAlloc(cbSize, __FILE__, CallerAddr);

return p;

}

Below is a sample that you can build and run using Visual Studio. (I suspect all versions will work.)

It demonstrates allocating and freeing memory from direct calls, from operator new, and from overloaded operator new.

Start VS, choose File->New->Project->C++->Win32->Console Application. Call it OverNew

In the wizard choose add common header files for ATL, click Finish.

Paste in the Sample1 code below:

Now hit F5 to run the code.

If you uncomment any of the Delete lines, the program will leak: the memory is never released.

There is no warning or error that the memory leaks. In this simple scenario, the leak doesn’t matter because the process just exits. However, in more complex scenarios, the leak can be crippling.

Now when you run the code, you get output like this:

MyAlloc 1056a8 Size = 100 d:\dev\vc\overnew\overnew.cpp(23)

MyAlloc 105850 Size = 4 d:\dev\vc\overnew\overnew.cpp(61)

Op new 105958

Constructor 105958

MyAlloc 105998 Size = 4 d:\dev\vc\overnew\overnew.cpp(61)

Op new 105aa0

Constructor 105aa0

MyAlloc 105ae0 Size = 4 d:\dev\vc\overnew\overnew.cpp(69)

Op new overload 105be8

Constructor 105be8

Destructor 105958

Op del 105958

MyDelete 105958 d:\dev\vc\overnew\overnew.cpp(61)

Destructor 105aa0

Op del 105aa0

MyDelete 105aa0 d:\dev\vc\overnew\overnew.cpp(61)

Op del 1057b0

MyDelete 1057b0 d:\dev\vc\overnew\overnew.cpp(23)

Destructor 105be8

Op del 105be8

MyDelete 105be8 d:\dev\vc\overnew\overnew.cpp(69)

Note: this sample doesn’t overload the operator new []() version which allocates arrays. That’s for you to do.

void* _cdecl operator new[](size_t cbSize)

See also:

Examine .Net Memory Leaks

Very Advanced Debugging tips

// OverNew.cpp : Defines the entry point for the console application.

#include "stdafx.h"

// version of OutputDebugString that allows variable # args

void OutputDebugStringf(char *szFmt, ...)

{

va_list marker;

va_start(marker, szFmt); // the varargs start at szFmt

char szBuf[1024];

_vsnprintf_s(szBuf, sizeof(szBuf),szFmt, marker);

OutputDebugStringA("\n");

OutputDebugStringA(szBuf);

}

struct AllocHeader // we'll put a header at the beginning of each alloc

{

char szFile[MAX_PATH];

UINT nLineNo;

};

void * MyAlloc(size_t cbSize, char *szFile = __FILE__, UINT nLineNo = __LINE__)

{

// We allocate a header followed by the desired allocation

void *p = malloc(sizeof(AllocHeader) + cbSize );

AllocHeader *pHeader = (AllocHeader *)p;

strcpy_s(pHeader->szFile, szFile);

pHeader->nLineNo = nLineNo;

OutputDebugStringf("MyAlloc %x Size = %d %s(%d)", p, cbSize, szFile, nLineNo);

// we return the address + sizeof(AllocHeader)

return (void *)( (size_t)p+sizeof(AllocHeader));

}

void MyDelete(void *p)

{

// we need to free our allocator too

AllocHeader *pHeader = (AllocHeader *)((size_t)p - sizeof(AllocHeader));

OutputDebugStringf("MyDelete %x %s(%d)", p, pHeader->szFile, pHeader->nLineNo);

free((void *)((size_t)p - sizeof(AllocHeader)));

}

// the single override of the module's new operator:

void * _cdecl operator new (size_t cbSize)

//void * _cdecl operator new (size_t cbSize, char *szFile = __FILE__, UINT nLineNo = __LINE__)

{

//#define USEWORKAROUND 1 // uncomment this to get the caller addr

#if USEWORKAROUND

UINT *EbpRegister ; // the Base Pointer: the stack frame base

_asm { mov EbpRegister, ebp};

UINT CallerAddr = *(((size_t *)EbpRegister)+1) ; // the return addr

// if you get a leak, you'll get something like:

// d:\dev\vc\overnew\overnew.cpp(10189270)

// Break into the debugger. Take the # in parens, put it in Watch window: turn on hex display->it shows addr of caller

// Go to disassembly, put the address in the Address bar hit enter. Bingo: you're at the caller that didn't free!

// CallerAddr -= (size_t)g_hinstDll; // you can get a relative address if you like: look at the link map

void *p = MyAlloc(cbSize, __FILE__, CallerAddr);

OutputDebugStringf("Op new %x CallerAddr = %x", p, CallerAddr);

#else

void *p = MyAlloc(cbSize, __FILE__, __LINE__); // this line will show for all New operator calls<sigh>

OutputDebugStringf("Op new %x", p);

#endif

return p;

}

// an overload of the new operator, with an int param

void * _cdecl operator new (size_t cbSize, int nAnyIntParam, char *szFile = __FILE__, UINT nLineNo = __LINE__)

{

void *p = MyAlloc(cbSize, szFile, nLineNo); // this line will show for all New operator calls<sigh>

OutputDebugStringf("Op new overload %x", p);

return p;

}

void _cdecl operator delete(void *p)

{

OutputDebugStringf("Op del %x", p);

MyDelete(p);

}

class TestClass

{

public:

int mem1;

TestClass() { // Constructur

OutputDebugStringf("Constructor %x", this);

}

~TestClass() { // destructor

OutputDebugStringf("Destructor %x", this);

}

};

int _tmain(int argc, _TCHAR* argv[])

{

void *ptemp = MyAlloc(100);// let's allocate 100 bytes (Default params are __FILE__ and __LINE__

TestClass *aTestClass = new TestClass(); //allocate space for an instance

TestClass *aTestClass2 = new TestClass(); //allocate space for another instance

TestClass *aTestClass3 = new (1) TestClass(); //allocate space for another instance, using custom New

delete aTestClass; // comment out this line for mem leak

delete aTestClass2; // comment out this line for mem leak

delete ptemp; // comment out this line for mem leak

delete aTestClass3; // comment out this line for mem leak

return 0;

}

</Sample1>

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!

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

How fast is interop code?

Calvin_Hsia — Wed, 28 May 2008 22:24:00 GMT

How fast is interop code? If you’re in one kind of code and your calling another, what is the cost of the interop?

For example, .Net code can call native C++ code (like Windows APIs) and vice versa. Similarly with Foxpro and C++ code. .Net code is often referred to as Managed code because much is managed for the programmer, such as memory allocation. That leaves C++ code to be called “Unmanaged”. An easy way to interop with C++ code is to use COM (Component Object Model, or sometimes ActiveX) as glue. Whether it’s COM calling .Net or vice versa, the managed boundary is traversed twice: there and back. Similarly with Fox code calling COM code.

Fox code calling .Net code (e.g. A Visual Basic COM object is simple to create, call and debug from Excel) will have both Fox to COM and COM to .Net interop.

I want to measure raw interop performance, so I want to remove memory allocation and Unicode/String marshalling issues from the tests. I want to have a loop on one side call a very fast method on the other, so that most of the execution time is in the interop, not the loop or the method call. I want to use in-process, same thread calls, so remote procedure calls/marshalling are not being measured.

We’ll create a native C++ method that just returns consecutive integers. A simple loop in the .Net or Fox client that calls this method keeps a running total would be a good perf test.

Start with this sample ActiveX control code: Create an ActiveX control using ATL that you can use from Fox, Excel, VB6, VB.Net. You don’t need the events and methods from that sample, just the control itself.

(If you’re using VS2008, in the ATL Project wizard, select DLL and just choose “Finish”. When adding a method in Class View, make sure to choose the ITestCtrl Interface (defined in MyCtrl.IDL, not ITestCtrl VCCodeStruct defined in MyCtrl_i.h. Similarly, if you’re adding an event, make sure to choose the _ITestCtrlEvents interface under MyCtrlLib in Class View. Also, you need to run the “Implement ConnectionPoint Wizard” and change the call to “Fire_MyEvent”, see http://msdn.microsoft.com/en-us/library/9h7xedd1.aspx)

When COM code is called from VB.Net or FoxPro, the calls are not quite direct: COM is used for creating the object and initialization and there is some parameter/return value massaging required per call. Then it’s either a straight virtual function call (vTable) call to IDispatch (late bound) or IUnknown (early bound). IOW, the performance would be slower than the a direct PInvoke or DECLARE DLL call.

Let’s add a simple method RetInt with no parameters that just returns an int. Add a method to our COM Control by right clicking on the ITestCtrl interface in Class View and choosing Add->Method to start the “Add Method Wizard”

Since all COM interface method calls return HRESULTS, to return a value an additional parameter is added and marked with the RetVal attribute and is passed by ref. So make the Method Name “RetInt”, the Parameter type “LONG *”, and the Parameter Name “RetVal”. Choose the Retval checkbox. Then choose “Add” to add the param to the method.

Add another method DoSum similarly. This method will run with no interop, so we have a baseline for comparison. (It runs the loop multiple times because it goes so much faster, but the timing measurement divides out the multiple runs.)

The resulting code is added to TestCtrl.CPP. Add the implementation:

static LONG g_Int = 0;

STDMETHODIMP CTestCtrl::RetInt(LONG* RetVal)

{

*RetVal = ++g_Int; // just return consecutive integers

return S_OK;

}

// DoSum will calculate the value with no interop whatsoever

STDMETHODIMP CTestCtrl::DoSum(LONG nTimes,LONG nInternalLoopCount, DOUBLE* Retval)

{

LONGLONG nSum;

for (LONG j = 0 ; j < nInternalLoopCount ; j++) // this code runs so fast we have to do it multiple times

{

nSum = 0;

for (LONG i = 1 ; i <= nTimes ; i++)

{

nSum += i;

}

*Retval = (DOUBLE)nSum;

return S_OK;

}

// RetIntStatic can be called directly via PInvoke or Declare Dll

extern "C" HRESULT __declspec(dllexport) WINAPI RetIntStatic(LONG *RetVal)

{

*RetVal = ++g_Int;

return S_OK;

}

You can add more methods, like a way to reset g_Int to get more accurate results, but I don’t really care about the results, just how long it takes to get them.

Of course, you’ll want to run perf tests using optimized Release builds, so you’re not including debug asserts, etc. A really smart optimizing compiler would remove the loops in DoSum altogether!

If you have Foxpro, try running this Fox code. Notice that DoLoop can take either the Form or the Control as a parameter. There’s a RetInt method on each.

CLEAR ALL

CLEAR

MODIFY COMMAND PROGRAM() NOWAIT

_screen.FontName="Courier New" && Make font monospace, not proportional

SET DECIMALS TO 6

g_Int=0

ox=CREATEOBJECT("MyForm")

*ox.visible=1

nLoops=1000000

nInternalLoopCnt=1000

ns=SECONDS()

zObj=ox.oc && use temp var so we don't deref ox.oc in loop

r = zObj.DoSum(nLoops,nInternalLoopCnt)

?"Internal DoSum ",r,(SECONDS()-ns)/nInternalLoopCnt

?DoLoop(ox,nLoops, "With No Interop" )

?DoLoop(ox.oc,nLoops,"With COM Interop")

*Use early binding:

oy=CREATEOBJECTEx("MyCtrl.TestCtrl","","")

?DoLoop(oy,nLoops,"With COM Interop Early Bound")

*Try Declare DLL: like PInvoke

DECLARE integer _RetIntStatic@4 IN "d:\dev\vc\myctrl\release\myctrl.dll" as RetIntStatic integer @ Retval

?DoLoopStatic(nLoops,"With DeclareDLL interop")

FUNCTION DoLoop(zObj as object,nTimes as Integer, sDesc as String) as String

LOCAL nSum

nSum=0

ns=SECONDS()

FOR i = 1 TO nTimes

nSum = nSum + zObj.RetInt()

ENDFOR

RETURN sDesc+" Sum= "+TRANSFORM(nSum) + " "+ TRANSFORM(SECONDS()-ns)

RETURN

FUNCTION DoLoopStatic(nTimes as Integer, sDesc as String) as String

LOCAL nSum

nSum=0

nRetval=0

ns=SECONDS()

FOR i = 1 TO nTimes

RetIntStatic(@nRetval)

nSum = nSum + nRetval

ENDFOR

RETURN sDesc+" Sum= "+TRANSFORM(nSum) + " "+ TRANSFORM(SECONDS()-ns)

RETURN

DEFINE CLASS MyForm as Form

ADD OBJECT OC as olecontrol WITH ;

oleClass="MyCtrl.TestCtrl",;

height=200,width=300

left=200

AllowOutput=.f.

PROCEDURE RetInt as Integer

g_Int = g_Int+1

RETURN g_Int

ENDDEFINE

The DoSum call (Fox and VB) was consistent as expected: they both execute in about the same time because there is only one interop call.

I consistently saw the COM Interop loop taking about 50% longer than the non interop loop. This makes sense. The code that calls the COM object has to deal with all sorts of parameter types, marshalling, etc. The non interop did the entire calculation within Fox code.

The DoSum method has its own internal loop to do the calculation, which does NO interop of any kind in the loop, runs roughly 2000 times faster. That implies there are about 2000 times more instructions executed in the loop.

Now I want to run a similar test using VB.Net. Let’s add a new project to the ActiveX control project from above.

Choose the Solution Explorer, right click on the solution, choose Add New Project, VB->Windows Forms Application. I put my VB Project within the folder of the TestCtrl project.

Right click on the project, and choose “Set As Startup Project” so hitting F5 will start this project.

If you’re on a 64 bit OS, then make sure you target x86 (Project->Properties->Compile->Advanced Compile Options->Target CPU->x86

Add the ActiveX control to your toolbox: Right click on the toolbox, choose items\COM Components…TestCtrl class.

Now drag the control from the toolbox onto the form. Dbl Click on the form and paste in this code:

Public Class Form1

'Note the path: "..\..\..\Release\MyCtrl.dll"

<Runtime.InteropServices.DllImport( _

"..\..\..\Release\MyCtrl.dll", _

CallingConvention:=Runtime.InteropServices.CallingConvention.Winapi, _

entrypoint:="_RetIntStatic@4")> _

Friend Shared Function RetIntStatic(ByRef RetVal As Integer) As Integer

End Function

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

Dim nLoops = 1000000

Dim nInternalLoopCnt = 1000

Dim sStopWatch = Stopwatch.StartNew

Dim r = Me.AxTestCtrl1.DoSum(nLoops, nInternalLoopCnt)

Console.WriteLine("Internal DoSum Native=" + r.ToString + " " + (sStopWatch.ElapsedMilliseconds / 1000 / nInternalLoopCnt).ToString)

sStopWatch = Stopwatch.StartNew

r = Me.DoSum(nLoops, nInternalLoopCnt)

Console.WriteLine("Internal DoSum .Net =" + r.ToString + " " + (sStopWatch.ElapsedMilliseconds / 1000 / nInternalLoopCnt).ToString)

Console.WriteLine(DoLoop(Me, nLoops, "With Late bound No interop, calling local VB.Net method"))

Console.WriteLine(DoLoop(Me.AxTestCtrl1, nLoops, "With Late bound COM interop"))

Console.WriteLine(DoLoopEarlyForm(Me, nLoops, "With Early bound No interop, calling local VB.Net method"))

Console.WriteLine(DoLoopEarlyCtrl(Me.AxTestCtrl1, nLoops, "With Early bound COM interop"))

Console.WriteLine(DoLoopPInvoke(nLoops, "With PInvoke interop"))

End

End Sub

Function DoLoop(ByVal zObj As Object, ByVal nTimes As Integer, ByVal sDesc As String) As String

Dim nSum = 0L

Dim sStopWatch = Stopwatch.StartNew

For i = 1 To nTimes

nSum += zObj.RetInt

Return sDesc + " Sum = " + nSum.ToString + " " + (sStopWatch.ElapsedMilliseconds / 1000).ToString()

End Function

Function DoLoopEarlyForm(ByVal zObj As Form1, ByVal nTimes As Integer, ByVal sDesc As String) As String

Dim nSum = 0L

Dim sStopWatch = Stopwatch.StartNew

For i = 1 To nTimes

nSum += zObj.RetInt

Return sDesc + " Sum = " + nSum.ToString + " " + (sStopWatch.ElapsedMilliseconds / 1000).ToString()

End Function

Function DoLoopEarlyCtrl(ByVal zObj As AxMyCtrlLib.AxTestCtrl, ByVal nTimes As Integer, ByVal sDesc As String) As String

Dim nSum = 0L 'L for Long so doesn't overflow 32 bits

Dim sStopWatch = Stopwatch.StartNew

For i = 1 To nTimes

nSum += zObj.RetInt

Return sDesc + " Sum = " + nSum.ToString + " " + (sStopWatch.ElapsedMilliseconds / 1000).ToString()

End Function

Function DoLoopPInvoke(ByVal nTimes As Integer, ByVal sDesc As String) As String

Dim nSum = 0L 'L for Long so doesn't overflow 32 bits

Dim sStopWatch = Stopwatch.StartNew

For i = 1 To nTimes

Dim RetVal = 0

RetIntStatic(RetVal)

nSum += RetVal

Return sDesc + " Sum = " + nSum.ToString + " " + (sStopWatch.ElapsedMilliseconds / 1000).ToString()

End Function

Private Shared g_Int As Long

Public Function RetInt() As Long

g_Int += 1

Return g_Int

End Function

Function DoSum(ByVal nTimes As Long, ByVal nInternalLoopCount As Long) As Double

Dim nSum As Long

For j = 1 To nInternalLoopCount ' calculated multiple times because it's fast

nSum = 0

For i = 1 To nTimes

nSum += i

Return nSum

End Function

End Class

Run the code with the Output Window visible. Here, the VB code with interop ran maybe 40% slower, and several times slower than the Fox code. I realized that this was because of the late binding calls the VB code does. The VB DoLoop method takes zObj as an Object, and I invoke the RetInt method on it. That means, the VB runtime latebinder code is called to reflect on the object and see if it has a Retint method on it that can be called. Both the Form and the control have a method with this name. The latebinding was code that I didn’t want to measure, so I added some strongly typed calls that forced the calls to be early bound direct calls, which were much faster. For the Non-interop code doing the entire calculation within VB, the late bound was around 1000 times slower than the early bound, due to the late binder code. For the Interop case, the late bound was about 30 times slower than the early.

(Comparing .Net speed with native, the DoSum call (with no interop at all) in .Net was almost 3 times slower than Native, but that’s expected too: native code runs faster than managed.)

These early bound calls are several times faster than the Fox code too: they don’t have to do any parameter packing/checking.

However, even the Fox code doing early binding, Fox still has to do a lot of parameter translation between fox types and COM types.

The Fox and VB calls via PInvoke/Declare DLL were the fastest of all. They have to do the least parameter translation/packing/checking. This makes sense: the method call is declared to have N parameters of certain types, so less work needs to be done.

Using ILDasm to see the IL for the RetInt, you can see that there isn’t much code. The Fox code for RetInt, however, causes much more code to run.

.method public instance int64 RetInt() cil managed

{

// Code size 24 (0x18)

.maxstack 2

.locals init ([0] int64 RetInt)

IL_0000: nop

IL_0001: ldsfld int64 WindowsApplication1.Form1::g_Int

IL_0006: ldc.i4.1

IL_0007: conv.i8

IL_0008: add.ovf

IL_0009: stsfld int64 WindowsApplication1.Form1::g_Int

IL_000e: ldsfld int64 WindowsApplication1.Form1::g_Int

IL_0013: stloc.0

IL_0014: br.s IL_0016

IL_0016: ldloc.0

IL_0017: ret

} // end of method Form1::RetInt

Or use the debugger to see the native code in DoSum: (cdq is ConvertDoubleToQuadWord)

LONGLONG nSum=0;

for (LONG i = 1 ; i <= nTimes ; i++)

{

692B1DF1 8B C1 mov eax,ecx

692B1DF3 99 cdq

692B1DF4 03 D8 add ebx,eax

692B1DF6 13 EA adc ebp,edx

692B1DF8 8D 41 01 lea eax,[ecx+1]

692B1DFB 99 cdq

692B1DFC 03 F0 add esi,eax

692B1DFE 8B 44 24 20 mov eax,dword ptr [esp+20h]

692B1E02 13 FA adc edi,edx

692B1E04 83 C1 02 add ecx,2

692B1E07 48 dec eax

692B1E08 3B C8 cmp ecx,eax

692B1E0A 7E E5 jle CTestCtrl::DoSum+21h (692B1DF1h)

692B1E0C 3B 4C 24 20 cmp ecx,dword ptr [esp+20h]

692B1E10 7F 0B jg CTestCtrl::DoSum+4Dh (692B1E1Dh)

{

nSum += i;

692B1E12 8B C1 mov eax,ecx

692B1E14 99 cdq

692B1E15 89 44 24 10 mov dword ptr [esp+10h],eax

692B1E19 89 54 24 14 mov dword ptr [esp+14h],edx

}

This (optimized) code sums 32 bit values to a 64 bit running sum, so you can see instructions like “ADC”, which is AddWithCarry.

As an exercise, on 64 bit, create code like DoSum that natively handles 64 bit ints (or modify this code to use just 32 bits). You’ll see that the loop is trivial.

Hint: make sure you have the 64 bit tools installed.

How to interrupt your code

Calvin_Hsia — Fri, 16 May 2008 05:42:00 GMT

I received a question:

Simply, is there a way of interrupting a vfp sql query once it has started short of closing down the process ?

I am running some complex queries on very large datasets which can sometimes take many minutes to complete.

Typically, a program that runs on your computer has a main thread of execution.

On this thread, the processor is fetching instructions from memory and executing them. If this thread is busy, perhaps executing a query, or even just in a loop, the processor won’t check for user input.

Imagine the processor to be a person working in a factory. If she’s busy, then she doesn’t have time to look at her email. One way to fix this is to add an item to her workload to look at the email once in a while. If she’s in a loop (repetitive work), then adding an item in the loop would work.

Another way to fix this is to have another person (thread) in the factory. His job is to watch the email for any pending requests. He has the ability to interrupt her work.

Many applications are single threaded. That means there is only one person responsible for doing the work, listening for input, and updating the User Interface. Sometimes he’s very busy, so to the user, the application seems non-responsive.

As above, a solution is to create another thread (think of it as adding another person who can help do the work). This other thread can monitor the email.

The sample below creates a temporary table of many records. It then does a non-optimized Cartesian join of the table with itself, making the main thread busy.

The Set Escape command tells the main thread to check for the Escape key (looking for the boss at the door).

The On Escape command says what to do if the boss is there.

As an alternative, you can inject your own code into the work loop. The WasKeyPressed function, for example, checks for a keypress.

If work is interrupted, the worker may not have finished the current task, perhaps leaving the environment in an abnormal state.

See also other threading samples, which allow you to create multiple threads in VB and FoxPro

Use Visual Studio Test framework to create tests for your code

Sample program to create multiple threads

Create multiple threads from within your application

More Multithread capabilities: interthread synchronization, error checking

Webcrawl a blog to retrieve all entries locally: RSS on steroids

The VB version of the Blog Crawler

CLEAR ALL

CLEAR

MODIFY COMMAND PROGRAM() NOWAIT

CREATE CURSOR foo (name c(10))

INSERT INTO foo (name ) VALUES ("foo")

*Try with ESCAPE ON and OFF

SET ESCAPE ON

?"Escape=",SET("Escape")

ON ESCAPE do OnEscapeHandler

FOR i = 1 TO 12

APPEND FROM DBF("foo") && Double the size each iteration

ENDFOR

?"Reccount=",RECCOUNT()

?"query starting: try to stop it!"

ns=SECONDS()

TRY

* Cartesian product unoptimized join

SELECT * FROM foo, foo bar WHERE foo.name=bar.name INTO CURSOR results

* Sample that calls a method that checks for key press

* SELECT * FROM foo, foo bar WHERE foo.name=bar.name AND WasKeyPressed() INTO CURSOR results

CATCH TO ex

?"Caught",ex.Message,ex.Details,ex.UserValue

ENDTRY

?"Query done"

?SECONDS()-ns

RETURN

PROCEDURE OnEscapeHandler

?"Interrupted"

THROW "interrupted from "+PROGRAM()

RETURN

FUNCTION WasKeyPressed as Boolean

IF INKEY()>0

THROW "Key pressed from "+PROGRAM()

ENDIF

RETURN .T.

Examine .Net Memory Leaks

Calvin_Hsia — Fri, 11 Apr 2008 22:54:00 GMT

Writing programs using .Net is very productive. One reason is because much of memory management is “managed” for you. In C, C++ and other “native” languages, if you allocate memory, you’re responsible for freeing it. There were stopgap measures, like destructors, SmartPointers and reference counting, which helped, but were still cumbersome.

Foxpro manages memory for you, and has used garbage collection for decades: Heartbeat: Garbage collection in VFP and .NET are similar

However, you can still have memory leaks in .Net.

Try this in VS 2008: (I think it will work in 2005 too, can somebody verify? Thanks)

1. File->New->Project->VB Windows Console Application.

2. Paste the sample code below.

3. Project->Properties->Debug->Enable Unmanaged Code debugging

If you’re running 64 bit, you can force 32 bit targeting: Project->Properties->Compile->Advanced Compile Settings->Target CPU->x86 (see this for more about x64)

The sample code has a loop that creates and releases an instance of a class MyWatcher that uses the FileSystemWatcher class that reacts to events, such as files being created in a directory.

The class has a member (Dim MyLargeMemoryEater(100000) As String) which eats up 4 bytes (8 bytes on x64) per array element. At the end of each loop, the garbage collector is called to release everything. The class has a Finalize method that will be called when the garbage collector collects.

When you run the code, you see the increase in memory use in each loop. The increase per iteration is just a little more than the amount of memory used by MyLargeMemoryEater . Also, the Finalizers don’t run until the application is shutting down.

If you uncomment the “UnSubscribe” line, then the finalizer fires (on a different thread) and you can see the leak is gone.

Now let’s examine the leak by looking at the heap.

Make it leak, then put a breakpoint on the “Done” line after the loop. At this point, we suspect there are 100 instances of MyWatcher in the managed heap.

Wouldn’t it be great to see them? Let’s use SOS:

Open the Immediate window: Debug Menu->Windows-> Immediate window

Type in the lines in red

!load sos.dll

extension C:\Windows\Microsoft.NET\Framework\v2.0.50727\sos.dll loaded

!dumpheap -type MyWatcher

PDB symbol for mscorwks.dll not loaded

Address MT Size

02b7431c 000d313c 16

<…>

02bdc3f0 000d313c 16

02bdc550 000d313c 16

total 100 objects

Statistics:

MT Count TotalSize Class Name

000d313c 100 1600 ConsoleApplication1.MyWatcher

Total 100 objects

So now we know that there are 100 instances still around. Why were they not garbage collected? Because somebody has a reference to them. Choose one of the instances (02bdc550), and use the gcroot command:

!gcroot 02bdc550

Note: Roots found on stacks may be false positives. Run "!help gcroot" for

more info.

Error during command: Warning. Extension is using a callback which Visual Studio does not implement.

Scan Thread 6948 OSTHread 1b24

Scan Thread 536 OSTHread 218

Scan Thread 6448 OSTHread 1930

DOMAIN(00601068):HANDLE(AsyncPinned):b15b4:Root:02bdda44(System.Threading.OverlappedData)->

02bddf38(System.Threading.IOCompletionCallback)->

02bdcfc4(System.IO.FileSystemWatcher)->

02b8b14c(System.IO.FileSystemEventHandler)->

02bdc550(ConsoleApplication1.MyWatcher)

Now we see that the FileSystemWatcher is referencing us via an eventhandler.

(The “!dumpheap -stat” command is also very useful to see what’s on the heap)

See also:

Collecting garbage at the wrong time

SOS Debugging Extension (SOS.dll)

http://www.codeproject.com/KB/dotnet/Memory_Leak_Detection.aspx

http://www.julmar.com/blog/mark/PermaLink,guid,643649fc-0467-4f0d-9a95-323ed7ce4298.aspx

Debugging a memory leak in managed code: Ping - SendAsync

Module Module1

Friend g_cnt As Integer

Sub Main()

'uncomment these 2 lines to test the event watcher

'Dim oFileWatcher = New MyWatcher

'MsgBox("Wait in msgbox. FSW events still fire: copy a file into d:\")

Dim oldPeak = 0L

For i = 1 To 100

Dim oWatcher = New MyWatcher

' oWatcher.UnSubscribe() ' uncomment this line to remove handler

oWatcher = Nothing

GC.Collect() ' collect garbage

GC.WaitForPendingFinalizers() ' allow finalizers

GC.Collect() ' collect again for any objects that had finalizers

Dim newpeak = Process.GetCurrentProcess.PeakWorkingSet64

Debug.WriteLine("All released? " + i.ToString + " " + _

" WorkingSet =" + Process.GetCurrentProcess.WorkingSet64.ToString("n0") + _

" Peak=" + newpeak.ToString("n0") + _

" delta =" + (newpeak - oldPeak).ToString)

oldPeak = newpeak

GC.Collect() ' collect garbage

GC.WaitForPendingFinalizers() ' allow finalizers

GC.Collect() ' collect again for any objects that had finalizers

Debug.WriteLine("Done")

End Sub

End Module

Class MyWatcher

Dim MyLargeMemoryEater(100000) As String ' make the instance bigger to magnify issue: 4 bytes per array item on x86

Dim fsw As IO.FileSystemWatcher

Sub New()

fsw = New IO.FileSystemWatcher

fsw.Path = "d:\"

fsw.Filter = "*.*"

AddHandler fsw.Created, AddressOf OnWatcherFileCreated

fsw.EnableRaisingEvents = True

End Sub

Sub UnSubscribe()

RemoveHandler fsw.Created, AddressOf OnWatcherFileCreated

End Sub

Sub OnWatcherFileCreated(ByVal sender As Object, ByVal args As System.IO.FileSystemEventArgs)

Debug.WriteLine((New StackTrace).GetFrames(0).GetMethod.Name + " " + args.FullPath)

End Sub

Protected Overrides Sub Finalize() ' called when garbage collector collects on the GC Finalizer thread.

MyBase.Finalize()

Debug.WriteLine((New StackTrace).GetFrames(0).GetMethod.Name + g_cnt.ToString + " Thread= " + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString)

End Sub

End Class

</Code Sample>

Persist user form size and location settings per session

Calvin_Hsia — Thu, 03 Apr 2008 02:57:00 GMT

My prior post (Create your own Test Host using XAML to run your unit tests) shows how to create a form and present it to the user. The user can resize and reposition the form, even on a 2^nd monitor.

When the user exits the form, we can persist or remember the form size and location, so the next time the user form starts up, it will be positioned/sized as before.

The happens to be a XAML form, but it could be a WinForm for this to work. (The My.Settings feature has been in Visual Studio for many years…)

Because FoxPro has its own database engine, Fox can persist data in a Fox table. The positions and sizes of design time windows, such as the Command Window, Project Window, Database Windows, are persisted in the FoxPro Resource file. The FoxResource class (unzip the xsource.zip file in tools\xsource and look in the EnvMgr folder) can help users persist user forms there too.

To add this feature to your VB project:

Go to Project->Properties->Settings, and add 2 settings:

Location, type=System.Drawing.Point, default = 0,0
Size, type=System.Drawing.Size, default=1024,768

In the Load or New method:

If System.Windows.Forms.Screen.AllScreens.Count = 1 AndAlso _

My.Settings.Location.X > System.Windows.Forms.Screen.PrimaryScreen.WorkingArea.Width Then

Me.Left = 0 ' if the saved .X is out of range (multimonitor, remote desktop)

Else

Me.Left = My.Settings.Location.X

End If

Me.Top = My.Settings.Location.Y

Me.Width = My.Settings.Size.Width

Me.Height = My.Settings.Size.Height

AddHandler Me.Closed, AddressOf OnWindowClosed

Sub OnWindowClosed(ByVal sender As Object, ByVal e As EventArgs)

My.Settings.Location = New System.Drawing.Point(CInt(Me.Left), CInt(Me.Top))

My.Settings.Size = New System.Drawing.Size(CInt(Me.Width), CInt(Me.Height))

My.Settings.Save()

End Sub

The data is stored in an XML file like:

"C:\Documents and Settings\Calvinh\Local Settings\Application Data\Microsoft\<appname>\1.0.0.0\user.config”

which looks like:

<?xml version="1.0" encoding="utf-8"?>

<<appname>.My.MySettings>

</setting>

</setting>

</<appname>.My.MySettings>

</userSettings>

</configuration>

If you’re feeling brave, you can persist multiple strings using System.Collections.Specialized.StringCollection.

I store things like which items are selected and how many asserts are fired per test. Each string will have 3 comma separated items: TestClass,TestName, and AssertCnt

For Each itm In m_TestMethods

Dim theitem = itm

Dim res = From a In My.Settings.AssertsPerTest _

Let strs = CStr(a).Split(","c) _

Where strs(0) = theitem.TestClass And strs(1) = theitem.TestName _

Let Assertcnt = CInt(strs(2))

If res.Count > 0 Then

itm.AssertCnt = res.First.Assertcnt

End If

And just before My.Settings.Save is called, we’ll create the string collection to save.

Dim ColAssertsPerTest = New Specialized.StringCollection

For Each itm In From d In TestMethods Where d.AssertCnt > 0

ColAssertsPerTest.Add(itm.TestClass + "," + itm.TestName + "," + itm.AssertCnt.ToString)

My.Settings.AssertsPerTest = ColAssertsPerTest

Notice the use of Linq in the For Each expressions.

I also use Linq to find the total # of asserts fired:

Dim nTotalAssertsExpected = Aggregate itm In m_SelectedTests Into Sum(itm.AssertCnt)

See also: another example of persisting settings: The VB version of the Blog Crawler