Calvin Hsia's WebLog : Visual Studio

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

Look at some hdden code in your VB project

Calvin_Hsia — Mon, 30 Nov 2009 20:41:00 GMT

Some code is always added to your VB project.

Try this:

Start VS (2008 or 2010 beta: the numbers below are for 2008)

File->New->Project->VB->Console App.

Build->Build Solution.

(I like to use temporary projects: see Use temporary projects in Visual Studio. I’m also using the General Profile (Tools->Import/Export Settings->Reset All Settings)

The build output window shows this:

------ Build started: Project: ConsoleApplication1, Configuration: Debug Any CPU ------

C:\Windows\Microsoft.NET\Framework\v3.5\Vbc.exe /noconfig /imports:Microsoft.VisualBasic,System,System.Collections,System.Collections.Generic,System.Data,System.Diagnostics,System.Linq,System.Xml.Linq /optioncompare:Binary /optionexplicit+ /optionstrict:custom /nowarn:42016,41999,42017,42018,42019,42032,42036,42020,42021,42022 /optioninfer+ /rootnamespace:ConsoleApplication1 /doc:obj\Debug\ConsoleApplication1.xml /define:"CONFIG=\"Debug\",DEBUG=-1,TRACE=-1,_MyType=\"Console\",PLATFORM=\"AnyCPU\",_MYTYPE=\"Empty\"" /reference:"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Core.dll","C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Data.DataSetExtensions.dll",C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Data.dll,C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Deployment.dll,C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll,C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.Xml.dll,"C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Xml.Linq.dll" /main:ConsoleApplication1.Module1 /debug+ /debug:full /filealign:512 /out:obj\Debug\ConsoleApplication1.exe /resource:obj\Debug\ConsoleApplication1.Resources.resources /target:exe Module1.vb "My Project\AssemblyInfo.vb" "My Project\Application.Designer.vb" "My Project\Resources.Designer.vb" "My Project\Settings.Designer.vb"

ConsoleApplication1 -> C:\Users\calvinh\AppData\Local\Temporary Projects\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe

========== Build: 1 succeeded or up-to-date, 0 failed, 0 skipped ==========

You can make your programs smaller by removing some features.

Now right click on the Project in Solution Explorer, and “choose Open Folder in Windows Explorer”, navigate to the ConsoleApplication1.EXE file to see how big it is.

Open a Visual Studio Command Prompt( Program Files->Visual Studio->Visual Studio Tools) and do this:

dir "C:\Users\calvinh\AppData\Local\Temporary Projects\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe"

The size I get is 14,336 bytes.

Now use the Intermediate Language Disassembler :

Ildasm "C:\Users\calvinh\AppData\Local\Temporary Projects\ConsoleApplication1\bin\Debug\ConsoleApplication1.exe"

You can navigate the tree view to see things like MyProject, MySettingsProperty, etc.

For example, even if you’re not using web services, this code is in your binary:

.method private static !!T Create__Instance__<.ctor T>(!!T 'instance') cil managed

{

.custom instance void [mscorlib]System.Diagnostics.DebuggerHiddenAttribute::.ctor() = ( 01 00 00 00 )

// Code size 32 (0x20)

.maxstack 2

.locals init ([0] !!T Create__Instance__,

[1] bool VB$CG$t_bool$S0)

IL_0000: nop

IL_0001: ldarg.0

IL_0002: box !!T

IL_0007: ldnull

IL_0008: ceq

IL_000a: stloc.1

IL_000b: ldloc.1

IL_000c: brfalse.s IL_0018

IL_000e: call !!0 [mscorlib]System.Activator::CreateInstance<!!0>()

IL_0013: stloc.0

IL_0014: br.s IL_001e

IL_0016: br.s IL_001d

IL_0018: nop

IL_0019: ldarg.0

IL_001a: stloc.0

IL_001b: br.s IL_001e

IL_001d: nop

IL_001e: ldloc.0

IL_001f: ret

} // end of method MyWebServices::Create__Instance__

Where does all this code come from? Is there a simple way to get rid of it?

VB Intellisense and background compiler know about this extra stuff too.

Type in this:

Dim r = My.WebService

Notice that after “My.” you see a a list of members of “My.”

Application

Computer

MySettings

Resources

Settings

User

WebServices

You can make the colored ones disappear.

Try this:

Project->Settings->Compiler->Advanced Compiler Options->Custom Constants

Put in _MYTYPE="Empty"

Immediately, you’ll see that there are compile errors for the My.Webservice line and that intellisense doesn’t show the colored members.

Now rebuild and see that the file size is 12,288.

This size difference is multiplied if you have multiple VB projects.

You can see some of the source VB that is used to generate this code:

File->Open->File-> "C:\Windows\Microsoft.NET\Framework\v2.0.50727\Microsoft.VisualBasic.dll"

This will open the DLL in the VS Resource Editor. Navigate in the treeview to RCDATA->300 and you’ll see a binary dump of some code.

If you right click on the 300, choose Export->T.VB, then open T.VB, you see the contents below:

Now you can see the effect of changing “_MYTYPE” in the code.

See also:

Use temporary projects in Visual Studio

Host the CLR and Generate IL to call a MessageBox

<T.vb>

Option Strict On

Option Explicit On

Option Compare Binary

#If TARGET = "module" AndAlso _MYTYPE = "" Then

#Const _MYTYPE="Empty"

#End If

#If _MYTYPE = "WindowsForms" Then

#Const _MYFORMS = True

#Const _MYWEBSERVICES = True

#Const _MYUSERTYPE = "Windows"

#Const _MYCOMPUTERTYPE = "Windows"

#Const _MYAPPLICATIONTYPE = "WindowsForms"

#ElseIf _MYTYPE = "WindowsFormsWithCustomSubMain" Then

#Const _MYFORMS = True

#Const _MYWEBSERVICES = True

#Const _MYUSERTYPE = "Windows"

#Const _MYCOMPUTERTYPE = "Windows"

#Const _MYAPPLICATIONTYPE = "Console"

#ElseIf _MYTYPE = "Windows" OrElse _MYTYPE = "" Then

#Const _MYWEBSERVICES = True

#Const _MYUSERTYPE = "Windows"

#Const _MYCOMPUTERTYPE = "Windows"

#Const _MYAPPLICATIONTYPE = "Windows"

#ElseIf _MYTYPE = "Console" Then

#Const _MYWEBSERVICES = True

#Const _MYUSERTYPE = "Windows"

#Const _MYCOMPUTERTYPE = "Windows"

#Const _MYAPPLICATIONTYPE = "Console"

#ElseIf _MYTYPE = "Web" Then

#Const _MYFORMS = False

#Const _MYWEBSERVICES = False

#Const _MYUSERTYPE = "Web"

#Const _MYCOMPUTERTYPE = "Web"

#ElseIf _MYTYPE = "WebControl" Then

#Const _MYFORMS = False

#Const _MYWEBSERVICES = True

#Const _MYUSERTYPE = "Web"

#Const _MYCOMPUTERTYPE = "Web"

#ElseIf _MYTYPE = "Custom" Then

#ElseIf _MYTYPE <> "Empty" Then

#Const _MYTYPE = "Empty"

#End If

#If _MYTYPE <> "Empty" Then

Namespace My

#If _MYAPPLICATIONTYPE = "WindowsForms" OrElse _MYAPPLICATIONTYPE = "Windows" OrElse _MYAPPLICATIONTYPE = "Console" Then

<Global.System.CodeDom.Compiler.GeneratedCodeAttribute("MyTemplate", "8.0.0.0")> _

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> Partial Friend Class MyApplication

#If _MYAPPLICATIONTYPE = "WindowsForms" Then

Inherits Global.Microsoft.VisualBasic.ApplicationServices.WindowsFormsApplicationBase

#If TARGET = "winexe" Then

<Global.System.STAThread(), Global.System.Diagnostics.DebuggerHidden(), Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Advanced)> _

