Many households, and most businesses, have more than one computer. Being able to remotely monitor and maintain these computers can save valuable minutes every day. NetPing makes these tasks a little easier by serving two purposes: Simple display of computer information and the ability to perform actions on these computers. What makes the application truly useful, though, is the ability to easily add to the application's functionality with add-ins written in .NET. Add-ins come in two flavors: ColoumnProviders, which display information for each computer in a single column, and ContextMenuItemProviders that allow the user to execute an action via context menu.

How NetPing works

When NetPing is launched, it loads all add-ins in the AddIns directory. When the Start button is pressed, all IP addresses in the given range are pinged and ColumnProvider add-ins are executed for each that respond. Finally, ContextMenuItemProvider add-ins are executed when the user right-clicks a row and selects an item from the context menu.

In the screen shot below, ‘Name', ‘Uptime' and ‘Operating System' are ColumnProvider add-ins. ‘Remote Deskop' and ‘System Information' are ContextMenuItemProviders.

The NetPing projects

NetPing consists of the following projects:

· NetPing: This contains the core application. MainForm and HostListViewItem are where the most of the action lives, but most of this action involves threading and is outside the scope of this article. The classes are fully commented, so the adventurous are welcome to dig around.

· NetPing.Common: Common contains what could be considered the NetPing ‘SDK' (software development kit). It contains the classes that add-in authors use to integrate with NetPing.

· NetPing.AddIns: Finally, AddIns contains the ‘Name', ‘Uptime', ‘Operating System', ‘Remote Desktop' and ‘System Information' add-ins. Note that any number of add-in assemblies may be put into the AddIns directory – this project need not be modified to extend NetPing.

Writing ColumnProvider add-ins

The IColumnProvider interface, shown below, must be implemented by all ColumnProvider add-ins:

The abstract ColumnProviderBase class is provided to make ColumnProvider creation a little easier. Classes that inherit ColumnProviderBase are only required to implement Execute, which returns a ColumnValue object.

The ColumnValue class represents three different values:

Text: This is the text that will be displayed.

SortKey: SortKey is a string that will be used when comparing values during a sort, since the text value of a field doesn't necessarily represent its value. For example, the Uptime column displays uptime in English but its SortKey is a numeric representation of the boot date and time, which sorts chronologically.

ColumnIndex: Indicates which column the row should update with the value.

The simplest ColumnProvider, ComputerNameColumn, is shown below in both Visual Basic and C#.

First, the VB version:

Friend Class ComputerNameColumn
    Inherits ColumnProviderBase

    Public Sub New()
        MyBase.New("Name", 125)
    End Sub

    Public Overrides Function Execute(ByVal ipAddress As IPAddress) As ColumnValue
        Dim hostEntry As IPHostEntry

        Try
            hostEntry = Dns.GetHostEntry(ipAddress)
        Catch
            hostEntry = Nothing
        End Try

        Dim hostName As String

        If hostEntry Is Nothing Then
            hostName = ""
        Else
            hostName = hostEntry.HostName
        End If

        Return New ColumnValue(ColumnIndex, hostName)
    End Function
End Class

And the C# version:

class ComputerNameColumn : ColumnProviderBase
{
    public ComputerNameColumn() 
        : base("Name", 125)
    {}

    public override ColumnValue Execute(IPAddress ipAddress)
    {
        IPHostEntry hostEntry;

        try
        {
            hostEntry = Dns.GetHostEntry(ipAddress);
        }
        catch 
        {
            hostEntry = null;
        }

        string hostName;

        if (hostEntry == null)
        {
            hostName = "";
        }
        else
        {
            hostName = hostEntry.HostName;
        }

        return new ColumnValue(ColumnIndex, hostName);
    }
}

Creating ContextMenuItemProviders add-ins

Writing ContextMenuItemProviders is even easier. The IContextMenuItemProvider interface is shown below, again in C# and Visual Basic:

Text is what is shown on the context menu and Execute is called when the user selects the menu item.

The SystemInformationMenuItem is shown below in C#:

class SystemInformationMenuItem : IContextMenuItemProvider
{
    public void Execute(IPAddress ipAddress)
    {
        try
        {
            Process.Start("cmd.exe", "/k systeminfo /s " + ipAddress);
        }
        catch (Exception e)
        {
            MessageBox.Show("An error occurred while retrieving system information:\n\n" + e.Message, 
                            "System information", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

    public string Text
    {
        get { return "System Information"; }
    }
}

And in Visual Basic:

Friend Class SystemInformationMenuItem
    Implements IContextMenuItemProvider

    Public Sub Execute(ByVal ipAddress As IPAddress) Implements IContextMenuItemProvider.Execute
        Try
            Process.Start("cmd.exe", "/k systeminfo /s " & ipAddress.ToString())
        Catch e As Exception
            MessageBox.Show("An error occurred while retrieving system information:" & _
                            Constants.vbLf + Constants.vbLf + e.Message, "System information", _
                            MessageBoxButtons.OK, MessageBoxIcon.Error)
        End Try
    End Sub

    Public ReadOnly Property Text() As String Implements IContextMenuItemProvider.Text
        Get
            Return "System Information"
        End Get
    End Property
End Class

What next?

All kinds of information is available via WMI (Windows Management Instrumentation). Add-ins can be written to display a computer's CPU, RAM, disk drive information and so on. The OperatingSystemColumn and UptimeColumn classes use WMI to retrieve their values and are a good place to start.

Regarding ContextMenuItemProviders, anything that requires an IP address can be executed. For example, a reboot command could be initiated, ports scanned, Computer Management opened, etc. The options are endless!

Using with Windows Vista

Vista's User Account Control may get between NetPing and Vista computers' WMI, and behavior is different for workspace and domain compters. The following articles explain the issue and solutions:

· Connecting to WMI Remotely Starting with Vista

· User Account Control and WMI

Jeff is the Technical Product Manager at InRule Technology and a Visual C# MVP. More stuff like this is available at his website.

I don't know about you, but the one aspect of development I like least is the typing bit. Drag-and-drop development has been evolving over the years, but has rarely made it past being a good demo. Luckily for us, the Visual Studio 2005 editions' drag-and-drop feature set is more evolved than in the past, and works surprisingly well. It is the holiday season, and my gift to you is an overview of some of the features that really do take the pain out of some of the more tedious parts of development.

The application accompanying this article maintains a simple holiday wish list. It lives in the notification area, and the user can print out or email the list. My primary goal was to use the RAD features available in Visual Studio 2005 to reduce the amount of complexity and typing required.

Table layout

Anyone that's done both Web and Windows development can probably appreciate the beauty of the HTML table. Sure, you can reliably put anything anywhere on a Windows dialog, but that isn't necessarily a good thing. The simple structure of the HTML table makes it easy to write functional user interfaces that are easy on the eyes.

Windows Forms in .NET 1.x introduced easy-to-use layout logic via anchoring and docking. These made manual auto-resizing logic a thing of the past, and gave the developer easy-to-use tools for creating a better user experience. Still, the developer had to make sure the controls' initial layouts were correct. This was more time consuming than it should have been.

Apparently some folks in Redmond thought the same thing, because the TableLayoutPanel was born. The table is really simple to use, and anyone with HTML table experience will be productive right out of the gate.

Figure 1: Simple table layout

TableLayoutPanels are really simple to use. Each cell can contain only one control, and controls can be anchored to any side (or sides) of the containing cell. Column and row sizes can be absolute, a percentage, or autosize. This combination makes dynamically-sized forms a snap to create.

In the image above, the table has three columns; the left and right are set at 48%, and the middle is 4%. Each text box is anchored to the left and right, and each label is anchored to the top and left. The rows are all autosized, which makes them as small as the largest control within them. Finally, the table is anchored on the form, so the controls grow or shrink and change their placement on the form when the user resizes it. The image below illustrates this:

Figure 2: Table in action

More complex table layouts are possible with familiar HTML table concepts like column spanning, row spanning, padding and margins, as well as table nesting. The tables below have examples of some of these features:

The Selected Gift table has four columns. The URL TextBox and button are in their own table. It's nested in a spanned cell with a zero margin, which gives it a fluid appearance within the outer table. The buttons in the Gifts table are in their own tables, anchored to either side of the outer table.

Figure 3: Complex table layouts

TableLayoutPanels are easy to use, and much better than previous methods required to accomplish the same result, but there are a few best practices that make life a little easier when using them. The Windows Forms 2.0 Layout link below has a short video explaining some of these.

Settings Bindings

Almost every application, no matter how small, has user settings. Maintaining these settings requires maintaining a settings file, wrapping those settings up so that they're consumable within the app, and creating the UI to adjust the settings. None of this is a major undertaking, but it takes time away from more important things. If you're coding for fun, you probably don't have much time to do it, and tasks like these are just begging to be automated.

You're in luck, my friend! This part of life has gotten a whole lot easier. I briefly covered the new user settings features in Visual Studio in my URL Buddy article. Basically, Visual Studio provides an interface for you to enter settings names and optional default values. It creates strongly-typed classes for accessing this data, so reading/writing these settings at run time is only a matter of accessing a strongly-typed property. These settings can be app- or user-level, with user-specific settings saved in the user's ApplicationData folder.

Visual Studio 2005's Property Bindings are similar to Visual Studio 2003's Dynamic Properties, which allowed for a read-only mapping to an appSettings entry in an application's config file. The big difference is that the new version supports two-way binding, so changes may be saved. That makes all the difference in the world! Mapping the value of a property to a setting is as easy as picking it from a list:

Figure 4: Mapping a user setting to a TextBox's Text property

Rounding out this little bit of heaven is automatic creation of settings right from the property grid. Let me give a scenario, because this little nugget is such a great time-saver I want to make sure it's remembered: You're in the middle of writing some very important code, but realize that you need the user's email address and want to save it between sessions. You go to your options form and create a TextBox, then open the PropertyBinding ("Application Settings" above) dialog. You click the drop-drown button next to Text, click "(New…)", then enter the name ("YourEmailAddress"), scope ("User") and optional default value ("someone@someplace.com"). That's it! You now have a strongly-typed YourEmailAddress property on the application's Settings class. The value will be loaded automatically from the user's config file, saved very easily (a single method call for all settings), and the value is bound to the TextBox. And you didn't write a single line of code.

Figure 5: Adding a setting from the property grid

Summary

Form layout and application settings are two things that are required in nearly every application, but take away development time from the application's intended purpose. I've touched on just two of the many features in Visual Studio 2005 and the .NET Framework 2.0 that help the developer focus on what's important. A little exploration within Visual Studio will unearth even more goodies.

The best April Fools' Day pranks are those that can be enjoyed by both the fooler and the foolee. This short article covers one of the simpler pranks in the "Why is my computer doing that?" category: the malfunctioning CD-ROM drive that opens at random intervals. This prank is best used in a cube farm where multiple instances can be easily deployed and monitored.

The Prank

The prank itself is very simple: a little program that, once launched, waits n minutes, then opens the CD-ROM drive door. It then continually opens the door at random intervals until the user closes the application. (Both n and the random interval constraint can be modified by the fooler via the application's config file.)

The most difficult part of the prank is getting the application onto the foolee's computer.

The Inspiration

I've recently begun using the Google Web Accelerator, which speeds up your Web browsing. Or so they say. The only indication that it is doing anything is a report of how much time it has saved me:

If you're reading this article, you probably have an idea how the Accelerator works. However, 99 percent of its users don't. They take its word that it's working, and this trust is a primary component of our evil deed.

"Web Speedster"

Our prank appears to be similar to the Web Accelerator. Once launched, it sits in the notification area until the user closes it. Unbeknownst to the user, the Web Speedster is the source of the randomly opening CD-ROM drive door. The initial CD-ROM door opening is delayed so the foolee doesn't make the connection with the Speedster.

The application itself is tiny — less than a dozen lines of code. The most interesting part is how the door is opened, since the .NET Framework doesn't natively provide this functionality.

The .NET Framework has almost everything most people need to create great applications, but sometimes developers need to access unmanaged functionality provided by other libraries, including Windows itself. Platform Invoke, or P/Invoke, is the gateway to these libraries. Methods in other libraries are defined with external method declarations like the following, which lets us call the mciSendString method in Windows WinMM DLL:

Visual C#

[DllImport("winmm.dll")]
static extern Int32 mciSendString(String command, StringBuilder buffer, Int32 bufferSize, IntPtr hwndCallback);

Visual Basic

Declare Function mciSendStringA Lib "winmm.dll" (command As String, _
   buffer As StringBuilder, bufferSize As Int32, hwndCallback As IntPtr) As Int32

(PInvoke.NET is a great resource for finding these declarations.)

Calls to these methods are done just like calls to "normal" methods:

mciSendString("set CDAudio door open", null, 0, IntPtr.Zero);

And that is all that's required to make a function call into Windows. Easy!

Summary

While the .NET Framework is huge, it doesn't do everything. However, if Windows can do what you need, chances are very good that you can get to that functionality with P/Invoke.

The next step is to compile the program, send it out to unsuspecting foolees (ideally within earshot), and let the fun begin!

Introduction
It's easy to assume that most people with computers have media libraries. As computers become cheaper, easier to network and easier to use, people are more likely to create home networks. Since servers aren't practical in a home setting, information is distributed amongst the computers in the network, which makes managing and finding formation difficult. This is probably most evident in music libraries.
Most media players maintain a private database containing all of the songs they're aware of. Keeping these databases up-to-date can be a chore on a single computer, and keeping databases current on several computers often seems impossible.
A common solution is to keep all music files on a single computer and have other computers' media libraries point to, and stay current with, the files on that computer. Anyone that has tried this in practice knows that it's an adequate solution, but not an ideal one. Personally, I just want to listen to music, not manage it.
My home setup consists of a Windows Media Center computer that drives my TV and has all of my music on it, my workstation, and occasionally a laptop. Keeping the workstation current with the music on the Media Center has always been a hassle, and doing so on the laptop just isn't practical. I wanted a simple, clean way to listen to music anywhere in my apartment, from any computer, without having to worry about the accuracy of the library. I chose to build a little website whose only purpose would be to get me to the music I wanted to listen to as painlessly as possible. I used Microsoft Visual Web Developer 2005 Express Edition Beta 2 to make this happen.
COM: A friend from the past
Back in the old days we had a technology called COM that let us use libraries written in any language from our code, regardless of the langauge we were using (as long as it supported COM), much like .NET does today. COM did a great job solving some problems, but introduced a few others that became more apparent over time. .NET is, among other things, a solution to many of these problems.
Years ago, Microsoft started exposing operating system and application services via COM. This let common folk write code against Microsoft Word, Windows Scripting Host, Windows Media Player, and countless others. Due to the number of languages, frameworks, etc. that support COM, it's still a major player in the Microsoft world and it's common to find COM support in Microsoft applications before .NET support. Luckily, .NET does a great job talking to COM (most of the time).
This history lesson is relevant because the site uses the Windows Media Player COM component to access its media library. Adding a reference to a COM component is just as easy as adding a reference to a .NET assembly. Click the Website menu and select Add Reference, then click the COM tab on the Add Reference dialog.

Figure 1: Adding a reference to the Windows Media Player COM component

Database
Quick access to a subset of the WMP library's information is required, so an in-memory database consisting of Artist, Album, Database and Track classes is required. The Database class has a static (or shared in Visual Basic) constructor that populates the database with a call to the Refresh method:

Visual C#

private static void Refresh()
    {
        WindowsMediaPlayer wmp = new WindowsMediaPlayer();
        IWMPPlaylist playlist = wmp.mediaCollection.getAll();
        Dictionary<string, Artist> artistDictionary = 
new Dictionary<string, Artist>();

        for (int i = 0; i < playlist.count; i++)
        {
            IWMPMedia media = (IWMPMedia)playlist.get_Item(i);
            string albumArtistName = media.getItemInfo("AlbumArtist");
            string albumName = media.getItemInfo("Album");
            string trackName = media.getItemInfo("Title");
            string trackLocation = media.getItemInfo("SourceUrl");
            string trackNumberString = media.getItemInfo("OriginalIndex");

            Artist artist;
            string artistSortName = Artist.GetSortName(albumArtistName);

            if (!artistDictionary.TryGetValue(artistSortName, out artist))
            {
                artist = new Artist(albumArtistName);
                artistDictionary.Add(artistSortName, artist);
            }

            Album album;

            if (!artist.Albums.TryGetValue(albumName, out album))
            {
                album = new Album(albumName, artist);
                artist.Albums.Add(albumName, album);
            }

            Track track;

            if (!album.Tracks.TryGetValue(trackName, out track))
            {
                int trackNumber;

                if (int.TryParse(trackNumberString, out trackNumber))
                {
                    track = new Track(trackNumber, trackName, trackLocation);
                }
                else
                {
                    track = new Track(trackName, trackLocation);
                }

                track.Album = album;
                album.Tracks.Add(trackName, track);
            }
        }

        ArtistList.AddRange(artistDictionary.Values);
        ArtistList.Sort();
    }

Visual Basic  

Private Shared Sub Refresh()
        Dim wmp As WindowsMediaPlayer = New WindowsMediaPlayer
        Dim playlist As IWMPPlaylist = wmp.mediaCollection.getAll()
        Dim artistDictionary As Dictionary(Of String, Artist) = _
New Dictionary(Of String, Artist)

        For i As Integer = 0 To playlist.count - 1
            Dim media As IWMPMedia = playlist.Item(i)
            Dim albumArtistName As String = media.getItemInfo("AlbumArtist")
            Dim albumName As String = media.getItemInfo("Album")
            Dim trackName As String = media.getItemInfo("Title")
            Dim trackLocation As String = media.getItemInfo("SourceUrl")
            Dim trackNumberString As String = _
                media.getItemInfo("OriginalIndex")

            Dim theArtist As Artist
            Dim artistSortName As String = _
                Artist.GetSortName(albumArtistName)

If Not artistDictionary.TryGetValue(artistSortName, theArtist) Then
                theArtist = New Artist(albumArtistName)
                artistDictionary.Add(artistSortName, theArtist)
            End If

            Dim theAlbum As Album

            If Not theArtist.Albums.TryGetValue(albumName, theAlbum) Then
                theAlbum = New Album(albumName, theArtist)
                theArtist.Albums.Add(albumName, theAlbum)
            End If

            Dim theTrack As Track

            If Not theAlbum.Tracks.TryGetValue(trackName, theTrack) Then
                Dim trackNumber As Integer

                If Integer.TryParse(trackNumberString, trackNumber) Then
                    theTrack = New Track(trackNumber, trackName, trackLocation)
                Else
                    theTrack = New Track(trackName, trackLocation)
                End If

                theTrack.Album = theAlbum
                theAlbum.Tracks.Add(trackName, theTrack)
            End If
        Next

        ArtistList.AddRange(artistDictionary.Values)
        ArtistList.Sort()
    End Sub

Figure 2: The Artists page

The Artists page (Figure 2) shows ten groups of artists at a time. Each time a group is clicked, that group is shown and so on until the user gets to the artist she's looking for.

Figure 3: The Albums page

The Albums page (Figure 3) shows all of the albums, including artwork, for an artist. Clicking the album name brings the user to the Album page, and clicking the play button will launch a playlist containing the tracks in the album in Windows Media Player.

Figure 4: The Album page

The Album page shows the large album artwork and tracks. The user can play the entire album or individual tracks.
Each page uses object data binding and shares a common master page. ASP.NET has a new feature called Master Pages, which allows you to create a consistent layout for the Web site and share common functionality without having to duplicate it for every page. The Master Page in this website is used to share Cascading Style Sheet (CSS) information and host the "breadcrumb bar," or SiteMapPath, as it's called in ASP.NET. I won't be covering the SiteMapPath control, but the implementation should be interesting to anyone that needs to drive one programmatically and not through a static definition. More information about master pages can be found in Fritz Onion's Master Your Site Design with Visual Inheritance and Page Templates.
The Albums and Album page also have images and play buttons that launch Windows Media Player playlist files. Album images are cached in a Web-accessible directory, and WMP playlist files are generated on the fly in an HTTP handler. Both of these topics are covered below.
Binding objects to grids
The new ObjectDataSource is the middleman between the grid and objects. It must be configured to work with a class to return data requested by the grid. We'll step through creating the data source for the Albums page.

Figure 5: The ObjectDataSource wizard, first page

The "Binder" class is selected as the business object. The objects used to represent the artists, et al, are simple and primarily represent data, and therefore don't have much in the way of persistence methods. The Binder class provides the functionality that may otherwise be handled by the objects themselves.

Figure 6: The ObjectDataSource wizard, second page

The next page is where we choose which method we would like to use to get the data, so we pick GetAlbums. Update, Insert and Delete methods can also be specified, but are not required.

Figure 7: The ObjectDataSource wizard, third page

The final page specifies where the parameter values will come from. The value can come from one of the following: Cookie, Control, Form, Profile, QueryString and Session.
Once the data source is configured, setting it as the DataSource of the grid is all that's required to make the magic happen.
Generating custom grid values
All of the grids use template columns and custom code to generate their hyperlinks. For example, the artists page (figure 2) consists of a single GridView that's bound to a generic List of RangeListItems. RangeListItem is a custom class that represents the first and last artist IDs in the range, as well as the text that is displayed in the grid. The hyperlinks are created by using a template field in the grid and calling a method in the page's server-side script section.

<asp:TemplateField ItemStyle-HorizontalAlign=Center>
    <ItemTemplate>
        <asp:HyperLink ID="HyperLink1" runat="server" NavigateURL='<%# CreateNavigateURL(GetDataItem() %>'
            Text='<%# Eval("Text") %>'></asp:HyperLink>
    </ItemTemplate>
</asp:TemplateField>

Visual C#

private string CreateNavigateUrl(object o)
    {
        RangeListItem listItem = (RangeListItem)o;

        if (listItem.StartIndex == listItem.EndIndex)
        {
            return "albums.aspx?artist=" + listItem.StartIndex;
        }
        else
        {
return string.Format("default.aspx?start={0}&end={1}", listItem.StartIndex, listItem.EndIndex);
        }
    }

Visual Basic

Private Function CreateNavigateUrl(ByVal o As Object) As String
        Dim listItem As RangeListItem = CType(o, RangeListItem)
        
        If (listItem.StartIndex = listItem.EndIndex) Then
            Return "albums.aspx?artist=" & listItem.StartIndex
        Else
            Return String.Format("default.aspx?start={0}&end={1}", listItem.StartIndex, listItem.EndIndex)
        End If
End Function

Visual C#

public string GetAlbumArtUrl(AlbumArtSize size)
    {
        string albumArtFileName = GetCustomAlbumArtFileName(size);
string albumArtFullFilename = Path.Combine(_albumArtDirectory, 
    albumArtFileName);

        bool fileExists = File.Exists(albumArtFullFilename);

        if (!fileExists)
        {
            string dir = Path.GetDirectoryName(Tracks[0].Location);
            string filename;

            if (Directory.Exists(dir))
            {
                filename = GetRealAlbumArtFileName(dir, size);

                if (filename != null)
                {
                    File.Copy(filename, albumArtFullFilename);
                    File.SetAttributes(albumArtFullFilename, 
                        FileAttributes.Normal);
                    fileExists = true;
                }
            }
        }

        string url;

        if (fileExists)
        {
            url = "Images/AlbumArt/" + albumArtFileName;
        }
        else
        {
            url = "Images/dot.gif";
        }

        return url;
    }

Visual Basic   

Public Function GetAlbumArtUrl(ByVal size As AlbumArtSize) As String
        Dim albumArtFileName As String = GetCustomAlbumArtFileName(size)
        Dim albumArtFullFilename As String = _
            Path.Combine(_albumArtDirectory, albumArtFileName)

        Dim fileExists As Boolean = File.Exists(albumArtFullFilename)

        If Not fileExists Then
            Dim dir As String = Path.GetDirectoryName(Tracks(0).Location)
            Dim filename As String

            If Directory.Exists(dir) Then
                filename = GetRealAlbumArtFileName(dir, size)

                If Not filename Is Nothing Then
                    File.Copy(filename, albumArtFullFilename)
                    File.SetAttributes(albumArtFullFilename, _
                        FileAttributes.Normal)
                    fileExists = True
                End If
            End If
        End If

        Dim url As String

        If fileExists Then
            url = "Images/AlbumArt/" & albumArtFileName
        Else
            url = "Images/dot.gif"
        End If

        Return url
    End Function

Visual C#   

private string GetCustomAlbumArtFileName(AlbumArtSize size)
    {
        return string.Format("{0}-{1}-{2}.jpg", 
            GetAlphanumericString(_artist.Name), 
            GetAlphanumericString(Name),
            size.ToString());
    }

    private string GetAlphanumericString(string s)
    {
        StringBuilder sb = new StringBuilder();

        foreach (char c in s)
        {
            if (char.IsLetterOrDigit(c))
            {
                sb.Append(c);
            }
        }

        return sb.ToString();
    }

Visual Basic  

 Private Function GetCustomAlbumArtFileName(ByVal size As AlbumArtSize) As String
        Return String.Format("{0}-{1}-{2}.jpg", _
            GetAlphanumericString(_artist.Name), _
GetAlphanumericString(Name), size.ToString)
    End Function

    Private Function GetAlphanumericString(ByVal s As String) As String
        Dim sb As StringBuilder = New StringBuilder

        For Each c As Char In s
            If Char.IsLetterOrDigit(c) Then
                sb.Append(c)
            End If
        Next

        Return sb.ToString()
    End Function

Large
AlbumArt_{FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF}_Large.jpg

AlbumArt__Large.jpg

Folder.jpg

Small
AlbumArt_{FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF}_Small.jpg

AlbumArt__Small.jpg

AlbumArtSmall.jpg

GetRealAlbumArtFileName gets the filename for the album art, if it exists, by searching for the patterns above:

Visual C#   

private string GetRealAlbumArtFileName(string dir, AlbumArtSize size)
    {
        string filename = null;
        string[] filenames = 
Directory.GetFiles(dir, "AlbumArt*" + size + ".jpg");

        if (filenames.Length > 0)
        {
            filename = filenames[0];
        }
        else if (size == AlbumArtSize.Large)
        {
            FileInfo file = new FileInfo(Path.Combine(dir, "Folder.jpg"));
            
            if (file.Exists)
            {
                filename = file.FullName;
            }
        }
        return filename;
    }

Visual Basic

Private Function GetRealAlbumArtFileName(ByVal dir As String, ByVal size As AlbumArtSize) As String
        Dim filename As String = Nothing
        Dim filenames() As String = _
Directory.GetFiles(dir, "AlbumArt*" & size.ToString() & ".jpg")

        If (filenames.Length > 0) Then
            filename = filenames(0)
        ElseIf (size = AlbumArtSize.Large) Then
            Dim file As FileInfo = _
New FileInfo(Path.Combine(dir, "Folder.jpg"))
            If file.Exists Then
                filename = file.FullName
            End If
        End If

        Return filename
    End Function

Visual C#   

public void ProcessRequest(HttpContext context)
    {
        _trackIndex = QueryStringHelper.TrackIndex;
        _artistIndex = QueryStringHelper.ArtistIndex;
        _albumIndex = QueryStringHelper.AlbumIndex;

        context.Response.ContentType = "video/x-ms-asf";

        StreamWriter streamWriter = 
new StreamWriter(context.Response.OutputStream);
        _writer = new XmlTextWriter(streamWriter);
        _writer.WriteProcessingInstruction("wpl", "version=\"1.0\"");

        _writer.WriteStartElement("smil");

        CreateHead();
        
        _writer.WriteStartElement("body");
        _writer.WriteStartElement("seq");

        if (_trackIndex.HasValue)
        {
            CreateTrackEntry();
        }
        else if (_albumIndex.HasValue)
        {
            CreateAlbumEntries();
        }

        _writer.WriteEndElement();
        _writer.WriteEndElement();
        _writer.WriteEndElement();

        _writer.Close();
    }

Visual Basic   

Public Sub ProcessRequest(ByVal context As HttpContext) Implements IHttpHandler.ProcessRequest
        _trackIndex = QueryStringHelper.TrackIndex
        _artistIndex = QueryStringHelper.ArtistIndex
        _albumIndex = QueryStringHelper.AlbumIndex

        context.Response.ContentType = "video/x-ms-asf"

        Dim streamWriter As StreamWriter = _
New StreamWriter(context.Response.OutputStream)
        _writer = New XmlTextWriter(streamWriter)
        _writer.WriteProcessingInstruction("wpl", "version=\""1.0\""")

        _writer.WriteStartElement("smil")

        CreateHead()

        _writer.WriteStartElement("body")
        _writer.WriteStartElement("seq")

        If _trackIndex.HasValue Then
            CreateTrackEntry()
        ElseIf _albumIndex.HasValue Then
            CreateAlbumEntries()
        End If

        _writer.WriteEndElement()
        _writer.WriteEndElement()
        _writer.WriteEndElement()

        _writer.Close()
    End Sub

<httpHandlers>



          <add path="*.wpl" type="PlaylistCreator" verb="*" validate="false" />
</httpHandlers>

Introduction

I lost one hard drive at home and two at the office in less than six months, and in each case the event log had included warnings of impending doom. I don't check event logs often, so the warnings went unnoticed. Utilities exist to monitor hard drive health, but it looks like USB hard drives aren't supported yet. This is a problem since I have three at home and two fairly important ones at the office.

The problem

Software exists to monitor my internal hard drives, but not the external ones. Drives on remote machines need to be monitored and alert me when their drives show signs of failure.

I would like other things monitored, too. System availability, hard drive space, and so on, need to be watched -- especially on critical systems. Utilities of all kinds exist to monitor these things, but maintenance and configuration of disparate utilities can be a hassle.

The solution

The solution is simple: A utility that can host “monitors” and provide a means to communicate to the user in a configurable, extensible way. Any number of “notifiers” can be associated with a “monitor” and new “notifiers” can be written to allow any kind of communication.

Figure 1 – System Monitor main window

The following Monitors are included:

• Disk space: Watches for a configurable amount of free space on a hard drive.
• Event log: Watches for entries in an event log for entries posted by a specified source.
• Network availability: Notifies the user when the computer's network connection is lost or restored.
• Ping: Pings a computer and notifies the user if a ping fails

The following Notifiers are included:

• Balloon tip: Shows a balloon near the icon in the notification area (see image below).
• Email: Sends an email to a user-configurable address.
• Message box: Displays a message box to the logged-in user.

Requirements

The application will:

• Host custom Monitors.
• Provide an interface for custom Notifiers.
• Provide a generic configuration system using the application's config file, allowing settings to be passed to Monitors and Notifiers.
• Allow for the association of Notifiers to Monitors.
• Provide two run modes for Monitors: Persistent and Scheduled.
  • Scheduled is run at a specified interval by the application.
  • Persistent is never run by the application.
• Run Scheduled “monitors” at the interval specified in the configuration file
• Allow on-demand execution of Scheduled Monitors.
• Run in the notification area.

We will build this solution using Visual Studio 2005 Beta 2, specifically Visual C# Express, and at the end of this article I will point out some features that make Visual Studio 2005 a compelling choice over previous versions. To download Visual C# Express Edition Beta 2, or any of the other Express editions, visit http://msdn.microsoft.com/express.

Architecture

The architecture is simple: The MainForm class handles the loading of Monitors and Notifiers, which are types that implement IMonitor and INotifier, respectively. Monitors are added to Tasks, which are responsible for running the Monitors on a schedule and maintaining status information. The MainForm displays information maintained by the Tasks and provides a means for executing a Monitor on demand.

The application configuration file plays an important role. It indicates which Monitors to load, which Notifiers should be associated with them, and what settings apply to both. The application itself is just a host and wouldn't do anything without the Monitor/Notifier definitions contained in the configuration file.

A typical Monitor definition is shown below. It represents a DiskSpaceMonitor, is run every four minutes and watches the C drive for free disk space below 10,000 megabytes. The Monitor has two Notifiers associated with it: A MessageBoxNotifier and an EmailNotifier. The former doesn't have any settings and the latter has three.

<monitor runFrequency="00:04" type="SystemMonitor.Monitors.DiskSpaceMonitor,SystemMonitor">
  <settings>
    <setting name="driveLetter" value="C" />
    <setting name="freeMegabytes" value="10000" />
  </settings>
  <notifiers>
    <notifier type="SystemMonitor.Notifiers.MessageBoxNotifier,SystemMonitor" />
    <notifier type="SystemMonitor.Notifiers.EmailNotifier,SystemMonitor">
      <settings>
        <setting name="host" value="mail.someDomain.com" />
        <setting name="to" value="someEmail@someDomain.com" />
        <setting name="from" value="someEmail@someDomain.com" />
      </settings>
    </notifier>
  </notifiers>
</monitor> 

Implementation

Startup

The application configuration file is read. Monitors and Notifiers are created and their settings are passed to them in their respective Initialize methods. Notifiers are associated with Monitors and Monitors are assigned Tasks.

Normal operation

Persistent Monitors are responsible for their own operation and are left to manage themselves. Tasks for scheduled Monitors invoke the Monitors' Execute methods on a new thread at the interval specified in the configuration file. The MainForm's display is updated as scheduled Monitors run and allows for the explicit execution of a Monitor via context menu.

Technology highlights

All of the following are new in version 2 of the .NET Framework.

ListView grouping

ListView grouping is easy to use and can make the display easier to read on Windows XP and Windows Server 2003 operating systems. Groups are created by adding ListViewGroup items to a ListView's Groups collection. ListViewItems are added to groups by assigning their Groups property the value of an existing ListViewGroup.

NotifyIcon balloon tips

Displaying a balloon tip on a notification icon is as easy as calling a single method: NotifyIcon.ShowBalloonTip. Clicked, Closed and Shown events are also available.

Figure 2 – NotifyIcon balloon tip

New configuration section handling

Previous versions of the .NET Framework required manual parsing of custom configuration sections. Version 2 includes completely revamped configuration handling, using strongly-typed class access.

Visual C#

class MonitorElement : ConfigurationElement
{
       [ConfigurationProperty("runFrequency")]
       public TimeSpan? RunFrequency
       {
             get { return (TimeSpan?)base["runFrequency"]; }
             set { base["runFrequency"] = value; }
       }
 
       [ConfigurationProperty("type")]
       public string TypeName
      {
              get { return (string)base["type"]; }
             set { base["type"] = value; }
       }
 
       [ConfigurationProperty("settings", 
        IsDefaultCollectionProperty = false)]
       public SettingElementCollection Settings
       {
             get 
            { return (SettingElementCollection)base["settings"]; }
       }
 
       [ConfigurationProperty("notifiers", 
        IsDefaultCollectionProperty = false)]
       public NotifierElementCollection Notifiers
       {
            get { return (NotifierElementCollection)base[
                  "notifiers"]; }
       }
}

Visual Basic

Class MonitorElement
    Inherits ConfigurationElement

    <ConfigurationProperty("runFrequency")> _
        Property RunFrequency() As Nullable(Of TimeSpan)
        Get
            Return CType(MyBase.Item("runFrequency"), 
            Nullable(Of TimeSpan))
       End Get
        Set(ByVal value As Nullable(Of TimeSpan))
            MyBase.Item("runFrequency") = value
        End Set
    End Property

    <ConfigurationProperty("type")> _
    Public Property TypeName() As String
        Get
            Return CStr(MyBase.Item("type"))
        End Get
        Set(ByVal value As String)
            MyBase.Item("type") = value
        End Set
    End Property

    <ConfigurationProperty("settings", IsDefaultCollection:=False)> _
    Public ReadOnly Property Settings() As SettingElementCollection
        Get
            Return CType(MyBase.Item("settings"), 
            SettingElementCollection)
        End Get
    End Property

    <ConfigurationProperty("notifiers", IsDefaultCollection:=False)> _
    Public ReadOnly Property Notifiers() As NotifierElementCollection
        Get
            Return CType(MyBase.Item("notifiers"),  
             NotifierElementCollection)
        End Get
    End Property
End Class

Improved SMTP support

Simple SMTP support in previous versions of the .NET Framework was dismal. IIS was required, as was its SMTP component, which was no picnic to correctly configure. I stumbled upon the new SMTP support recently and it was a wonderful surprise. The snippet below just works. No configuration necessary!

Visual C#

SmtpClient mailClient = new SmtpClient();
mailClient.Host = _host;
mailClient.Send(_to, _from, title, message);

Visual Basic

Dim mailClient As New SmtpClient()
mailClient.Host = _host
mailClient.Send(_to, _from, title, message)

Network

A whole new namespace exists within System.Net: NetworkInformation. The Ping and NetworkChanges classes are used in this sample. Many more are available and worth checking out.

Generic collections

It's no mistake that System.Collections.Generic has replaced System.Collections in class templates. Two of the more significant, related benefits:

• No longer need to write strongly-typed collections (most of the time).
• Increased type safety over the standard collections.

The result is less time spent writing code and fewer runtime errors. What more could you want?

Nullable types

Representing the absence of a value type's value has been an issue since .NET 1.0, and people have solved it in very different ways. The generic Nullable structure provides a way for value types to have null values.

Both Visual Basic and C# can use the generic Nullable structure, but only C# has a new type modifier: A question mark appended to the type name.

In the example below, all expressions evaluate to true.

Visual C#

int? int1 = null;
if (int1 == null)
    MessageBox.Show("null");
if (!int1.HasValue)
    MessageBox.Show("has no value");
int1 = 10;
if (int1 == 10)
    MessageBox.Show("equal");

Visual Basic

Dim int1 As Nullable(Of Integer) = New Nullable(Of Integer)
If Not int1.HasValue Then
    MessageBox.Show("null")
End If
If Not int1.HasValue Then
    MessageBox.Show("has no value")
End If
int1 = New Nullable(Of Integer)(10)
If (int1.GetValueOrDefault Is 10) Then
    MessageBox.Show("equal")
End If

Easier threading with BackgroundWorker

The BackgroundWorker class joins the Thread, ThreadPool, asynchronous delegate invocation and friends in the world of .NET Framework-based threading. As with all things threading, a cursory overview isn't sufficient. Allocate some time to learn the BackgroundWorker class if you think you'll need threading support in the future. The design accounts for common usage scenarios and is a valuable tool for anyone's bag of tricks.