I like productivity at my fingertips, so for this post, I'm going to walk through a tool that I've created to save time for online researching.  This tool can be made to launch by simply using a shortcut key while you're in any application.

ResearchHelp

One common task is to look up some term in a variety of search engines.  For example, I might come across the phrase "Visual Studio Team System".  Often I search Google to find the key sites, Google Groups to see what people are saying about it in the newsgroups, Feedster to get the recent buzz from the blogs, etc.  To facilitate searching quickly, I put together a simple utility that I can also launch from a key stroke.  With a simple CTRL+C to copy the phrase, and CTRL+SHIFT+Y, I can get the following:

This application dynamically creates tabs for my configured search engines, and then uses the new WebBrowser control to display the results.  Dissecting this application shows a number of the new features in Visual Studio 2005. I'll use Visual C# 2005 Express Edition for this example. Depending on the language I wanted, I could have used any of the Visual Studio Express Editions to create a similar sample. Beta 2 of the Express editions can be downloaded from http://msdn.microsoft.com/express. 

First, the form is divided into two sections using the new SplitContainer control.  This control is a combination of 2 panels, and a splitter.  It's much easier to work with than the Visual Studio .NET 2003 Splitter control, which got tricky depending on the order in which you added the panels and splitter to the form.

The top panel contains a section that lets you enter the search information.  This is populated by default with whatever's in the clipboard.

Next, you see the new ToolStrip control.  This control makes it trivial to set up professional "Office" style toolbars, that support docking, floating, repositioning, and other features.  This toolbar just has a couple of buttons on it, but you can also add drop-downs, text boxes, labels, and a variety of other controls.  To wire up code for an item on the toolbar, you simply double-click it in the designer.  This ToolStrip contains two buttons.  The first will open the currently selected page in a new browser window, which is useful when you've found something interesting, and you want the full features of Internet Explorer.  The second button provides simple "Back" button functionality.

Below the toolbar is a Tab control.  The tabs are actually created at run-time when the search is performed, and a WebBrowser control is added to each tab to display the results.

The code for this application was very straightforward to write.  First, the application contains a list of configured search engines using a custom SearchInfo class:

Visual C#

private SearchInfo[] searches = { 
    new SearchInfo("Google Web", "http://www.google.com/search?q="),
    new SearchInfo("Google Groups", "http://groups-beta.google.com/groups?q="),
    new SearchInfo("Google News", "http://news.google.com/news?q="),
    new SearchInfo("Feedster", "http://www.feedster.com/search.php?q="),
    new SearchInfo("Technorati", 
        "http://www.technorati.com/cosmos/search.html?rank=&url=")
};

Visual Basic