Friend Shared Sub Main(ByVal Args As String())

Try

Global.System.Windows.Forms.Application.SetCompatibleTextRenderingDefault(MyApplication.UseCompatibleTextRendering())

Finally

End Try

My.Application.Run(Args)

End Sub

#End If

#ElseIf _MYAPPLICATIONTYPE = "Windows" Then

Inherits Global.Microsoft.VisualBasic.ApplicationServices.ApplicationBase

#ElseIf _MYAPPLICATIONTYPE = "Console" Then

Inherits Global.Microsoft.VisualBasic.ApplicationServices.ConsoleApplicationBase

#End If '_MYAPPLICATIONTYPE = "WindowsForms"

End Class

#End If '#If _MYAPPLICATIONTYPE = "WindowsForms" Or _MYAPPLICATIONTYPE = "Windows" or _MYAPPLICATIONTYPE = "Console"

#If _MYCOMPUTERTYPE <> "" Then

<Global.System.CodeDom.Compiler.GeneratedCodeAttribute("MyTemplate", "8.0.0.0")> _

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> Partial Friend Class MyComputer

#If _MYCOMPUTERTYPE = "Windows" Then

Inherits Global.Microsoft.VisualBasic.Devices.Computer

#ElseIf _MYCOMPUTERTYPE = "Web" Then

Inherits Global.Microsoft.VisualBasic.Devices.ServerComputer

#End If

<Global.System.Diagnostics.DebuggerHidden()> _

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

Public Sub New()

MyBase.New()

End Sub

End Class

#End If

<Global.Microsoft.VisualBasic.HideModuleName()> _

<Global.System.CodeDom.Compiler.GeneratedCodeAttribute("MyTemplate", "8.0.0.0")> _

Friend Module MyProject

#If _MYCOMPUTERTYPE <> "" Then

<Global.System.ComponentModel.Design.HelpKeyword("My.Computer")> _

Friend ReadOnly Property Computer() As MyComputer

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_ComputerObjectProvider.GetInstance()

End Get

End Property

Private ReadOnly m_ComputerObjectProvider As New ThreadSafeObjectProvider(Of MyComputer)

#End If

#If _MYAPPLICATIONTYPE = "Windows" Or _MYAPPLICATIONTYPE = "WindowsForms" Or _MYAPPLICATIONTYPE = "Console" Then

<Global.System.ComponentModel.Design.HelpKeyword("My.Application")> _

Friend ReadOnly Property Application() As MyApplication

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_AppObjectProvider.GetInstance()

End Get

End Property

Private ReadOnly m_AppObjectProvider As New ThreadSafeObjectProvider(Of MyApplication)

#End If

#If _MYUSERTYPE = "Windows" Then

<Global.System.ComponentModel.Design.HelpKeyword("My.User")> _

Friend ReadOnly Property User() As Global.Microsoft.VisualBasic.ApplicationServices.User

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_UserObjectProvider.GetInstance()

End Get

End Property

Private ReadOnly m_UserObjectProvider As New ThreadSafeObjectProvider(Of Global.Microsoft.VisualBasic.ApplicationServices.User)

#ElseIf _MYUSERTYPE = "Web" Then

<Global.System.ComponentModel.Design.HelpKeyword("My.User")> _

Friend ReadOnly Property User() As Global.Microsoft.VisualBasic.ApplicationServices.WebUser

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_UserObjectProvider.GetInstance()

End Get

End Property

Private ReadOnly m_UserObjectProvider As New ThreadSafeObjectProvider(Of Global.Microsoft.VisualBasic.ApplicationServices.WebUser)

#End If

#If _MYFORMS = True Then

#Const STARTUP_MY_FORM_FACTORY = "My.MyProject.Forms"

<Global.System.ComponentModel.Design.HelpKeyword("My.Forms")> _

Friend ReadOnly Property Forms() As MyForms

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_MyFormsObjectProvider.GetInstance()

End Get

End Property

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

<Global.Microsoft.VisualBasic.MyGroupCollection("System.Windows.Forms.Form", "Create__Instance__", "Dispose__Instance__", "My.MyProject.Forms")> _

Friend NotInheritable Class MyForms

<Global.System.Diagnostics.DebuggerHidden()> _

Private Shared Function Create__Instance__(Of T As {New, Global.System.Windows.Forms.Form})(ByVal Instance As T) As T

If Instance Is Nothing OrElse Instance.IsDisposed Then

If m_FormBeingCreated IsNot Nothing Then

If m_FormBeingCreated.ContainsKey(GetType(T)) = True Then

Throw New Global.System.InvalidOperationException(Global.Microsoft.VisualBasic.CompilerServices.Utils.GetResourceString("WinForms_RecursiveFormCreate"))

End If

Else

m_FormBeingCreated = New Global.System.Collections.Hashtable()

End If

m_FormBeingCreated.Add(GetType(T), Nothing)

Try

Return New T()

Catch ex As Global.System.Reflection.TargetInvocationException When ex.InnerException IsNot Nothing

Dim BetterMessage As String = Global.Microsoft.VisualBasic.CompilerServices.Utils.GetResourceString("WinForms_SeeInnerException", ex.InnerException.Message)

Throw New Global.System.InvalidOperationException(BetterMessage, ex.InnerException)

Finally

m_FormBeingCreated.Remove(GetType(T))

End Try

Else

Return Instance

End If

End Function

<Global.System.Diagnostics.DebuggerHidden()> _

Private Sub Dispose__Instance__(Of T As Global.System.Windows.Forms.Form)(ByRef instance As T)

instance.Dispose()

instance = Nothing

End Sub

<Global.System.Diagnostics.DebuggerHidden()> _

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

Public Sub New()

MyBase.New()

End Sub

<Global.System.ThreadStatic()> Private Shared m_FormBeingCreated As Global.System.Collections.Hashtable

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never)> Public Overrides Function Equals(ByVal o As Object) As Boolean

Return MyBase.Equals(o)

End Function

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never)> Public Overrides Function GetHashCode() As Integer

Return MyBase.GetHashCode

End Function

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never)> _

Friend Overloads Function [GetType]() As Global.System.Type

Return GetType(MyForms)

End Function

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never)> Public Overrides Function ToString() As String

Return MyBase.ToString

End Function

End Class

Private m_MyFormsObjectProvider As New ThreadSafeObjectProvider(Of MyForms)

#End If

#If _MYWEBSERVICES = True Then

<Global.System.ComponentModel.Design.HelpKeyword("My.WebServices")> _

Friend ReadOnly Property WebServices() As MyWebServices

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_MyWebServicesObjectProvider.GetInstance()

