Getting started with ETW using .NET’s EventSource

October 13, 2014

.NET 4.5 introduced the EventSource class, allowing convenient access to Event Tracing for Windows (ETW) from managed code. This is a boon for enterprise developers, and I encourage you to go read up on it at MSDN. Also, be sure sure to check out Vance Morrison’s EventSource blog entries. Another useful blog by MS MVP Kathleen Dollard is Leaning into Windows, and Muhammad Shujaat Siddiqi’s blog is worth checking out as well.

Once you’ve got the hang of EventSource, take it to the next level with the Enterprise Library Semantic Logging Application Block (SLAB). You can do some pretty cool stuff with it, including verification of your EventSource class validity, and automatic routing of ETW events to different storage platforms (such as databases, Azure tables, and text files). Start with the developer’s guide.

Finally, if you take a close look at the documentation of the EventSource class, you’ll notice the following note:

There is a NuGet version of the EventSource class that provides more features. For more information, see Microsoft EventSource Library 1.0.16.

I couldn’t find any documentation for this mysterious NuGet package, but I did find its samples package. Once you install it you can take a look at the extensively documented code as well as debug and step into the parts you’re interested in. Be sure to read the guides that accompany the samples: _EventRegisterUsersGuide.docx and _EventSourceUsersGuide.docx - they pertain to the vanilla library that comes with .NET as well (not just the NuGet package).

One thing I couldn’t find is a list of differences between the vanilla .NET EventSource and the NuGet package. Going by the signatures, I only saw a couple more WriteEvent overloads. If you’ve read the documentation, you should know by now that that’s a good thing, however digging a little into the code I found another important difference – event type support.

The .NET version currently supports the following types (taken from ManifestBuilder.GetTypeName):

  1. Enum
  2. Boolean
  3. SByte
  4. Byte
  5. Int16
  6. UInt16
  7. Int32
  8. UInt32
  9. Int64
  10. UInt64
  11. Single
  12. Double
  13. DateTime
  14. String
  15. Guid

The NuGet package adds support for the following:

  1. Char
  2. IntPtr
  3. Byte*
  4. Byte[]

Finally, the beta pre-relase includes a very interesting overload: public void Write<T>(string eventName, T data). The data parameter is documented as follows:

The object containing the event payload data. The type T must be an anonymous type or a type with an [EventData] attribute. The public instance properties of data will be written recursively to create the fields of the event.

In other words, we should be able to use annotated custom types (in a similar fashion to WCF DataContract-annotated objects). But even better than that, we should be able to say:

public void Bar(int i, string s, DateTime d)
    Write(null, new {I = i, S = s, D = d});

Notice I said should, because I could make neither work (beta after all). But why do we even need this when we already have the WriteEvent(int eventId, params Object[]) overload? Well, let’s look at the documentation of the latter:

By default, the compiler calls this overload if the parameters for the call do not match one of the other method overloads. This overload is much slower than the other overloads, because it does the following:

  1. It allocates an array to hold the variable argument.
  2. It casts each parameter to an object (which causes allocations for primitive types).
  3. It assigns these objects to the array.
  4. It calls the function, which then determines the type of each argument so it can be serialized for ETW.

Using an anonymous types, we save the boxing (bullet 2) and unboxing (post bullet 4). I’m not sure how big of a benefit that is, so we may still be forced to use the WriteEventCore method, but I suppose every little bit helps!

Controlling the physical storage location of the Azure Storage Emulator

September 25, 2014

The Azure Storage Emulator is a very convenient tool for working against mocked Azure Storage services – blobs, queues and tables. However, it appears to have no visible means of setting the physical location used for storage, or even determining it. Luckily, both are easily achieve.


Blobs are stored on the file system, and that location is very easy to control:

  1. Navigate to C:\Users\<YourUserName>\AppData\Local\WAStorageEmulator
  2. Open WAStorageEmulator.<EmulatorVersion>.config with the test editor of your choice
  3. Change the PageBlobRoot and BlockBlobRoot to the location you desire (the default is something like C:\Users\<UserName>\AppData\Local\WAStorageEmulator\PageBlobRoot)