Private searches As SearchInfo() = { _
    New SearchInfo("Google Web", "http://www.google.com/search?q="), _
    New SearchInfo("Google Groups", "http://groups-
        beta.google.com/groups?q="), _
    New SearchInfo("Google News", "http://news.google.com/news?q="), _
    New SearchInfo("Feedster", "http://www.feedster.com/search.php?q="), _
    New SearchInfo("Technorati", 
        "http://www.technorati.com/cosmos/search.html?rank=&url=") _
}

If you have other search engines that you want to use, you can just add them here.

The Form_Load event does a couple of things.  First, it registers a shortcut for the application:

Visual C#

string shortcutPath = 
     Environment.GetFolderPath(Environment.SpecialFolder.Programs) 
     + @"\ResearchHelp.lnk";
if (!System.IO.File.Exists(shortcutPath))
{
    WshShell shell = new WshShell();
    IWshShortcut shortcut = (IWshShortcut)shell.CreateShortcut(shortcutPath);
    shortcut.Hotkey = "CTRL+SHIFT+Y";
    shortcut.TargetPath = Assembly.GetExecutingAssembly().Location;
    shortcut.Description = "ResearchHelp";
    shortcut.Save();
}

Visual Basic

Dim shortcutPath As String = _
     Environment.GetFolderPath(Environment.SpecialFolder.Programs) _
     & "\ResearchHelp.lnk"
If Not System.IO.File.Exists(shortcutPath) Then
    Dim shell As WshShell = New WshShell()
    Dim shortcut As IWshShortcut = 
        CType(shell.CreateShortcut(shortcutPath), IWshShortcut)
    shortcut.Hotkey = "CTRL+SHIFT+Y"
    shortcut.TargetPath = Assembly.GetExecutingAssembly().Location
    shortcut.Description = "ResearchHelp"
    shortcut.Save()
End If

And then, some new methods on the Clipboard class are used to see if the Clipboard contains a search string:

Visual C#

if (Clipboard.ContainsText)
{
    topicTextBox.Text = Clipboard.GetText();
}

Visual Basic

If Clipboard.ContainsText() Then
    topicTextBox.Text = Clipboard.GetText()
End If

You can see that this makes it very simple to see if the clipboard contains data in a certain format, and then extract that data in a more strongly typed way.

When the search button is clicked, the application iterates through all the SearchInfo objects, and creates corresponding tabs and WebBrowser instances to show the results.  With the new WebBrowser control in Visual Studio 2005, you can see that the browser is simple to work with:

Visual C#

private void searchButton_Click(object sender, EventArgs e)
{
    searchTab.Controls.Clear();
    foreach (SearchInfo si in searches)
    {
        TabPage tp = new TabPage(si.Description);
        WebBrowser wb = new WebBrowser();
        searchTab.Controls.Add(tp);
        tp.Controls.Add(wb);
        wb.Dock = DockStyle.Fill;
        wb.ScriptErrorsSuppressed = true;
        wb.Navigate(si.BaseURL + topicTextBox.Text);
    }
}

Visual Basic

Private Sub searchButton_Click(ByVal sender As System.Object, _
     ByVal e As System.EventArgs) Handles searchButton.Click
    searchTab.Controls.Clear()
    For Each si As SearchInfo In searches
        Dim tp As TabPage = New TabPage(si.Description)
        Dim wb As WebBrowser = New WebBrowser()
        searchTab.Controls.Add(tp)
        tp.Controls.Add(wb)
        wb.Dock = DockStyle.Fill
        wb.ScriptErrorsSuppressed = True
        wb.Navigate(si.BaseURL & topicTextBox.Text)
    Next
End Sub

The TabPage objects are added to the TabControl, and then the WebBrowser objects are added to each tab.  Each browser is set to DockStyle.Fill to fill the available tab space.  Finally, the Navigate method is used to perform the actual search and show the results.  Navigate is an asynchronous method, so all the browser instances can be searching in parallel.

Conclusion

Visual Studio 2005 made it trivial for me to create a utility that I now use all the time.  New controls like the SplitContainer, ToolStrip, and WebBrowser made it very quick to put together an easy-to-use interface.  Enhancements to the Clipboard class make it more intuitive to use, and the WebBrowser is a nice managed wrapper around the browser control. Get started today by downloading one of the Visual Studio 2005 Express Editions from http://msdn.microsoft.com/express.

Parting tip: I'm a big fan of hot-keys instead of mouse clicks.  When I'm writing code, I like to keep my hands on the keyboard.  One thing that I often do in Visual Studio is CTRL+TAB to switch between my open code windows.  It was an interesting surprise to see that even this has been enhanced.  When I CTRL-TAB now, the following window opens in Visual Studio to make it easy to pick exactly the file I want:

For this first post, I've decided to dig into the new System.Net.NetworkInformation namespace, and build a simple utility that will look for devices on the network:

This gave me the opportunity to explore a number of new features in Visual Studio 2005 by using Visual C# Express Edition. Depending on the language I wanted, I could have used any of the Visual Studio Express Editions for this sample. Beta 2 of the Express editions can be downloaded from http://msdn.microsoft.com/express.  

The core of this application is the new Ping class (System.Net.NetworkInformation.Ping).  This gives you built-in functionality for sending an ICMP echo request to a network device.

Visual C#

IPAddress ip = IPAddress.Parse("192.168.1.1");
Ping ping = new Ping();
PingReply pr = ping.Send(ip);

Visual Basic

IPAddress ip = IPAddress.Parse("192.168.1.1")
Dim newPing As Ping = New Ping()
Dim pr As PingReply = newPing.Send(ip)

You can see that the .NET Framework 2.0 makes it trivial to ping a network device.  Prior to the .NET Framework 2.0, it was substantially more code to accomplish this.

In addition, I wanted to make this asynchronous so that the pings were being done in the background, and the UI was not blocked, and updated as the results came in.  Also, because there could potentially be a very large number of IP addresses, I didn't want to fire off pings for all of them at the same time.  For my testing, having about 200 pings going at the same time worked well.

Letting 200 pings go at one time turned out to be trivial to perform using the semaphore class.  Here's how it works:

First, you declare the semaphore class with the maximum number of threads you want to allow.  In this case that's 200:

Visual C#

const int THREAD_COUNT = 200;
private Semaphore pingBlock = new Semaphore(0, THREAD_COUNT);
pingBlock.Release(THREAD_COUNT);

Visual Basic

const int THREAD_COUNT = 200;
private Semaphore pingBlock = new Semaphore(0, THREAD_COUNT);
pingBlock.Release(THREAD_COUNT);

Now, when the application wants to spawn a new thread to perform a ping, it uses the semaphore to insure that there aren't already 200 pings running.  The code can do this as follows:

Visual C#

pingBlock.WaitOne();

Visual Basic

pingBlock.WaitOne()

This call allocates an item in the semaphore.  If all 200 are already allocated, then this call will block until one of the items is released.  Once WaitOne returns, this thread is unblocked, and can perform the ping.  Once the ping has completed, the thread needs to release the semaphore object so that another thread can unblock and do its ping.  This repeats until all the pings are completed.  A semaphore object is released as follows:

Visual C#

pingBlock.Release();

Visual Basic

pingBlock.Release()

To handle all the ping operations, I created a class called "NetScan".  To kick off a set of pings, you call the NetScan.Start method, and pass in the range of IP addresses that you want it to loop through.  NetScan handles all the background threads, and fires events when each ping has completed, and another event when all of the pings are done.  In the .NET Framework 2.0, the syntax for declaring an event is much simpler.  In the past, you had to declare a delegate, and an event.  Now, you just use the generic EventHandler<T>:

Visual C#

//
// Fired when each ping completes
// 
public event EventHandler<NetScanCompletedEventArgs> PingComplete;

//
// Fired when all pings complete
//
public event EventHandler<EventArgs> NetScanComplete;

Visual Basic

'
' Fired when each ping completes
' 
Public Event PingComplete As EventHandler(Of NetScanCompletedEventArgs)

'
' Fired when all pings complete
'
Public Event NetScanComplete As EventHandler(Of EventArgs)

The syntax for raising an event remains unchanged:

Visual C#

NetScanComplete(this, new EventArgs());

Visual Basic

RaiseEvent NetScanComplete(Me, New EventArgs())

The form can then wire up handlers to respond to these events.  When each ping completes, an event is raised that lets the user interface show the results of the ping.  When all the pings have completed, an event is raised that lets the user interface know that all the results are in.  This could have been handled with traditional event handlers, but C# 2.0 supports a new feature known as anonymous methods, and I implemented the handler with those.  Here's all the code for setting up the event handlers and kicking off the ping operations:

Visual C#

//
// The NetScan will perform the pings on separate threads
//
NetScan ns = new NetScan();

//
// Event handler for when each ping completes.
//
ns.PingComplete += delegate(object s, NetScanCompletedEventArgs ev)
{
    if (ev.Reply.Status == IPStatus.Success)
    {
        ListViewItem li = new ListViewItem(new string[] {
            ev.Reply.Address.ToString(),
            ev.Reply.RoundtripTime.ToString(CultureInfo.InvariantCulture)
            + " ms" });
        resultsListView.Items.Add(li);
    }
};

//
// Event handler for when all pings have completed.
//
ns.NetScanComplete += delegate(object s, EventArgs ev)
{
    scanButton.Enabled = true;
};

//
// Disable the "Scan" button while the pings are running, and start the 
// pings.
//
scanButton.Enabled = false;
ns.Start(new PingRange(startIP, endIP));

Visual Basic

'
' The NetScan will perform the pings on separate threads
'
Dim ns As NetScan = New NetScan()

'
' Event handler for when each ping completes.
'
AddHandler ns.PingComplete, AddressOf PingComplete

'
' Event handler for when all pings have completed.
'
AddHandler ns.NetScanComplete, AddressOf NetScanComplete
'
' Disable the "Scan" button while the pings are running, and start the ‘ 
' pings.
'
scanButton.Enabled = False
ns.Start(New PingRange(startIP, endIP))

Private Sub PingComplete(ByVal s As Object, 
    ByVal ev As NetScanCompletedEventArgs)

    If ev.Reply.Status = IPStatus.Success Then
        Dim li As ListViewItem = New ListViewItem(New String() 
            {ev.Reply.Address.ToString(), 
            ev.Reply.RoundtripTime.ToString(
            CultureInfo.InvariantCulture) + " ms"})
        resultsListView.Items.Add(li)
    End If
End Sub

Private Sub NetScanComplete(ByVal s As Object, ByVal ev As EventArgs)
    scanButton.Enabled = True
End Sub

You can see that the event handlers for PingComplete and NetScanComplete are just placed in-line in the method body.

This completes the tour of this application.  You can download Visual C# 2005 Express Edition and explore this application for yourself. Get started at http://msdn.microsoft.com/express.

Interacting visually with the Windows Desktop from code is fun, so I decided to see what it would take to change the appearance.  This sample application allows you select an image and set it as wallpaper:

It turns out that wallpaper is not directly accessible from managed code, but working with Win32 API's is no problem in this case.  Developing this application allowed me to work with methods imported from system DLL's, the registry, the file open dialog, a custom enumerated type, and use datasource binding to that enumerated type.

The application allows you to browse to an image, view a preview (resized smaller to fit if necessary), select the display style (Tiled, Stretched, or Centered), and set the image as the Desktop background.  This enabled me to work some of the new features in Visual Studio 2005 as well.  The code samples shown in this article use Visual C# 2005 Express Edition, however any of the Visual Studio Express Editions can be used to create a similar sample.  Visual Basic source code is also included with the code download for this article. Beta 2 of the Express editions can be downloaded from http://msdn.microsoft.com/express.

As seen above, the form consists of a button to browse to an image, a button to set the background to that image, a drop-down list of sizing options, and the currently selected image.  Not visible are a SplitContainer control (separating the buttons and ComboBox control from the image) and a file open dialog.  As seen in the ResearchHelp sample, the SplitContainer control is easy to use and allows the user more control over the layout of the user interface.  In the upper panel, the interactive controls have been placed, while the lower space is filled with a docked PictureBox control.

Desktop wallpaper can use one of three different sizing styles for display.  The Tiled option displays the image at full-size, repeating the image as needed, horizontally and vertically, to fill the screen.  The Stretched option displays the image at whatever size necessary to fill the screen either horizontally or vertically.  Finally, the Centered option places the image at the center of the screen, exactly once, whether if fills the screen or not, even allowing it to go beyond the edges of the screen if it is too large.  In order to support these three styles in an object-oriented way, an enumerated type was created.  This allows us to use the various style options as strongly-typed objects.  This is preferable to string or numeric representations that may not contain valid values and can cause trouble when passed to a method.

Visual C#

public enum Style: int
{
    Tiled, Centered, Stretched
}

Visual Basic

Public Enum Style As Integer
    Tiled
    Centered
    Stretched
End Enum

The code that actually sets the image as wallpaper accepts the path to the image and a Style reference.  Two registry values are set in the Control Panel\Desktop key.  Based on which sizing style is requested, numeric codes are set for the WallpaperStyle and TileWallpaper values.  Using an enumerated type for the style means the value is guaranteed to match one of the three defined options -- no default case is needed.

Visual C#

RegistryKey key = Registry.CurrentUser.OpenSubKey("Control Panel\\Desktop", true);
switch( style )
{
    case Style.Stretched :
        key.SetValue(@"WallpaperStyle", "2") ; 
        key.SetValue(@"TileWallpaper", "0") ;
        break;
    case Style.Centered :
        key.SetValue(@"WallpaperStyle", "1") ; 
        key.SetValue(@"TileWallpaper", "0") ; 
        break;
    case Style.Tiled :
        key.SetValue(@"WallpaperStyle", "1") ; 
        key.SetValue(@"TileWallpaper", "1") ;
        break;
}

Visual Basic

Dim key As RegistryKey = My.Computer.Registry.CurrentUser.OpenSubKey("Control Panel\Desktop", True)
Select Case selectedStyle
    Case Style.Stretched
        key.SetValue("WallpaperStyle", "2")
        key.SetValue("TileWallpaper", "0")
    Case Style.Centered
        key.SetValue("WallpaperStyle", "1")
        key.SetValue("TileWallpaper", "0")
    Case Style.Tiled
        key.SetValue("WallpaperStyle", "1")
        key.SetValue("TileWallpaper", "1")
End Select

At this point, the sizing options have been set, but the actual image path still needs to be set.  The SystemParametersInfo function exists in the user32.dll to allow you to set or retrieve hardware and configuration information from your system.  The function accepts four arguments.  The first indicates the operation to take place, the second two parameters represent data to be set, dependant on requested operation, and the final parameter allows you to specify how changes are saved and/or broadcasted.  The DllImport attribute allows you to specify a DLL, the function to call, and any required arguments.

Visual C#

[DllImport("user32.dll", CharSet = CharSet.Auto)]
static extern int SystemParametersInfo(
    int uAction, int uParam, string lpvParam, int fuWinIni);

Visual Basic

<DllImport("user32")> _
Public Shared Function SystemParametersInfo(ByVal uAction As Integer, _
     ByVal uParam As Integer, ByVal lpvParam As String, ByVal fuWinIni _   
     As Integer) As Integer
End Function

In addition to importing the function, you will need to define some constants for use with it.  The first constant represents the wallpaper operation to take place in this sample, to be used in the first argument.  The other two constants will be combined together for the final argument.

Visual C#

const int SPI_SETDESKWALLPAPER = 20;
const int SPIF_UPDATEINIFILE = 0x01;
const int SPIF_SENDWININICHANGE = 0x02;

Visual Basic

Const SPI_SETDESKWALLPAPER As Integer = 20
Const SPIF_UPDATEINIFILE As Integer = &H1&
Const SPIF_SENDWININICHANGE As Integer = &H2&

Once the function is imported, you can call it like any other.  The operation to be invoked is SPI_SETDESKWALLPAPER.  In our sample, the second argument is not needed so set to zero.  The third argument is a reference to the image path.  Note that the image must be in bitmap format.  The final argument specifies that the changes should persist, and also be immediately visible.

Visual C#

SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, path, SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE);