End Get

End Property

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

<Global.Microsoft.VisualBasic.MyGroupCollection("System.Web.Services.Protocols.SoapHttpClientProtocol", "Create__Instance__", "Dispose__Instance__", "")> _

Friend NotInheritable Class MyWebServices

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never), Global.System.Diagnostics.DebuggerHidden()> _

Public Overrides Function Equals(ByVal o As Object) As Boolean

Return MyBase.Equals(o)

End Function

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never), Global.System.Diagnostics.DebuggerHidden()> _

Public Overrides Function GetHashCode() As Integer

Return MyBase.GetHashCode

End Function

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never), Global.System.Diagnostics.DebuggerHidden()> _

Friend Overloads Function [GetType]() As Global.System.Type

Return GetType(MyWebServices)

End Function

<Global.System.ComponentModel.EditorBrowsable(Global.System.ComponentModel.EditorBrowsableState.Never), Global.System.Diagnostics.DebuggerHidden()> _

Public Overrides Function ToString() As String

Return MyBase.ToString

End Function

<Global.System.Diagnostics.DebuggerHidden()> _

Private Shared Function Create__Instance__(Of T As {New})(ByVal instance As T) As T

If instance Is Nothing Then

Return New T()

Else

Return instance

End If

End Function

<Global.System.Diagnostics.DebuggerHidden()> _

Private Sub Dispose__Instance__(Of T)(ByRef instance As T)

instance = Nothing

End Sub

<Global.System.Diagnostics.DebuggerHidden()> _

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

Public Sub New()

MyBase.New()

End Sub

End Class

Private ReadOnly m_MyWebServicesObjectProvider As New ThreadSafeObjectProvider(Of MyWebServices)

#End If

#If _MYTYPE = "Web" Then

<Global.System.ComponentModel.Design.HelpKeyword("My.Request")> _

Friend ReadOnly Property Request() As Global.System.Web.HttpRequest

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Dim CurrentContext As Global.System.Web.HttpContext = Global.System.Web.HttpContext.Current

If CurrentContext IsNot Nothing Then

Return CurrentContext.Request

End If

Return Nothing

End Get

End Property

<Global.System.ComponentModel.Design.HelpKeyword("My.Response")> _

Friend ReadOnly Property Response() As Global.System.Web.HttpResponse

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Dim CurrentContext As Global.System.Web.HttpContext = Global.System.Web.HttpContext.Current

If CurrentContext IsNot Nothing Then

Return CurrentContext.Response

End If

Return Nothing

End Get

End Property

<Global.System.ComponentModel.Design.HelpKeyword("My.Application.Log")> _

Friend ReadOnly Property Log() As Global.Microsoft.VisualBasic.Logging.AspLog

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Return m_LogObjectProvider.GetInstance()

End Get

End Property

Private ReadOnly m_LogObjectProvider As New ThreadSafeObjectProvider(Of Global.Microsoft.VisualBasic.Logging.AspLog)

#End If '_MYTYPE="Web"

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

<Global.System.Runtime.InteropServices.ComVisible(False)> _

Friend NotInheritable Class ThreadSafeObjectProvider(Of T As New)

Friend ReadOnly Property GetInstance() As T

#If TARGET = "library" Then

<Global.System.Diagnostics.DebuggerHidden()> _

Get

Dim Value As T = m_Context.Value

If Value Is Nothing Then

Value = New T

m_Context.Value() = Value

End If

Return Value

End Get

#Else

<Global.System.Diagnostics.DebuggerHidden()> _

Get

If m_ThreadStaticValue Is Nothing Then m_ThreadStaticValue = New T

Return m_ThreadStaticValue

End Get

#End If

End Property

<Global.System.Diagnostics.DebuggerHidden()> _

<Global.System.ComponentModel.EditorBrowsableAttribute(Global.System.ComponentModel.EditorBrowsableState.Never)> _

Public Sub New()

MyBase.New()

End Sub

#If TARGET = "library" Then

Private ReadOnly m_Context As New Global.Microsoft.VisualBasic.MyServices.Internal.ContextValue(Of T)

#Else

<Global.System.Runtime.CompilerServices.CompilerGenerated(), Global.System.ThreadStatic()> Private Shared m_ThreadStaticValue As T

#End If

End Class

End Module

End Namespace

#End If

</T.vb>

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";

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.

You can use Visual Studio to debug itself!

Calvin_Hsia — Tue, 09 Jun 2009 03:22:00 GMT

How do you find out why your computer or a running program is so slow? Here’s one way.

Let’s attach the VS debugger to VS itself. The main executable for VS is devenv.exe.

Start Visual Studio 2008. This will be the “debugger”

Choose File->Open Project C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe

(You can also choose Debug->Attach to process to debug another instance of devenv.exe, or any other EXE, like Foxpro.exe or Excel.exe)

Hit F5, and a dialog pops up:

“Debugging information for ‘devenv.exe’ cannot be found or does not match. Symbols not loaded. Do you want to continue debugging?”.

Answer yes, and Visual Studio starts. This will be the “debuggee”

Do anything you like in the debuggee, such as create or load a project. Hit F12 to cause an asynchronous breakpoint (or go to the debugger and choose Debug->Break All).

That will freeze all the debuggee threads and put you in the debugger.

You can then examine the Threads window (Debug->Windows->Threads) and see what threads are running. There are several. You can dbl-click various threads and look at the Call stack for it (Debug->Windows->Call stack).

You’ll probably see that most threads are just waiting for something to happen.

Choose the main thread. When VS is idling, the stack will look like this:

ntdll.dll!7c90eb94()

[Frames below may be incorrect and/or missing, no symbols loaded for ntdll.dll]

ntdll.dll!7c90e9ab()

kernel32.dll!7c8094e2()

> msvcr90.dll!_onexit_nolock(int (void)* func=0x0072006f) Line 157 + 0x6 bytes C

00660072()

Each stack entry shows the module and address that called the next stack entry. This isn’t very useful, so you need to load symbols. You can use the public Microsoft Symbol Server:

Tools->Options->Debug->Symbols

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

Cache the symbols to a local dir, like C:\Symbols

Right click on the various modules (like ntdll.dll, kernel32.dll, msenv.dll etc.) in the call stack to load symbols. Now it’s a little more intelligible:

> ntdll.dll!_KiFastSystemCallRet@0()

user32.dll!_NtUserKillTimer@8() + 0xc bytes

msenv.dll!CMsoCMHandler::FPushMessageLoop() + 0x36 bytes

msenv.dll!SCM::FPushMessageLoop() + 0x4f bytes

msenv.dll!SCM_MsoCompMgr::FPushMessageLoop() + 0x28 bytes

msenv.dll!CMsoComponent::PushMsgLoop() + 0x28 bytes

msenv.dll!VStudioMainLogged() + 0x19b bytes

msenv.dll!_VStudioMain() + 0x7d bytes

devenv.exe!util_CallVsMain() + 0xd8 bytes

devenv.exe!CDevEnvAppId::Run() + 0x5cb bytes

devenv.exe!_WinMain@16() + 0x60 bytes

devenv.exe!License::GetPID() - 0x4cf9 bytes

kernel32.dll!_BaseProcessStart@4() + 0x23 bytes