Tables and queues

Tables and queues are stored in a SQL server database (LocalDB by default), so in order to set the physical storage location, we simply need to set the physical storage location of the database (mdf file). We’ll use the sqlcmd utility to do that:

  1. Close all programs that may be using the storage emulator database (the storage emulator itself, management studio, visual studio, etc.)
  2. Run sqlcmd -S instancePath
    • By default the storage emulator uses LocalDB, so the above would be sqlcmd -S (localdb)\v11.0
    • If you configured a different SQL Server instance you’ll have to use that instead
    • You can always determine the instance path used by the storage emulator by examining the SQLInstance element in the WAStorageEmulator.<EmulatorVersion>.config file mentioned in the Blobs section above
  3. Type the following commands with [enter] after each line:
    1. SELECT name, physical_name AS CurrentLocation, state_desc FROM sys.master_files;
    2. Go;
  4. You will now see the list of all database files. Pick a file you want to move and note its name and current physical location. For example, suppose you want to move the WAStorageEmulatorDb32 file from its current location to E:\StorageEmulator\LocalDB\WAStorageEmulatorDb33.mdf
  5. Type the following commands with [enter] after each line:
    1. ALTER DATABASE WAStorageEmulatorDb33 SET OFFLINE with no_wait;
    2. Go;
  6. Move the mdf file from its current location to E:\StorageEmulator\LocalDB\WAStorageEmulatorDb33.mdf
  7. Type the following commands with [enter] after each line:
    1. ALTER DATABASE WAStorageEmulatorDb33 MODIFY FILE ( NAME = WAStorageEmulatorDb33, FILENAME = ‘E:\StorageEmulator\LocalDB\WAStorageEmulatorDb33.mdf’);
    2. ALTER DATABASE WAStorageEmulatorDb33 SET ONLINE;
    3. Go;
  8. All done. You can verify the result of the move by re-running the commands in step (3) and observing the new file location.

Knowing where the storage emulator stores its data and how to change that location can be useful. For example, if your C: drive is a small SSD, space may be running low. Conversely, your C: drive may be a slow hard disk drive, and you wish to use a faster SSD for storage emulation.

Obtaining old Mono and MonoDevelop Mac versions

August 28, 2014

I was recently looking for old Mono and MonoDevelop Mac versions and realised they weren’t trivial to find. So for the benefit of all mankind, here are the links:

For more information see:

Happy coding :)

Getting spinner gifs from a CDN

August 16, 2014

Using animated gifs for spinner / loader animation can be quite convenient, and sites such as AjaxLoad allow you to create them to your liking. However, being the early optimization evil person that I am, I was wondering if I could get those off a CDN. There doesn’t seem to be any official support for this, and you won’t get custom taliored gifs to your exact liking, but a sneaky web search reveals quite a few possibilities. For example:

Enjoy :)


July 12, 2014

A couple of months ago I blogged about TvGameLauncher, a command line tool to help you launch your favorite games on your HDMI-connected TV (or any other connected display) with all the necessary steps carried out for you (change primary display, change default audio endpoint, prevent sleep).

The tool works great (at least for me :) ), but its command-line nature leaves is inaccessible to users who aren’t comfortable with the command line and the entire experience isn’t that much fun.

Enter TvGameLauncherGUI. I’ve created a nice(?) WPF GUI front-end for TvGameLauncher, and also improved the latter for good measure:

  1. There is now a useful “darken non-primary displays” that will darken all displays except the one where the game takes place for improved gaming immersion atmosphere.
  2. TvGameLauncher now employs the excellent NirCmd instead of the previous relatively unknown (and less reliable and updated) tools.
  3. Improved logging, error handling, and more.

Get it at SourceForge, and be sure to check out the 5 minute tutorial on Youtube.



The Windows API Code Pack – the case of the missing samples

June 13, 2014

The Windows API Code Pack can be a boon for managed code developers wanting to access Windows functionality such as the TaskBar, Windows Shell, DirectX, Aero, Sensors, and more (see the article for a more complete list).

Unfortunately, the original link is dead (as is the entire MSDN Archive Gallery, may it rest in peace) – you can try the wayback machine but the download link won’t work. As it turns out, the code pack has found a new home in the Nuget repository:

This is all well and good, but these are just the binaries – where are the original code samples? The documentation comprises of thin XML API coverage, not nearly enough for a developer wanting to get started with development quickly. The original download contained many useful samples and these don’t seem to be available anymore.

Fortunately, a quick web search revealed quite a few mirrors of the original package (in its latest 1.1 version) :

And just because I’m paranoid, I’ve uploaded a copy to my OneDrive.

But wait, there’s more! The Windows 7 Training Kit For Developers contains yet additional samples using the Windows API Code Pack!

Happy coding :)


Creating managed wrappers for COM interfaces

May 31, 2014

COM interop can be a very useful tool, but it requires the definitions of the unmanaged interfaces one wants to use. This may be a little tricky, so here’s a small guide to help you out. Note that much of the advice below is applicable to P/Invoke as well.

Make sure it’s necessary

Many COM APIs have managed counterparts, so make sure you don’t waste your time doing what the BCL team already did for you. A quick search would usually lead you to the right StackOverflow / MSDN page. Make sure you check the Windows API Code Pack too.

See if it’s been done

Many times, the interface you want to use has already been written in managed form. For example, IPersistFile is already defined in mscorlib.dll (hint: you already have this referenced in your project by default) under the System.Runtime.InteropServices.ComTypes namespace.

A quick MSDN search should start you off in the right direction – you’d be surprised where you find some of them… For example, Microsoft.VisualStudio.TestTools.UITest.Extension contains IUniformResourceLocator, and Microsoft.VisualStudio.OLE.Interop contains IPropertyStorage. Searches beyond MSDN could be worthwhile as well, especially note Another useful source is Ohloh code search (note that you can filter by language, e.g. C#).

If you don’t want to take a dependency on the assembly that has the definition you want, you can always copy the definitions you need to your source (e.g. from Reflector).

Another repository of managed code definitions is embedded in the P/Invoke Interop Assistant (more on this tool later).

Use TlbImp

Sometimes you won’t find the interface you want defined anywhere. Fortunately, TlbImp can automatically create the needed managed COM definitions for you, provided that you can feed it with the appropriate type library (.tlb) files (note that these could be embedded in EXE and DLL files as resource) .

That would have been straightforward had the OS / SDK actually come with tlb files for the entire Win32 COM API, but that is not always the case. Instead, you can usually find an interface definition (.idl) file containing the interface you desire (use findstr or something like find in files in Notepad++).

Once you find the relevant IDL file, you will need to compile it into a TLB file, which in turn could be fed to TlbImp. The midl compiler does just that, but it will only produce tlb files for Library definitions, which may not be present. Fortunately, we can simply inject some Library definition with the interfaces we want into the IDL file and thus “trick” midl into producing the tlb.

For example, suppose you want to get the managed definition of the IPropertySetStorage interace, which resides in [SDKFolder]\Include\um\PropIdl.Idl. 

  1. Open PropIdl.Idl in your favorite text editor
  2. Add the following after the definition of IPropertySetStorage:
    [ uuid( 03383777-9430-4A45-9417-38B4B5CB4143 )] // (use guidgen.exe to generate this guid)
    library TempLib {
    interface IPropertySetStorage;
  3. Run midl PropIdl.Idl
  4. Run tlbimp PropIdl.tlb
  5. Don’t forget to undo your changes to PropIdl.Idl !

You will now have TempLib.dll containing all the required definitions for the interface.

Use the P/Invoke Interop Assistant

Sometimes you can’t even find IDL definitions for the interfaces you want, and in those cases you have to go hardcore and define them yourself. Note that you should look at the unmanaged definitions in the header (.h) file itself (again find it in the SDK folder with findstr or a similar tool) rather than the MSDN documentation, as definition order is very important and the docs don’t preserve it. MSDN may also present the signatures of the ANSI interface, whereas you’d likely want the Unicode variety (in the header file, they will be defined as InterfaceA for ANSI and InterfaceW for Unicode).

As for the signature conversion itself, the CLR Interop team has released the P/Invoke Interop Assistant to, well, assist you with that. Basically, you paste in the unmanaged signature of the interface / struct you want to use (grab them from MSDN), and it generates the managed definitions for you. Note that it may need your help sometimes for typedefs it doesn’t know (in these cases you need to “unwrap” the typedefs until you reach something it knows,  usually a basic type) so browsing the actual header files in Visual Studio may be more convenient (simply start a new Win32 project and include the desired header).

For more information on marshaling data between managed and unmanaged code see Marshaling Data with Platform Invoke. The P/Invoke Data Types table and the COM Data Types table are great cheat-sheets to have handy, too.

Don’t let Work Guy screw Home Guy over

May 1, 2014

A great man once said:

I never get enough sleep. I stay up late at night, cause I’m Night Guy. Night Guy wants to stay up late. ‘What about getting up after five hours sleep?’, oh that’s Morning Guy’s problem… That’s not my problem, I’m Night Guy – I stay up as late as I want! So you get up in the morning, you’re exhausted, groggy… oooh I hate that Night Guy!

See, Night Guy always screws Morning Guy. There’s nothing Morning Guy can do. The only Morning Guy can do is try and oversleep often enough so that Day Guy looses his job and Night Guy has no money to go out anymore.

Today, after tackling some annoying WCF issues at a late hour, I realized Work Guy and Home Guy have a very similar relationship.

When I’m at work , I stay to work late cause I’m Work Guy. I  want to track down that bug, I want to finish that piece of code, I want to get that test to pass, I want to study that interesting .NET topic a little further.

“What about getting home at 10:00 PM, missing the gym session you wanted to have, skipping that UFC title fight event you wanted to watch, and delaying that level you wanted to complete in your latest video game?”, oh that’s Home Guy’s problem - I’m Work Guy, I stay at work as late as I want!

So you get home late, and by the time you eat, shower, and write a small blog post you have to go to bed… ooh I hate that Work Guy ! It’s a good thing that by that time you’re already Night Guy, so you can stay up late :)

Measuring on-screen pixels

January 30, 2014

There are times when measuring pixels on-screen may be useful. This is especially true when following redline specifications (just make sure your browser zoom is set to 100%). There exist many free tools to aid in this task, and this SuperUser thread lists many of them. Luckily for you, I’ve tested most of the utilities proposed in the thread and the winner is… Cropper !


Even though it’s a screen capture utility, it works very well for pixel measuring. Some of its useful features (the full list appears on their site):

  • Always On Top
  • F8 Show the main form
  • Arrow keys Nudge the main form one pixel (hold Ctrl for 10 pixels)
  • Alt+Arrow keys Resize the main form one pixel (hold Ctrl for 10 pixels)

When you need that extreme precision, you can use it in conjunction with the Windows Magnifier:

  • Win + ‘+’ Magnify (will also open the magnifier if not already open)
  • Win + ‘-‘ Reduce
  • Win + Esc Close Magnifier

An honorary mention goes to Meazure. It is an excellent choice if you prefer a more verbose, extremely detailed UI with many features.


There are also various browser extensions that offer similar functionality, but a global tool is obviously better (I actually didn’t like any of the extensions I tried regardless).

Introducing TvGameLauncher

January 12, 2014

I recently blogged about Playing PC games on your HDMI-connected TV, and I mentioned a couple of programs you could use to get the job done, along with a couple of batch files you could whip up to ease the process.

Secretly though, I knew it wasn’t enough. So I wrote TvGameLauncher to take care of everything for you (including something I forgot – preventing computer sleep). Everything is now done automatically in one fell swoop. 

For example, in order to run ioquake3 on your TV, you could run a command such as TvGameLauncher.exe -t -h 2 -s 0 -e “F:\Games\ioquake3\ioquake3.x86.exe”

And in order to run Hotline Miami (through Steam): TvGameLauncher.exe -t -h 2 -s 0 -l steam://rungameid/219150 -e HotlineGL.exe

Again, thanks go to Dave Amenta and Michael Welter for their useful utilities that made this possible!

I have some ideas for improvements, but this should suffice for now. 




Get every new post delivered to your Inbox.