Visual Basic

SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, path, SPIF_UPDATEINIFILE Or SPIF_SENDWININICHANGE)

At this point, everything is in place to update the desktop wallpaper.  The user interface provides a Browse button that defaults to the Windows system directory with a *.bmp filter.  About a dozen bitmaps are available here.  The drop-down list is databound to the Style enumerated type by calling the Enum.GetNames() method in the System namespace.  This returns a string array perfect for lists and iteration.

Visual C#


styleComboBox.DataSource = System.Enum.GetNames(typeof(Wallpaper.Style));

Visual Basic

styleComboBox.DataSource = System.Enum.GetNames(GetType(Wallpaper.Style))

When the user clicks the Set button, the selected ComboBox text must be casted back to the enumerated item object.  Note that this method would throw an exception if an invalid string was passed to it, but this isn't a risk with a ComboBox.  The conversion occurs as follows:

Visual C#

(Wallpaper.Style)Enum.Parse(typeof(Wallpaper.Style), styleComboBox.Text)

Visual Basic

CType(System.Enum.Parse(GetType(Wallpaper.Style), styleComboBox.Text),            
      Wallpaper.Style)

Conclusion

The Win32 API makes it relatively easy to take advantage of features that aren't available in the .NET Framework.  A nice addition would be to use the Save() method of the Bitmap class to automatically convert images to Bitmap format so a user could select JPEG or GIF images from the local hard drive.  Download Visual C# 2005 Express Edition or Visual Basic 2005 Express Edition and give this application a try.  Get started at http://msdn.microsoft.com/express.  