You can see the WinMain calls a MessageLoop.

Let’s make the foreground thread busy. Create a VB console application. Add an XML literal:

Module Module1

Sub Main()

Dim bigxml = <xml>

</xml>

End Sub

End Module

Make the XML literal big: open the file C:\Program Files\Reference Assemblies\Microsoft\Framework\v3.5\System.Data.Linq.xml and copy everything except the <?xml version="1.0" encoding="utf-8"?> into the literal (between the <xml> and the </xml>), so you have about 2000 lines.

Start Task Manager (Ctrl-Shift->Escape, or right click on the task bar and choose Task Manager). Observe the little tray icon in the System tray. It will indicate how busy your computer is.

For example, if you have 2 processors and 1 thread is very busy, it’ll show 50% busy.

Now, if you hover your mouse over the “bigxml”, you’ll trigger VB to create a Quick Info tooltip, but it takes quite a lot of calculation to figure out the tip.

Do your asynchronous breakpoint trick and you’ll see something like this:

> msvb7.dll!BCSYM::IsNamedRoot()

msvb7.dll!BCSYM::AreTypesEqual()

msvb7.dll!EquivalentTypes() + 0x17 bytes

msvb7.dll!ClassifyPredefinedCLRConversion() + 0x22 bytes

msvb7.dll!Semantics::ClassifyPredefinedCLRConversion() + 0x28 bytes

msvb7.dll!Semantics::ClassifyPredefinedConversion() + 0xbf bytes

msvb7.dll!Semantics::ResolveConversion() + 0x234 bytes

msvb7.dll!Semantics::ClassifyUserDefinedConversion() + 0x40685 bytes

msvb7.dll!Semantics::ClassifyConversion() + 0x21e31 bytes

msvb7.dll!Semantics::CompareParameterTypeSpecificity() + 0x57 bytes

msvb7.dll!Semantics::CompareParameterSpecificity() + 0xa3 bytes

msvb7.dll!Semantics::InsertIfMethodAvailable() + 0x461 bytes

msvb7.dll!Semantics::CollectOverloadCandidates() + 0x1e6 bytes

msvb7.dll!Semantics::ResolveOverloading() + 0xd9 bytes

msvb7.dll!Semantics::ResolveOverloadedCall() + 0x5e bytes

msvb7.dll!Semantics::InterpretCallExpression() + 0x2656f bytes

msvb7.dll!Semantics::CreateConstructedInstance() + 0xfa bytes

msvb7.dll!Semantics::CreateConstructedInstance() + 0x5b bytes

msvb7.dll!Semantics::InterpretXmlElement() + 0x241 bytes

msvb7.dll!Semantics::InterpretXmlContent() + 0x56 bytes

msvb7.dll!Semantics::InterpretXmlElement() + 0x27c bytes

msvb7.dll!Semantics::InterpretXmlContent() + 0x56 bytes

msvb7.dll!Semantics::InterpretXmlElement() + 0x27c bytes

msvb7.dll!Semantics::InterpretXmlContent() + 0x56 bytes

msvb7.dll!Semantics::InterpretXmlElement() + 0x27c bytes

msvb7.dll!Semantics::InterpretXmlContent() + 0x56 bytes

msvb7.dll!Semantics::InterpretXmlElement() + 0x27c bytes

msvb7.dll!Semantics::InterpretXmlExpression() - 0x13d bytes

msvb7.dll!Semantics::InterpretXmlExpression() + 0xb0 bytes

msvb7.dll!Semantics::InterpretXmlExpression() + 0xc3 bytes

msvb7.dll!Semantics::InterpretExpression() - 0x1fc bytes

msvb7.dll!Semantics::InterpretExpressionWithTargetType() + 0x43 bytes

msvb7.dll!Semantics::InterpretInitializer() + 0x36 bytes

msvb7.dll!Semantics::InterpretInitializer() + 0x1a bytes

msvb7.dll!Semantics::InterpretInitializer() + 0x127 bytes

msvb7.dll!Semantics::InterpretVariableDeclarationStatement() + 0x158c bytes

msvb7.dll!Semantics::InterpretStatement() + 0x7b2f bytes

msvb7.dll!Semantics::InterpretStatementSequence() + 0x2f bytes

msvb7.dll!Semantics::InterpretBlock() + 0x24 bytes

msvb7.dll!Semantics::InterpretMethodBody() + 0x1fa bytes

msvb7.dll!SourceFile::GetBoundMethodBodyTrees() + 0x126 bytes

msvb7.dll!CBaseSymbolLocator::GetBoundMethodBody() + 0xb6 bytes

msvb7.dll!CSymbolLocator::LocateSymbolInMethodImpl() + 0x29 bytes

msvb7.dll!CSymbolLocator::LocateSymbol() + 0x81f bytes

msvb7.dll!CIntelliSense::GenQuickInfo() + 0x52399 bytes

msvb7.dll!CIntelliSense::HandleQuickInfo() + 0x29 bytes

msvb7.dll!CIntelliSense::ProcessCompletionInfo() + 0x66cda bytes

msvb7.dll!CIntelliSense::GenIntelliSenseInfo() + 0x402 bytes

msvb7.dll!SourceFileView::GenIntelliSenseInfo() + 0x94 bytes

msvb7.dll!SourceFileView::GetDataTip() + 0x743 bytes

msvb7.dll!CVBLangService::GetDataTip() + 0x11d bytes

msenv.dll!CEditView::GetFilterDataTipText() + 0x37 bytes

msenv.dll!CEditView::HandleHoverWaitTimer() + 0x213 bytes

msenv.dll!CEditView::TimerTick() + 0x7d bytes

msenv.dll!CEditView::WndProc() + 0x1685b9 bytes

msenv.dll!CEditView::StaticWndProc() + 0x39 bytes

user32.dll!_InternalCallWinProc@20() + 0x28 bytes

user32.dll!_UserCallWinProcCheckWow@32() + 0xb7 bytes

user32.dll!_DispatchMessageWorker@8() + 0xdc bytes

user32.dll!_DispatchMessageW@4() + 0xf bytes

msenv.dll!EnvironmentMsgLoop() + 0xb6 bytes

msenv.dll!CMsoCMHandler::FPushMessageLoop() + 0x36 bytes

msenv.dll!SCM::FPushMessageLoop() + 0x4f bytes

msenv.dll!SCM_MsoCompMgr::FPushMessageLoop() + 0x28 bytes

msenv.dll!CMsoComponent::PushMsgLoop() + 0x28 bytes

msenv.dll!VStudioMainLogged() + 0x19b bytes

msenv.dll!_VStudioMain() + 0x7d bytes

devenv.exe!util_CallVsMain() + 0xd8 bytes

devenv.exe!CDevEnvAppId::Run() + 0x5cb bytes

devenv.exe!_WinMain@16() + 0x60 bytes

devenv.exe!License::GetPID() - 0x4cf9 bytes

kernel32.dll!_BaseProcessStart@4() + 0x23 bytes

Note how it’s easy to read the stack. The bottom of the stack (the first thing put on it) is _BaseProcessStart, which starts the process. You can see that a timer tick caused GetDataTip to call GenIntelliSenseInfo, which calls GenQuickInfo, -> LocateSymbol, etc.

Each stack entry indicates the name of the routine being executed. The “+ 0x23 bytes” means the # of bytes into the routine that the call occurred. A low number means near the beginning of that method.

Because XML is a tree, and is thus a recursive data structure, you see that XMLContent can contain an XMLExpression and vice versa. The depth of the recursion reflects the actual XML being processed.

BTW, the VB background compiler thread is:

0 > 4620 Worker Thread ThreadSyncManager::ThreadProc _KiFastSystemCallRet@0 Normal 0

And it’s stack at idle:

> ntdll.dll!_KiFastSystemCallRet@0()

ntdll.dll!_ZwWaitForMultipleObjects@20() + 0xc bytes

kernel32.dll!_WaitForMultipleObjectsEx@20() - 0x48 bytes

user32.dll!_RealMsgWaitForMultipleObjectsEx@20() + 0xd9 bytes

ole32.dll!CCliModalLoop::BlockFn() + 0x76 bytes

ole32.dll!_CoWaitForMultipleHandles@20() + 0xe6 bytes

msvb7.dll!ThreadSyncManager::ThreadProc() + 0x98 bytes

kernel32.dll!_BaseThreadStart@8() + 0x37 bytes

See also:

Dynamically attaching a debugger

Is a process hijacking your machine?

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;

}

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.

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

Create your own Test Host using XAML to run your unit tests

Calvin_Hsia — Thu, 27 Mar 2008 19:26:00 GMT

A few days ago, somebody came into my office and plopped down a box. It seemed very light. He said that it was a new PC. I thought hmmm…. The box seems empty…Why am I getting a new PC?.

Apparently an inventory was made and my current hardware was at the lower end of the list.

So I started up the Dell Optiplex 755 with 4 gigs of RAM, and it was running Vista 64. Super: I hadn’t done much with 64 bit code yet.

Sure enough, debugging 64 bit native applications shows that the CPU has 64 bit wide registers (and more registers!). If I attach to a 64 bit process, the Debug->Windows->Registers looks like:

RAX = 0000000000000000 RBX = 000000001DEB7818 RCX = 000000000F99A027

RDX = 0000000000000000 RSI = 0000000000000001 RDI = 00000000242E5454

R8 = 000000001FD3FCB8 R9 = 0000000000000000 R10 = 0000000000000000

R11 = 0000000000000206 R12 = 0000000000000000 R13 = 0000000000000000

R14 = 0000000000000000 R15 = 0000000000000000 RIP = 000007FEF0FD3D29

RSP = 000000001FD3FCF0 RBP = 0000000000000000 EFL = 00000246

If I attach to a 32 bit process:

EAX = 00000000 EBX = 006AC138 ECX = 79E74400 EDX = 00000000 ESI = 00DF6700

EDI = 00000000 EIP = 59B80265 ESP = 001DDEE8 EBP = 001DDEE8 EFL = 00000206

001DDEFC = 06CD35C8

(The debugger is pretty amazing!)

The sheer size of the registers means instead of a maximum 2^32 =4 gig virtual address space, we have 2^64

To calculate that, type this in the Fox command window:

?LOG10(2^64)

?2^64

Which shows 19.27, 1.844674E+19

That means 19.27 zeros: 18,000,000,000,000,000,000 which is 18 billion billion or 18 exabytes!

Coincidentally, we have some new 64 bit code that was recently created by “patching” the 32 bit version, and I wanted some test tools for it.

I have a VS Test Project with many (32 bit) tests. (Use Visual Studio Test framework to create tests for your code)

So I created my own Test Host in a day:

This Test Host:

· Uses the existing 32 bit test source code as linked files: if you make changes to the tests, they will automatically be updated in both 32 and 64 bit versions

· Can be built as 32 bit or 64 bit (Project->Properties->Compile->Advanced Compile Options->Target CPU->AnyCPU or x86), so it can run tests in either 32 or 64 bits. When set as AnyCPU and running on 64 bit OS like Vista 64, then it will run as 64 bit.

· Does not require test deployment: you can test in place. VSTestHost requires deployment.

· Uses reflection on itself to get and run the TestInitialize, TestCleanup and TestMethods.

· Can run selected tests in a loop for stress tests, like leak detection.

· Uses XAML and Data Binding (see Create your own media browser: Display your pictures, music, movies in a XAML tooltip)

o Notice how the enabling and disabling of buttons is done via data binding.

o The data binding updates the status (Success,Failure/Pending) and its color in the ListView.

o Shows the test methods in a ListView with click/sort column headers.

· The tests run on a worker thread. The UI is thus responsive and not blocked.

· A progress bar and stopwatch also show

· Can be run without UI: another assembly can call it to run tests

· Can determine if it’s running 64 or 32: IntPtr.Size=8 bytes on 64, 4 bytes on 32.

I’m thinking about adding a new 32 bit test case (for running in the VS IDE) that will launch all the 64 bit tests, or a new one for each of the 32 bit test cases, but that’s lower priority.

This new test host has already helped me find several 64 bit issues.

Follow my prior post: Use Visual Studio Test framework to create tests for your code to create a project. (If you don’t have Fox or Excel, you can either get them or remove the Fox/Excel code in the test)

If you add these lines to the test

System.Diagnostics.Debug.WriteLine("Sizeof IntPtr = " + IntPtr.Size.ToString)

System.Diagnostics.Debug.WriteLine(System.Diagnostics.Process.GetCurrentProcess.MainModule.FileName)

You’ll get the output:

Sizeof IntPtr = 4

C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\vstesthost.exe

Nothing unexpected. VSTestHost is a 32 bit EXE, which means only 32 bit code is run.

To make the test host more interesting, add a few more tests to the bottom of UnitTests1:

Shared oRandom As New Random

<TestMethod()> _

Sub EmptyTest()

End Sub

<TestMethod()> _

Sub AlwaysFail()

Assert.IsTrue(False, "True is never false!")

End Sub

<TestMethod()> _

Sub SometimesFail()

If oRandom.NextDouble < 0.4 Then

Assert.IsTrue(False, "True is never false!")

End If

End Sub

<TestMethod()> _

Sub RarelyFails()

If oRandom.NextDouble < 0.02 Then

Assert.IsTrue(False, "True is rarely false!")

End If

End Sub

To create the Test Host:

Right Click on the Solution from above in Solution explorer, choose Add->New Project. This time choose Windows->WPF Application. Put in a folder next to the folder of the existing test project. I called mine MyTestHost

Right Click on MyTestHost in solution explorer, choose Set As Startup Project. That way, hitting F5 will run this new project.

Delete the Window1.XAML in the solution explorer. We’ll create our own.

Delete MyTestHost->Application.xaml (we have our own Sub Main)

Right Click on MyTestHost in solution explorer, choose Add New Item, Code->Class. Name it MyTestHost.vb

Right Click on MyTestHost in solution explorer, choose Add Existing Item, navigate to the UnitTest1.vb file in the other project. Make sure you add as a Lnked File. The “Add” button on the dialog has a little down arrow that allows you to choose Add As Link.

Note: the Fox code in the unit test TestMethod1 will fail in 64 because there is no 64 bit version of it.

Add references to:

Microsoft.VisualStudio.QualityTools.UnitTestFramework

System.Windows.Forms