Note: For this code sample, please make sure to open the project with the Windows Form visible, select performanceCounter1 from the application tray, switch to the Properties Window and change the MachineName property to your computer name.

Laptops are currently outselling desktops, which means a couple of things.  It means that users are more mobile, and are using applications while they sit in conference rooms, coffee shops, or airline seats.  This also means that for a good percentage of the day, you can be away from the wall outlet that gives life to your laptop.  I often find that I'm consciously aware of what I run when I'm on a long flight, because I want the battery to last it all the way to my destination.  However, my choice of application usage is based on in intuition and environmental clues.  For example, if the fan's running, and the performance of applications is “chunky”, then I know that I'm loading the system down, and the battery is bleeding dry faster than I would like.  However, I wanted something a little more scientific than just laying my hands on the machine, and trying to feel the force of the current flowing.  There are some really sophisticated pieces of software that will examine the power usage of various applications, but I figured by just monitoring a few key performance counters, I could have a pretty good approximation of the drain rate.

The Stats

First, you know that when the CPU is maxed out, you're using a lot of battery.  The hard drive is another expensive piece of equipment to use, so physical disk IO is another indication.  Finally, network usage – especially wireless network usage – can also be a significant drain.  There are some other significant factors as well (is your brightness turned up all the way, for example), but much of this information is not readily accessible through software, so it's left out of the mix.  Even so, I believe that the power monitor developed for this article gives a good indication of how fast you're draining the electron bank.

The App

I wanted an application that made it really easy to know how much power you were using, and specifically where that power was going, so the following user interface was developed:

This is the power usage while I was simultaneously zipping a directory that contained SQL 2000, and downloading an ISO image over the wireless network.  As you can see, the system is hammered, and the power usage monitor indicates that the CPU, disk, and networking subsystems are all being stressed.  Stop the download, and the networking usage drops off:

And stop the Zip operation, and the system returns to a more idle state:

Also note the blue bar.  This indicates what the average power usage has been for the last minute.  As power usage tends to jump around a fair amount as applications are running, and this gives you an instant look what the average usage level has been.

The Details

The application uses a timer control to poll certain system counters on a regular – two second – interval.  For CPU data, this is trivial.  You can just use the .NET Framework's PerformanceCounter class.  For disk IO, the story is a tad more complicated.  The counter that I wanted to read was the “Physical Disk:% Disk Time:_Total” counter.  Unfortunately, as documented here, reading that counter from the .NET Framework is broken in v1.0, 1.1, and apparently still in v2.0.  However, with just a little WMI code, you can easily get this information:

Visual C#

physDiskCounter = new ManagementObject(
                "Win32_PerfRawData_PerfDisk_PhysicalDisk.Name='_Total'"); 

physDiskCounter.Get();
double newCountBase = (double)(ulong)physDiskCounter.Properties[
                       "PercentDiskTime_Base"].Value;
double newCountValue = (double)(ulong)physDiskCounter.Properties[
                       "PercentDiskTime"].Value;
double result = ((prevCountValue - newCountValue) / 
                (prevCountBase - newCountBase)) * 100;
prevCountBase = newCountBase;
prevCountValue = newCountValue;
return result;

Visual Basic

physDiskCounter = New ManagementObject(
                  "Win32_PerfRawData_PerfDisk_PhysicalDisk.Name='_Total'")

physDiskCounter.Get();
double newCountBase = (double)(ulong)physDiskCounter.Properties[
                       "PercentDiskTime_Base"].Value;
double newCountValue = (double)(ulong)physDiskCounter.Properties[
                        "PercentDiskTime"].Value;
double result = ((prevCountValue - newCountValue) /
                (prevCountBase - newCountBase)) * 100;
prevCountBase = newCountBase;
prevCountValue = newCountValue;
return result;

This just accesses the raw performance counter values, subtracts off the previous value to get the delta, and returns the results.

Reading the network information is also a problem, but for a different reason.  First, I really want to just monitor the wireless network card, as that's what uses the most power.  I certainly don't want things like the loopback adapter included in the mix.  There are some low level APIs that I could use to find the wireless network adapter, but fortunately version 2.0 of the Framework contains a number of new networking classes that make this easy:

Visual C#

// Look for a "real" network interface, and preferably
// a WiFi, as it uses the most power.
NetworkInterface[] interfaces = 
    NetworkInterface.GetAllNetworkInterfaces();