There are 3 sections of code to paste below: Window1.XAML, Window1.XAML.VB (the code behind file), and MyTestHost.vb

Hit F5, click on the button to run the tests.

You can force the Testmethod1 to fail simply by forcing Excel to close before it’s done.

<Window1.XAML code to paste>

<Window x:Class="Window1"

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

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

Title="Window1" Height="711" Width="1043">

<ListView.View>

<GridViewColumn>Selected

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>Status

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>TestName

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>Description

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>TestClass

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>mSecs

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>ErrorMessage

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>Owner

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

<GridViewColumn>Pri

<GridViewColumn.CellTemplate>

</DataTemplate>

</GridViewColumn.CellTemplate>

</GridViewColumn>

</GridView>

</ListView.View>

</ListView>

<Button Height="23" HorizontalAlignment="Left" Margin="22,0,0,35"

Name="btnSelectAll" VerticalAlignment="Bottom" Width="85" ButtonBase.Click="btnClicked">Select_All</Button>

<Button Height="23" HorizontalAlignment="Left" Margin="117,0,0,35"

Name="btnInvertSelection" VerticalAlignment="Bottom" Width="85" ButtonBase.Click="btnClicked">_InvertSelection</Button>

<CheckBox Height="16" HorizontalAlignment="Left" Margin="215,0,0,65"

Name="chkLoopForever" VerticalAlignment="Bottom" Width="120" IsEnabled="{Binding Path=NotIsTestRunning}">_LoopForever</CheckBox>

<Button Height="23" HorizontalAlignment="Left" Margin="215,0,0,35"

Name="btnRunSelected" VerticalAlignment="Bottom" ButtonBase.Click="btnClicked" Width="85" IsEnabled="{Binding Path=NotIsTestRunning}">_RunSelected</Button>

<Button Height="23" HorizontalAlignment="Left" Margin="315,0,0,35"

Name="btnAbortRun" VerticalAlignment="Bottom" ButtonBase.Click="btnClicked" IsEnabled="{Binding Path=IsTestRunning}" Width="56.82">_AbortRun</Button>

<Button Height="23" HorizontalAlignment="Right" Margin="0,0,54,35"

Name="btnQuit" VerticalAlignment="Bottom" Width="85" ButtonBase.Click="btnClicked" IsCancel="True">_Quit</Button>

<ProgressBar Height="14" HorizontalAlignment="Right" Margin="0,0,16,0"

Name="ProgressBar1" VerticalAlignment="Top" Width="123" />

</Grid>

</Window>

</Window1.XAML code to paste >

<Window1.XAML.vb code to paste >

Imports System.ComponentModel

Imports System.Collections.ObjectModel

Class Window1

Implements INotifyPropertyChanged ' so XAML UI updates

Private m_TestMethods As ReadOnlyCollection(Of TestItem)

Private m_SelectedTests As New Collection(Of TestItem)

Private m_StatusText As String

Private m_IsTestRunning As Boolean = False

Private m_Clock As String

Private m_nTestPass As Integer

Friend StopWatch As Diagnostics.Stopwatch

Public Property Clock() As String

Get

Return m_Clock

End Get

Set(ByVal value As String)

If m_Clock <> value Then

m_Clock = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("Clock"))

End If

End Set

End Property

Public Property IsTestRunning() As Boolean

Get

Return m_IsTestRunning

End Get

Set(ByVal value As Boolean)

m_IsTestRunning = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("IsTestRunning"))

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("NotIsTestRunning"))

End Set

End Property

Public ReadOnly Property NotIsTestRunning() As Boolean

Get

Return Not m_IsTestRunning

End Get

End Property

Public Property StatusText() As String

Get

Return m_StatusText

End Get

Set(ByVal value As String)

Dim strTitle = "TestHost "

If IntPtr.Size > 4 Then

strTitle += "amd64 64 bit"

Else

strTitle += "x86 32 bit"

End If

strTitle += " Total Tests = " + TestMethods.Count.ToString

If m_nTestPass > 0 Then

strTitle += " Test Pass #" + m_nTestPass.ToString + " PeakWorkingSet =" + Process.GetCurrentProcess.PeakWorkingSet64.ToString("n0")

End If

m_StatusText = strTitle + " " + value

Me.Title = m_StatusText ' in case of process crash, we can still see window title

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("StatusText"))

End Set

End Property

Public ReadOnly Property TestMethods() As ReadOnlyCollection(Of TestItem)

Get

Return m_TestMethods

End Get

End Property

Sub New(ByVal TestMethods As ReadOnlyCollection(Of TestItem))

InitializeComponent()

m_TestMethods = TestMethods

StatusText = "" ' init window title

Me.ProgressBar1.Visibility = Windows.Visibility.Hidden

Me.ProgressBar1.Minimum = 0

Me.ProgressBar1.Maximum = 100

Me.ProgressBar1.Value = 0

Me.DataContext = Me ' so XAML can databind to our members

AddHandler Me.Closed, AddressOf OnWindowClosed

Me.AddHandler(System.Windows.Controls.GridViewColumnHeader.ClickEvent, New RoutedEventHandler(AddressOf OnHeaderClicked))

End Sub

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

TestItem.ShutDown() ' abort thread

End Sub

Private Sub btnClicked(ByVal sender As System.Windows.Controls.Button, ByVal e As RoutedEventArgs)

Debug.WriteLine((New StackTrace).GetFrame(0).GetMethod.Name + " " + sender.Name)

Select Case CStr(sender.Name)

Case "btnSelectAll"

For Each lstItem In ListView1.Items

Dim tstItem = CType(lstItem, TestItem)

If Not tstItem.Selected Then

tstItem.Selected = True

End If

Case "btnInvertSelection"

For Each lstItem In ListView1.Items

Dim tstItem = CType(lstItem, TestItem)

tstItem.Selected = Not tstItem.Selected

Case "btnRunSelected"

m_SelectedTests.Clear()

m_nTestPass = 1

For Each lstItem In ListView1.Items ' Get the user selected items in display order

Dim tstItem = CType(lstItem, TestItem)

tstItem.Reset() ' reset all to not run yet (doesn't reset checkbox)

If tstItem.Selected Then

m_SelectedTests.Add(tstItem)

tstItem.Status = TestItem.TstStatus.Pending

End If

If Me.chkLoopForever.IsChecked Then

Do While True

DoRunSelected()

For Each lstItem In ListView1.Items

Dim tstItem = CType(lstItem, TestItem)

If tstItem.Status = TestItem.TstStatus.Aborted OrElse tstItem.Status = TestItem.TstStatus.Failed Then

Me.StatusText = String.Format(" Failed {0}", DateTime.Now.ToString)

Exit Do

End If

tstItem.Reset()

m_nTestPass += 1

Loop

Else

DoRunSelected()

End If

Case "btnAbortRun"

TestItem.ShutDown()

For Each tstItem In m_SelectedTests

If tstItem.Status = TestItem.TstStatus.Pending Then

tstItem.Status = TestItem.TstStatus.NotRun

End If

Case "btnQuit"

TestItem.ShutDown()

Me.Close()

Case Else

Debug.Assert(False, "Unhandled button")

End Select

End Sub

Private Sub DoRunSelected()

IsTestRunning = True

Dim nTestsRun = 0

Dim nTestsFailed = 0

StopWatch = Diagnostics.Stopwatch.StartNew

Me.StatusText = String.Format("{0} Test run ({1}/{2}) ", DateTime.Now.ToString, nTestsRun, m_SelectedTests.Count)

Try

For Each lstItem In ListView1.Items

Dim tstItem = CType(lstItem, TestItem)

If tstItem.Selected Then

Me.ProgressBar1.Visibility = Windows.Visibility.Visible

tstItem.RunTest(Me) ' actually run the test

Me.ProgressBar1.Visibility = Windows.Visibility.Hidden

nTestsRun += 1

If tstItem.Status = TestItem.TstStatus.Failed Then

nTestsFailed += 1

End If

Me.StatusText = String.Format("{0} Test run {1}/{2} #Failed = {3}", DateTime.Now.ToString, nTestsRun, m_SelectedTests.Count, nTestsFailed)

If tstItem.Status = TestItem.TstStatus.Aborted Then

Exit For

End If

Catch ex As Exception

End Try

Me.StatusText = String.Format(" Done: {0:f2} secs", StopWatch.ElapsedMilliseconds / 1000)

IsTestRunning = False

End Sub

Private Sub ListBox1_KeyUp(ByVal sender As Object, ByVal args As System.Windows.Input.KeyEventArgs) Handles ListView1.KeyUp

If args.Key = Key.Space Then

Dim lb As System.Windows.Controls.ListBox = CType(sender, System.Windows.Controls.ListBox)

If lb.SelectedIndex >= 0 Then

Dim lbi = CType(lb.ItemContainerGenerator.ContainerFromIndex(lb.SelectedIndex), System.Windows.Controls.ListBoxItem)

If lbi IsNot Nothing Then

Dim tstItem = CType(lbi.Content, TestItem)

tstItem.Selected = Not tstItem.Selected

End If

End Sub

'see http://blogs.msdn.com/calvin_hsia/archive/2007/11/29/6600915.aspx

Dim m_LastDir As System.ComponentModel.ListSortDirection = System.ComponentModel.ListSortDirection.Ascending

Dim m_LastHeaderClicked As System.Windows.Controls.GridViewColumnHeader = Nothing

Private Sub OnHeaderClicked(ByVal sender As Object, ByVal e As RoutedEventArgs)

If e.OriginalSource.GetType Is GetType(System.Windows.Controls.GridViewColumnHeader) Then

Dim direction = System.ComponentModel.ListSortDirection.Ascending

Dim gvHdr = CType(e.OriginalSource, System.Windows.Controls.GridViewColumnHeader)

If gvHdr IsNot Nothing AndAlso gvHdr.Column IsNot Nothing Then

Dim hdr As String

hdr = CStr(gvHdr.Column.Header)

If gvHdr Is m_LastHeaderClicked Then

If m_LastDir = System.ComponentModel.ListSortDirection.Ascending Then

direction = System.ComponentModel.ListSortDirection.Descending

End If

Sort(hdr, direction)

m_LastHeaderClicked = gvHdr

m_LastDir = direction

End If

End Sub

Private Sub Sort(ByVal sortby As String, ByVal dir As System.ComponentModel.ListSortDirection)

Me.ListView1.Items.SortDescriptions.Clear()

Dim sd = New System.ComponentModel.SortDescription(sortby, dir)

Me.ListView1.Items.SortDescriptions.Add(sd)

Me.ListView1.Items.Refresh()

End Sub

Public Event PropertyChanged(ByVal sender As Object, ByVal e As System.ComponentModel.PropertyChangedEventArgs) _

Implements System.ComponentModel.INotifyPropertyChanged.PropertyChanged

End Class

</Window1.XAML.vb code to paste >

<MyTestHost.vb code to paste >

Imports System.Reflection

Imports System.Windows

Imports System.Collections.ObjectModel

Imports System.Windows.Controls

Imports System.ComponentModel

Imports Microsoft.VisualStudio.TestTools.UnitTesting

Public Class MyTestHost

Private Shared m_TestMethods As ReadOnlyCollection(Of TestItem)

Shared Sub Main()

m_TestMethods = GetTestMethods()

If System.Environment.GetCommandLineArgs.Count > 1 Then ' arg 0 is the fullpath name of the app

Dim testname = System.Environment.GetCommandLineArgs(1)

Else

' show UI

Dim wpfApplicationWindow As System.Windows.Window = New Window1(m_TestMethods)

wpfApplicationWindow.ShowDialog()

End If

End Sub

Public Shared Function GetTestMethods() As ReadOnlyCollection(Of TestItem) ' can be called from other assemblies

Dim retval As New Collection(Of TestItem)

Dim MyAsm = Assembly.GetExecutingAssembly

Dim TestClasses = From typ In MyAsm.GetTypes Where typ.GetCustomAttributes(GetType(TestClassAttribute), True).Length > 0

For Each TestClassName In TestClasses

Debug.WriteLine("Test class " + TestClassName.Name)

Dim TestClassInstance = MyAsm.CreateInstance(TestClassName.FullName)

Dim TestMethods = From meth In TestClassInstance.GetType.GetMethods _

Where meth.GetCustomAttributes(GetType(TestMethodAttribute), True).Length > 0 _

AndAlso Not meth.GetCustomAttributes(GetType(IgnoreAttribute), True).Length > 0

Debug.WriteLine("Count=" + TestMethods.Count.ToString)

' you can define your own TestContext class

'Dim tstContext = New VBTest64TestContext

'Dim TestContext_Property As PropertyInfo = TestClassInstance.GetType.GetProperty("TestContext")

'If TestContext_Property IsNot Nothing Then

' TestContext_Property.SetValue(TestClassInstance, tstContext, BindingFlags.SetProperty, Nothing, Nothing, Nothing)

'End If

Dim TestInitialize_method As MethodInfo = TestClassInstance.GetType.GetMethod("TestInitialize")

Dim TestCleanup_method As MethodInfo = TestClassInstance.GetType.GetMethod("TestCleanup")

For Each meth In TestMethods ' In From dd In meths Where dd.Name.StartsWith("PepperQu")

Debug.WriteLine(meth.Name)

Dim TestDesc = ""

Dim TestOwner = ""

Dim TestPriority = ""

Dim Tmp = meth.GetCustomAttributes(GetType(Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute), True)

If Tmp.Length > 0 Then

TestDesc = CType(Tmp(0), Microsoft.VisualStudio.TestTools.UnitTesting.DescriptionAttribute).Description

End If

Tmp = meth.GetCustomAttributes(GetType(OwnerAttribute), True)

If Tmp.Length > 0 Then

TestOwner = CType(Tmp(0), OwnerAttribute).Owner

End If

Tmp = meth.GetCustomAttributes(GetType(PriorityAttribute), True)

If Tmp.Length > 0 Then

TestPriority = CType(Tmp(0), PriorityAttribute).Priority.ToString

End If

retval.Add(New TestItem(meth.Name, TestClassName.FullName, TestDesc, _

TestOwner, TestPriority, meth, _

TestClassInstance, TestInitialize_method, TestCleanup_method))

Return New ReadOnlyCollection(Of TestItem)(retval)

End Function

End Class

Public Class TestItem

Implements INotifyPropertyChanged

Enum TstStatus