foreach (NetworkInterface ni in interfaces)
{
    if (ni.NetworkInterfaceType == NetworkInterfaceType.Wireless80211 ||
        ni.NetworkInterfaceType == NetworkInterfaceType.Ethernet)
    {
        netName = ni.Description.Replace("(", "[").Replace(")", "]");
        speed = ni.Speed / 10;
        if (ni.NetworkInterfaceType == NetworkInterfaceType.Wireless80211)
        {
            break;
        }
    }
} 

Visual Basic

' Look for a "real" network interface, and preferably
' a WiFi, as it uses the most power.
Dim interfaces() As NetworkInterface =  
    NetworkInterface.GetAllNetworkInterfaces() 
Dim ni As NetworkInterface
For Each ni In interfaces
    If ni.NetworkInterfaceType = NetworkInterfaceType.Wireless80211 Or _
        ni.NetworkInterfaceType = NetworkInterfaceType.Ethernet Then
        netName = ni.Description.Replace("(", "[").Replace(")", "]")
        speed = ni.Speed / 10
        If ni.NetworkInterfaceType = 
            NetworkInterfaceType.Wireless80211 Then
            Exit For
        End If
    End If
Next

You can see that the NetworkInterface class exposes a wealth of information about each network interface.  Specifically, it's easy to find an 802.11 interface.  However (nothing's ever easy), this method returned “Intel 21140-Based PCI Fast Ethernet Adapter (Generic) - Packet Scheduler Miniport” for the adapter description.  However, the “real” name appears to be “Intel 21140-Based PCI Fast Ethernet Adapter [Generic] - Packet Scheduler Miniport”.  Note the brackets instead of parenthesis around the work “Generic”.  I'm not sure why the NetworkInterface API is returning parenthesis, but it's enough of a difference that if you try to use a PerformanceCounter class, or WMI, to read the counter, it won't find it because the name exactly doesn't match.

I ran into another problem with the PerformanceCounter as well.  It appears that it truncates the instance name to 64 characters, so while I passed in “Intel 21140-Based PCI Fast Ethernet Adapter [Generic] - Packet Scheduler Miniport”, it only took “Intel 21140-Based PCI Fast Ethernet Adapter [Generic] - Packet S”.  The last 17 characters were lopped off, and the PerformanceCounter class threw an exception saying it couldn't find what I was looking for.

The (relatively) new MSDN Product Feedback Center came to the rescue.  I used it to look up the bug, and found that it had already been reported, and that it was scheduled to be fixed in Beta 2 of Visual Studio 2005.

In the end, it was back to WMI to read this performance counter as well.

That's Smooth

At this point, I was able to read all the applicable performance counters, and it was time to render the information.  When reading performance counters, you want to read them infrequently, as reading performance counters is relatively expensive.  However, if your bar graph only updates every two seconds, it tends to jump around a lot, making it hard to see how much power you're really using (high one reading, low the next).  I wanted to smooth out the movement of the bar, so I used an additional timer control, ticking 10 times per second, to move the bar an increment between the last performance counter reading, and the current one.  The affect is shown here:

The Solution is the Problem

Again, you don't want your power monitor to use a lot of power itself.  This application can consume as much as 6% of the CPU while it's running.  To me, this is too expensive.  To correct for this, I modified the application so that when it's minimized, it uses a system tray icon to display the power usage graphics, and with a little logic, the application uses much less power. 

A really good way to reduce the power of many applications is to shut off your rending logic if the application isn't visible.  This is really simple to do (but you'd be surprised how few applications bother to do this):

Visual C#

if (Visible)
{
    int x = pictureBox1.Width;
    int y = pictureBox1.Height;
    using (Graphics g = pictureBox1.CreateGraphics())
    {
        Render(g, x, y);
    }
}

Visual Basic

If Visible Then
    Dim x As Integer = pictureBox1.Width
    Dim y As Integer = pictureBox1.Height
    Using g As Graphics = pictureBox1.CreateGraphics()
        Render(g, x, y)
    End Using
End If

In other words, if the Form isn't visible, don't render the bar graph on it.  This change alone cut the power consumption from 6% of CPU to about 2% of CPU.  When the application is minimized, it still renders the bar graph to the system tray using the notification icon control:

Visual C#

Bitmap iconBitmap = new Bitmap(16, 16);
using (Graphics g = Graphics.FromImage(iconBitmap))
{
    Render(g, 16, 16);
    try
    {
        notifyIcon1.Icon = Icon.FromHandle(iconBitmap.GetHicon());
    }
    catch (Exception)
    {
    }
} 

Visual Basic

Dim iconBitmap As Bitmap = New Bitmap(16, 16)
Using g As Graphics = Graphics.FromImage(iconBitmap)
    Render(g, 16, 16)
    Try
        notifyIcon1.Icon =
            System.Drawing.Icon.FromHandle(iconBitmap.GetHicon())
    Catch
    End Try
End Using

As you can see, it's easy to generate a bitmap, and then use the GetHicon method to display the bitmap in the notification icon.  Rendering a 256 pixels to the system tray uses very little power compared rendering 11500 pixels to the form.

One other thing I quickly noticed was that, because the notification icon just isn't the same resolution, you didn't see a physical change in it 10 times a second, so I realized that I could drop my rendering rate when the power monitor is minimized:

Visual C#

private void Form1_VisibleChanged(object sender, EventArgs e)
{
    renderTimer.Interval = Visible ? 100 : 500;    
}

Visual Basic

Private Sub Form1_VisibleChanged(ByVal sender As Object, ByVal e As  
    EventArgs) Handles Me.VisibleChanged
    renderTimer.Interval = IIf(Visible, 100, 500)
End Sub

With these changes in effect, the power monitor now consumes an average of less than 1% of CPU when minimized, while still providing a visual indication of overall power usage.  With a simple double-click, you can display the full form for more details.  This is low enough power consumption that you can leave it running all the time without significantly affecting battery life.

At this point, I have an application that I can easily use to make intelligent choices about what to run to conserve battery.  Also, while the application doesn't monitor individual processes, I have found it useful for identifying power hogs.

When I read the announcement that Visual Studio 2005 Tools for Microsoft Office (VSTO 2005) had added support for Microsoft Outlook (currently in beta), I downloaded it immediately! After all, my digital universe revolves around email, and being able to easily extend Outlook in custom ways has always been a wish of mine. Writing add-ins for Outlook certainly isn't a new capability, but it was never as easy to write useful, secure code as it is now.