Idle

Pending

Running

Passed

Aborted

NotRun

Failed

End Enum

Private m_TestName As String

Private m_TestClass As String

Private m_Description As String

Private m_TestOwner As String

Private m_TestPriority As String

Private m_Selected As Boolean = True ' default to checkbox selected

Private m_TestStatus As TstStatus = TstStatus.Idle

Private m_TestInitialize_method As MethodInfo

Private m_TestCleanup_method As MethodInfo

Private m_TestMethodInfo As MethodInfo ' the actual test to run

Private m_TestClassInstance As Object

Private m_ElapsedTime As String

Private m_ErrorMessage As String

Private m_Stopwatch As Diagnostics.Stopwatch

Private Shared m_bgThread As System.Threading.Thread

Private Shared m_threadRunning As Boolean

Delegate Sub delThreadDone()

Private m_ThreadDoneEvent As System.Threading.ManualResetEvent

Sub New(ByVal TestName As String, ByVal TestClass As String, ByVal testDesc As String, _

ByVal TestOwner As String, ByVal TestPriority As String, _

ByVal meth As MethodInfo, ByVal TestClassInstance As Object, _

ByVal TestInitialize_method As MethodInfo, ByVal TestCleanup_method As MethodInfo)

m_TestName = TestName

m_TestClass = TestClass

m_Description = testDesc

m_TestOwner = TestOwner

m_TestPriority = TestPriority

m_TestMethodInfo = meth

m_TestInitialize_method = TestInitialize_method

m_TestCleanup_method = TestCleanup_method

m_TestClassInstance = TestClassInstance

End Sub

Shared Sub ShutDown()

If m_bgThread IsNot Nothing Then

m_bgThread.Abort()

Do While m_threadRunning

System.Windows.Forms.Application.DoEvents()

Loop

End If

End Sub

Sub BgThreadProc(ByVal disp As Object)

m_Stopwatch = Stopwatch.StartNew

Dim stat As TstStatus = TstStatus.Running

Status = TstStatus.Running

Dim deldone As New delThreadDone(AddressOf BgThreadDone)

Dim fDidRunCleanup = False

Debug.WriteLine(TestName)

Try

If m_TestInitialize_method IsNot Nothing Then

m_TestInitialize_method.Invoke(m_TestClassInstance, BindingFlags.InvokeMethod, Nothing, Nothing, Nothing)

End If

' run the test

m_TestMethodInfo.Invoke(m_TestClassInstance, Reflection.BindingFlags.InvokeMethod, Nothing, Nothing, Nothing)

If m_TestCleanup_method IsNot Nothing Then

m_TestCleanup_method.Invoke(m_TestClassInstance, BindingFlags.InvokeMethod, Nothing, Nothing, Nothing)

fDidRunCleanup = True

End If

stat = TstStatus.Passed

Catch ex As Exception 'When ex.GetType IsNot GetType(System.Threading.ThreadAbortException)

If ex.GetType Is GetType(System.Threading.ThreadAbortException) Then

If Not fDidRunCleanup Then

If m_TestCleanup_method IsNot Nothing Then

m_TestCleanup_method.Invoke(m_TestClassInstance, BindingFlags.InvokeMethod, Nothing, Nothing, Nothing)

fDidRunCleanup = True

End If

Status = TstStatus.Aborted

ErrorMessage = "User aborted test run"

CType(disp, System.Windows.Threading.Dispatcher).Invoke(Threading.DispatcherPriority.Background, deldone)

Throw ex

End If

Debug.WriteLine(String.Format("Got exception {0} {1}", m_TestMethodInfo.Name, ex.InnerException.Message))

ErrorMessage = ex.InnerException.Message

stat = TstStatus.Failed

End Try

Me.Status = stat

mSecs = m_Stopwatch.ElapsedMilliseconds.ToString

m_Stopwatch.Stop()

Debug.WriteLine(TestName + " Done")

CType(disp, System.Windows.Threading.Dispatcher).Invoke(Threading.DispatcherPriority.Background, deldone)

End Sub

Sub BgThreadDone() ' runs on main thread

m_bgThread = Nothing

m_threadRunning = False

End Sub

Friend Sub RunTest(ByVal mWindow As Window1)

m_ThreadDoneEvent = New System.Threading.ManualResetEvent(False)

m_bgThread = New System.Threading.Thread(AddressOf BgThreadProc) ' cant' use BackgroundWorker because need STA

m_bgThread.Name = "MyTestHost runtests"

m_bgThread.SetApartmentState(System.Threading.ApartmentState.STA)

m_threadRunning = True

m_bgThread.Start(System.Windows.Threading.Dispatcher.CurrentDispatcher)

Do While m_threadRunning

If mWindow IsNot Nothing Then

Dim pbar As ProgressBar = mWindow.ProgressBar1

pbar.Value = DateTime.Now.Millisecond / 10

mWindow.Clock = (mWindow.StopWatch.ElapsedMilliseconds / 1000).ToString("f1")

End If

System.Windows.Forms.Application.DoEvents()

Loop

End Sub

Public Sub Reset()

mSecs = ""

ErrorMessage = ""

Status = TstStatus.Idle

End Sub

Public Property ErrorMessage() As String

Get

Return m_ErrorMessage

End Get

Set(ByVal value As String)

m_ErrorMessage = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("ErrorMessage"))

End Set

End Property

Public Property mSecs() As String

Get

Return m_ElapsedTime

End Get

Set(ByVal value As String)

m_ElapsedTime = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("mSecs"))

End Set

End Property

Public Property Status() As TstStatus

Get

Return m_TestStatus

End Get

Set(ByVal value As TstStatus)

If value <> m_TestStatus Then

m_TestStatus = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("Status"))

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("StatusColor"))

End If

End Set

End Property

Public ReadOnly Property StatusColor() As String

Get

Select Case m_TestStatus

Case TstStatus.Failed

Return "Red"

Case TstStatus.Idle

Return "LightBlue"

Case TstStatus.Pending

Return "Purple"

Case TstStatus.Aborted

Return "Red"

Case TstStatus.Passed

Return "Green"

Case TstStatus.NotRun

Return "Black"

Case Else

Return "Blue"

End Select

End Get

End Property

Public ReadOnly Property TestName() As String

Get

Return m_TestName

End Get

End Property

Public ReadOnly Property TestClass() As String

Get

Return m_TestClass

End Get

End Property

Public ReadOnly Property Description() As String

Get

Return m_Description

End Get

End Property

Public ReadOnly Property Owner() As String

Get

Return m_TestOwner

End Get

End Property

Public ReadOnly Property Pri() As String

Get

Return m_TestPriority

End Get

End Property

Public Property Selected() As Boolean

Get

Return m_Selected

End Get

Set(ByVal value As Boolean)

m_Selected = value

RaiseEvent PropertyChanged(Me, New PropertyChangedEventArgs("Selected"))

End Set

End Property

Public Overrides Function ToString() As String

Return String.Format("{0,-20} {1}", m_TestName.PadRight(20), m_TestClass)

End Function

Public Event PropertyChanged(ByVal sender As Object, ByVal e As PropertyChangedEventArgs) Implements INotifyPropertyChanged.PropertyChanged

End Class

</MyTestHost.vb code to paste >

End of blog entry