My first step was to download the VSTO Outlook Beta installer. Then, to speed up the learning curve, I downloaded the conveniently supplied snippets. Including the snippets, even this early build is immensely helpful and a great way to jumpstart your creativity. As you will see, the extensibility is quite broad, and in fact we will only be able to scratch the surface with this article. Don't worry though; I'll revisit it again in future columns.

The application we will create today is basically a Hello World for Outlook. We'll step through creating an email message and a contact. The supplied code samples in this article are written in C#, however Visual Basic source code is also included with the code download for this article. Developing with VSTO requires a version of Visual Studio greater than Express Edition. The current beta of Visual Studio can be downloaded from http://lab.msdn.microsoft.com/vs2005/get/. Of course, Microsoft Office Professional 2003 (Service Pack 1) is also a requirement for this article, or at least Outlook 2003 SP1. Be aware that Outlook Express will not function as a replacement for Outlook.

The first step after installing the above is to create an Outlook Add-in project in the Office project templates section in Visual Studio. Notice that alongside the Excel and Word templates, there is a new option for Outlook. Specify a name and click OK.

Creating the Outlook Add-in project (click image to zoom)

Actually working with the new features could have proved to be difficult, but it turns out that the object model and available events just make sense. The project template adds a few references for general VSTO and specifically for Outlook. It also creates a setup project to simplify deployment. The main class file is ThisApplication.cs and contains a Startup and Shutdown event handler similar to other VSTO project types.

To avoid presenting too much material at once, in our example creating these items will occur when the add-in starts up and we will not use a menu or any user input to trigger it. Though not realistic, it makes it easier to step into this new functionality. Keep in mind though, that you can create custom menus on the standard menu bar, or respond to events such as the currently active folder, new messages arriving, or an appointment reminder.

Creating mail items, contacts, and folders is easy using the snippets, but be sure to read the readme that appears after installing them. Though the snippets are installed, they will not appear in the Insert Snippet menu item until added through the Visual Studio Snippets Manager (Tools | Code Snippets Manager menu command).

In order to create a new mail message, you will first need to obtain a reference to an Outlook.MAPIFolder object. This encapsulates an Outlook folder like Inbox, Draft, Outbox, or user-created folders. In order to get the default Outbox folder call the GetDefaultFolder method of the MAPI namespace object:

Visual C#

Outlook.MAPIFolder outBoxfolder = this.GetNamespace("MAPI").GetDefaultFolder( 
    Microsoft.Office.Interop.Outlook.OlDefaultFolders.olFolderOutbox); 

Visual Basic

Dim outBoxfolder As Outlook.MAPIFolder = 
    Me.GetNamespace("MAPI").GetDefaultFolder(    
    Microsoft.Office.Interop.Outlook.OlDefaultFolders.olFolderOutbox)

Correction (9/7/2005, thanks to Sue Mosher, Outlook MVP): You should actually use the Application.CreateItem method, which is the standard (and simpler) technique for creating a new item in one of the default folders.

Once you have a reference to the folder, you can add an item to it. Because the Outbox is generally intended for mail items, that is what we will add, but remember that Outlook supports any item type being added to any folder. To create and add a new mail item, call the Items.Add method of the folder object:

Visual C#

Outlook.MailItem mailItem = (Outlook.MailItem)outBoxfolder.Items.Add(Outlook.OlItemType.olMailItem);

Visual Basic

Dim mailItem As Outlook.MailItem = 
    outBoxfolder.Items.Add(Outlook.OlItemType.olMailItem)

At this point you have a mail item to manipulate. You can set the Subject, Body, and To properties, add a reminder, attach files, display the message, and of course send it:

Visual C#

mailItem.Subject = "Coding4Fun Sample";
mailItem.Body = "This email was created using VSTO 2005 Outlook support.";
mailItem.To = "emailaddress@emailaddress";

Visual Basic

mailItem.Subject = "Coding4Fun Sample" 
mailItem.Body = "This email was created using VSTO 2005 Outlook support."
mailItem.To = "emailaddress@emailaddress" 

Sending the message simply requires calling the Send method, while displaying the message is accomplished with the Display method (modally or not). If you do not call the Send or Save method, the message will not persist unless you display the message to allow the user to save or send it. This model is consistent with the various item types.

If you have added the snippets, you can create a mail item in two quick steps: insert the snippet, and then fill in the placeholder fields. You should probably create a new method to contain your message sending code, then right-click and select Insert Snippet, and navigate to the Outlook | Create sub-menu. You will see all of the above code, including helpful TODO comments, and commented out Send and Display calls.

A sample message (click image to zoom)

There is no snippet for adding a task item (yet anyway), so for our final sample, let's create a new task. The API is so well thought-out, that once you can create an email, creating a task is a snap. As before, obtain a reference to the folder, this time the Tasks folder. Also as before, remember that any folder will hold a task. This feature is useful for linking items and maintaining isolation between business or project boundaries. Once again, the folder is one of the defaults, so call GetDefaultFolder, this time with the olFolderTasks enumerated folder name:

Visual C#

Outlook.MAPIFolder tasksFolder = this.GetNamespace("MAPI").GetDefaultFolder( 
    Microsoft.Office.Interop.Outlook.OlDefaultFolders.olFolderTasks); 

Visual Basic

Dim outBoxfolder As Outlook.MAPIFolder = 
    Me.GetNamespace("MAPI").GetDefaultFolder(
    Microsoft.Office.Interop.Outlook.OlDefaultFolders.olFolderTasks)

Next, add a new instance of a task item. Notice that you are not calling a constructor. Each item type is actually an interface. Items must be created as children of a folder, not as stand-alone objects:

Visual C#

Outlook.TaskItem taskItem = (Outlook.TaskItem)tasksFolder.Items.Add(Outlook.OlItemType.olTaskItem);

Visual Basic

Dim taskItem As Outlook.TaskItem = 
    outBoxfolder.Items.Add(Outlook.OlItemType.olTaskItem)

Next, set the appropriate properties. In this case, the task's subject, owner, percentage complete, and status. Status is an enumerated type representing Complete, Deferred, In Progress, Not Started, and Waiting.

Visual C#

taskItem.Subject = "Finish Coding4Fun article!";
taskItem.Owner = "Bob";
taskItem.PercentComplete = 0;
taskItem.Status = Microsoft.Office.Interop.Outlook.OlTaskStatus.olTaskInProgress;

Visual Basic

taskItem.Subject = "Finish Coding4Fun article!"
taskItem.Owner = "Bob"
taskItem.PercentComplete = 0
taskItem.Status = Microsoft.Office.Interop.Outlook.OlTaskStatus.olTaskInProgress

The final step is to save the task. This step must be called, or the task will be lost when Outlook is closed or the object goes out of scope.

Visual C#

taskItem.Save();

Visual Basic

taskItem.Save()

Conclusion

VSTO support for Outlook makes it painless to create add-ins for Outlook in managed code. You can create all of the common entity types such as email messages, contacts, and tasks, respond to events, create HTML folder views, and also add application menus. Download Visual Studio 2005, the beta VSTO Outlook installer, then give this application a try. Get started at http://lab.msdn.microsoft.com/vs2005/get/.

Additional Resources

VSTO support for Outlook (Beta)

Outlook Add-in Snippets

In my last article in this series, I worked with the new Visual Studio 2005 Tools for Microsoft Office (VSTO 2005) newly released support for Microsoft Outlook (currently beta). At that point, it was enough to just get it installed, set up the snippets, and take a look at the samples. I created a starter project to demonstrate creating a new mail item and task. Of course it was just a stepping stone to the great things you can do with the beta, but I wanted to do something useful this time.

I don't know about you, but in my house I have my laptop that floats from room to room, a main desktop in the office, a media center computer, my wife's computer, and other assorted boxes awaiting upgrades or repair. I have Outlook installed on my laptop to keep it portable. Obviously, with all of the aforementioned systems, I'm not always sitting in front of my laptop. This means that meeting and task reminders will often go off without me noticing them. Not a good situation!

As they say, necessity is the mother of invention. "Wouldn't it be nice if I could be alerted on a different computer since Outlook is bound to only one?" I thought. Then, it came to me. The new VSTO 2005 for Outlook support was the answer! Why not register for event notifications when a reminder goes off, and raise an alert somewhere else? And from that, Outlook Alerts was born.

Today's article will guide you through creating an add-in to Outlook 2003 to send alerts to another computer when a reminder is raised. In order to follow this article and run the code, you will need any of the Visual Studio Express editions. The code samples in this article are shown in Visual Basic 2005; however, the downloadable source code is available in both VB 2005 and C# 2005. Beta 2 of the Express editions can be downloaded from http://msdn.microsoft.com/express. As with last time, Microsoft Office 2003 (Service Pack 1) is also a requirement, or at least Outlook 2003 SP1. Be aware that Outlook Express will not function as a replacement for Outlook.

The first step in sending alerts remotely is to detect when reminders and alarms are triggered in Outlook. As it turns out, this is easy to hook into, as the main Application object exposes a Reminder event. By registering an event handler for this, you are notified every time the Outlook Reminder dialog appears. The item parameter contains a reference to the item causing the event. This could be a mail item, an appointment, or any other Outlook item supporting reminders. The following method declaration creates a method which will be triggered whenever the Reminder event is raised:

Visual C#

void ThisApplication_Reminder(object item)

Visual Basic

Private Sub ThisApplication_Reminder(ByVal item As Object) Handles Me.Reminder

The alerts application has two settings to keep track of. Settings can seem like a challenge. You may not be sure where to store them or what format to use, and writing the code to serialize them and deserialize them can be tedious. Fortunately, the .NET 2.0 framework makes this trivial. Simply right-click the project in the Solution Explorer, then click Properties. Choose the Settingstab and you can create and manage any settings you need. You have the ability to create user or application scope settings with arbitrary names, in a variety of data types. For this project, create a Boolean setting called RemoteRemindersEnabled, and a String setting called RemoteReminderAddress. The first flag controls whether or not alerts will be sent remotely, while the second flag specifies where to send any alerts. The address should be an IP address or net name. Note that unless the other computer is in the same workgroup or domain, it is generally easier to use IP address to guarantee delivery. The Settingsconfiguration should look like this:

(click image to zoom)

Once the settings are created, you can access them in a strongly-typed fashion using the My namespace in Visual Basic as follows:

Visual C#

Properties.Settings.Default.RemoteRemindersEnabled

Visual Basic

My.Settings.RemoteRemindersEnabled

If you use settings, you must provide an easy way to allow users to manage the setting values. Outlook allows you to add menus alongside the built-in menus. This is easy to do and provides a professional look to your add-in. The first step is to obtain a reference to the main menu bar and add a top-level menu; in this case, "Add-in Tasks." The code looks a little messy due to type casting (the CType call) and the two Type.Missing parameters. These are necessary due to the underlying COM nature of the code:

Visual C#

_menuBar = this.ActiveExplorer().CommandBars.ActiveMenuBar;
_helpMenuIndex = _menuBar.Controls[MENU_BEFORE].Index;

_topMenu = (Office.CommandBarPopup)(_menuBar.Controls.Add(Office.MsoControlType.msoControlPopup, 
Type.Missing, Type.Missing, _helpMenuIndex, true));
_topMenu.Caption = "Add-in Tasks";
_topMenu.Visible = true;

Visual Basic

_menuBar = Me.ActiveExplorer().CommandBars.ActiveMenuBar
_helpMenuIndex = _menuBar.Controls(MENU_BEFORE).Index

_topMenu = CType(_menuBar.Controls.Add(Office.MsoControlType.msoControlPopup, Type.Missing, 
Type.Missing, _helpMenuIndex, True), Office.CommandBarPopup)
_topMenu.Caption = "Add-in Tasks" 
_topMenu.Visible = True

After creating the menu, you add menu items by calling the Controls.Add() method. Once again, the code looks a little cluttered, but is overall very understandable. The Caption properties in both cases determine what is seen when the menu is opened:

Visual C#

_settingsMenu = (Office.CommandBarButton)(_topMenu.Controls.Add(Office.MsoControlType.msoControlButton, 
Type.Missing, Type.Missing, Type.Missing, true));
_settingsMenu.Caption = "Remote Alert Notification Settings...";
_settingsMenu.Visible = true;
_settingsMenu.Enabled = true;

Visual Basic

_settingsMenu = CType(_topMenu.Controls.Add(Office.MsoControlType.msoControlButton, Type.Missing, 
Type.Missing, Type.Missing, True), Office.CommandBarButton)
_settingsMenu.Caption = "Remote Alert Notification Settings..." 
_settingsMenu.Visible = True 
_settingsMenu.Enabled = True

You will still need to create a settings form, and create an event handler to respond to user clicks on the item. At runtime, selecting the Add-in Tasks | Remote Alert Notification Settings menu option brings up this custom dialog:

Alerts

The final step is to determine how to actually send the remote alerts. I toyed with the idea of creating a remoting client to run on other PCs, or publish/subscribe clients, but the easiest approach is to work with what is already there. The Messenger service is a built-in Windows service for sending simple administrative messages from servers. Note that this is not related to the MSN Messenger product.

Unfortunately, in the past few years, the service has also become a target of spammers, so it is often disabled by Anti-Spyware products like Microsoft AntiSpyware. In order to enable it, go to Services configuration, then enable and start the Messenger service. Once it is enabled, you can use a built-in command, net.exe, to send messages. Given a computer's name or IP address, you can send a message as follows:

net send mycomputername This is my message. 

From code, this isn't a good option, as it causes the command prompt to appear, and it requires you to find the path to the net command. Instead, in this article, I've decided to platform-invoke the underlying Win32 method to send the alert. This is easy to do once you've located the appropriate method; in this case, NetMessageBufferSend in the Netapi32 library. Start by declaring the method signature:

Visual C#

[DllImport("Netapi32", CharSet=CharSet.Unicode)]
private static extern int NetMessageBufferSend(string servername ,
    string msgname ,
    string fromname ,
    string buf ,
    int buflen );

Visual Basic

<DllImport("Netapi32", CharSet:=CharSet.Unicode)> _
Private Shared Function NetMessageBufferSend(ByVal servername As String, _
    ByVal msgname As String, _
    ByVal fromname As String, _
    ByVal buf As String, _
    ByVal buflen As Integer) As Integer 
End Function 

Notice there is no body to the method. When you specify the DllImport attribute, this flags to the compiler that the actual method exists in a platform library, not in the managed class. Calling the method then, is as easy as calling any other method:

Visual C#

NetMessageBufferSend(null, address, null, message, message.Length * 2 + 2);

Visual Basic

NetMessageBufferSend(Nothing, address, Nothing, message, message.Length * 2 + 2)

Now that we have a way to actually send the alert (with no client install even!), we need to respond to the Reminder event. In the event handler, we will first check to see if the RemoteRemindersEnabled setting is true, then determine what type of item triggered the event. Mail, appointment, and task items are supported below in this project. Depending on the type, you can extract various fields to build up a simple string, then send the alert:

Visual C#

if( Properties.Settings.Default.RemoteRemindersEnabled )
{
    string reminderMsg;

    if(item is Outlook.MailItem)
    {
        Outlook.MailItem reminderMail;
        reminderMail = (Outlook.MailItem)item;
        reminderMsg = String.Format("Remote Outlook Reminder\nMail "+
            "subject: {0}\nReminder time: {1:t}", reminderMail.Subject,
            reminderMail.ReminderTime);
    }
    else if(item is Outlook.AppointmentItem)
    {
        Outlook.AppointmentItem reminderAppt;
        reminderAppt = (Outlook.AppointmentItem)item;
        reminderMsg = String.Format("Remote Outlook Reminder\n "+
        "Appointment subject: {0}\nLocation: {1}\nReminder time: {2:t}",
        reminderAppt.Subject, reminderAppt.Location, reminderAppt.Start);
    }
    else if(item is Outlook.TaskItem)
    {
        Outlook.TaskItem reminderTask;
        reminderTask = (Outlook.TaskItem)item;
        reminderMsg = String.Format("Remote Outlook Reminder\nTask "+
            "subject: {0}\nReminder time: {1:t}", reminderTask.Subject, 
            reminderTask.ReminderTime);
    }
    else
    {
        // Unsupported item
        return;
    }

    NetSend.Send(Properties.Settings.Default.RemoteReminderAddress,
        reminderMsg);
}

Visual Basic

If My.Settings.RemoteRemindersEnabled Then 
  Dim reminderMsg As String 

  If TypeOf item Is Outlook.MailItem Then 
    Dim reminderMail As Outlook.MailItem
    reminderMail = CType(item, Outlook.MailItem)
    reminderMsg = String.Format("Remote Outlook Reminder\nMail subject: {0}\nReminder time: {1:t}", 
                                                    reminderMail.Subject, reminderMail.ReminderTime)
  ElseIf TypeOf item Is Outlook.AppointmentItem Then 
    Dim reminderAppt As Outlook.AppointmentItem
    reminderAppt = CType(item, Outlook.AppointmentItem)
    reminderMsg = String.Format("Remote Outlook Reminder\nAppointment subject: {0}\nLocation: {1}\nReminder time: {2:t}", 
                                                    reminderAppt.Subject, reminderAppt.Location, reminderAppt.Start)
  ElseIf TypeOf item Is Outlook.TaskItem Then 
    Dim reminderTask As Outlook.TaskItem
    reminderTask = CType(item, Outlook.TaskItem)
    reminderMsg = String.Format("Remote Outlook Reminder\nTask subject: {0}\nReminder time: {1:t}", 
                                                     reminderTask.Subject, reminderTask.ReminderTime)
  Else
    ' Unsupported item
    Return
  End If

  NetSend.Send(My.Settings.RemoteReminderAddress, reminderMsg)
End If

The NetSend.Send method actually performs a quick replacement on any carriage returns, as they are not directly supported, then sends the alert using the Win32 call. The message will pop up on the specified computer over any other application:

Next Steps

Future expansion might be to allow messages to be broadcasted to multiple machines. This is easy on a domain, but would require additional work on many home networks. Net send has some limitations, including sparse formatting options and a bad perception due to spammers. A more robust client, or tying it into an existing instant messenger network could be useful.

Conclusion

Building this was fun. It served a definite purpose and allowed me to use a number of techniques to get it working. Download Visual C# 2005 Express Edition or Visual Basic 2005 Express Edition, the beta VSTO Outlook installer, then give this application a try. Get started at http://msdn.microsoft.com/express.

Additional Resources

• VSTO support for Outlook (Beta)
• NetMessageBufferSend documentation