I have been asked to provide a more-realistic Windows application, and that is the point of this post.

My new Windows application uses .NET performance-counter classes to collect health information:

It uses SignalR to send this information to the Web page:

The application samples its counters once per second and sends the information to the dashboard. The values that determine the system health status are derived from the thresholds defined in the PAL tool. (PAL is a great addition to your toolbox, by the way. If you haven't used it, you should go look right away, Go ahead, I'll wait.)

Try it out

I will describe the new Windows application below. However, if you would like to try this for yourself first, then follow these steps:

1. Navigate to the web page. The URL is https://signalrdashboard.azurewebsites.net/ .
2. Run the new Windows application. It is a ClickOnce-deployed application hosted at https://signalrdashboard.blob.core.windows.net/wpfclientperf/publish.htm . (You will probably need to add https://signalrdashboard.blob.core.windows.net to your trusted sites list in order to run the application. It was signed with an untrusted, temporary certificate.)
3. Copy the "Client ID" value from the web page and paste it into the Windows application. (Because this demo is hosted in the cloud, many people may try to use it at the same time. To keep things simple, each instance of the Windows application will send data only to the client whose ID matches that entered into the application's "Client ID" textbox.)
4. Sit back and watch the show. New system status values will be set to the dashboard every second. If you get bored with constant "Normal" values, make your machine work harder. For this purpose, I like to make SQL Server Management Studio run "CPU Stress" scripts such as the one described at https://blog.sqlauthority.com/2013/02/22/sql-server-t-sql-script-to-keep-cpu-busy/ . Choose what you will, but get that CPU util up!
5. OPTIONAL. You can also run the older Windows application as well. The dashboard will respond to the old "health" sliders as well as to the new performance-based information.

Read the details

The heart of the new application is the System.Diagnostics.PerformanceCounter class. The application uses this class to pull system performance-counter information from the local machine. In fact, most of the code is devoted to this. There are three main classes involved:

• SignalRDashboard.Common.PerformanceCounter
  • Abstract class
  • Provides functionality needed to collect data from any system performance counter
• SignalRDashboard.Common.CPUPerformanceCounter
  • Derived from SignalRDashboard.Common.PerformanceCounter
  • Contains overrides unique to the "Processor Information\% Processor Time(_Total)" counter
• SignalRDashboard.Common.ProcessorQueueLengthPerformanceCounter
  • Derived from SignalRDashboard.Common.PerformanceCounter
  • Contains overrides unique to the "Processor Queue Length\Processor Information(Total)" counter

Combined together, these classes provide the information needed to determine the "health" of the monitored system. (For the demo, this is always the local machine. However, in reality, it could include data from remote machines as well.)

The data points used are:

• The last five counter values
• The average of these five values
• The peak from these five values
• The warning threshold (from PAL)
• The critical threshold (from PAL)

The classes also contain logic to update their counter values when directed, and to determine a new health status from those values. The code is too long to duplicate here, but it is all very straight forward and is included in the download zip below.

The SignalRDashboard.Common.PerfStatusCounter class brings everything together. This class holds a collection of PerformanceCounter-derived objects, and performs aggregations across them.

public ICollection<PerformanceCounter> Counters { get; private set; } 

For example, the overall status of the system is the maximum of the status values for all the counters:

public Status Status 
{ 
    get
    { 
        return this.Counters.Max(x => x.Status); 
    } 
} 

Similarly, the details of the current status are the concatenation of the details of each counter:

public ICollection<string> StatusDetails 
{ 
    get
    { 
        var details = new Collection<String>(); 

        foreach (var c in this.Counters) 
        { 
            foreach (var d in c.StatusDetails) 
            { 
                details.Add(d); 
            } 
        } 

        return details; 
    } 
} 

And the individual counters are updated as a batch:

public void Update() 
{ 
    foreach (var c in this.Counters) 
    { 
        c.Update(); 
    } 

    if (!String.IsNullOrWhiteSpace(this.ClientId)) 
    { 
        SignalRSupport.Instance.SendPerfStatusUpdate(this.ClientId, 
                                                    this.CounterName, 
                                                    this.Status.ToString(), 
                                                    this.StatusDetails); 
    } 

    this.OnPropertyChanged("Status"); 
    this.OnPropertyChanged("StatusDetails"); 
} 

Notice the "SendPerfStatusUpdate" method above. This is where SignalR comes in. This method makes a call to the "SendPerfStatusUpdate" method defined in the SignalR hub defined in the Web page.

In Common.SignalRSupport:

public void SendPerfStatusUpdate(string clientId, 
 string systemName, 
 string status, 
 ICollection<string> statusDetails) 
{ 
    if (!String.IsNullOrWhiteSpace(clientId)) 
    { 
        // invoke the SendStatus method that is defined on the hub.
        statusHubProxy.Invoke("SendPerfStatusUpdate", 
 clientId, 
 systemName, 
 status, 
 statusDetails); 
    } 
} 

In StatusHub in the Web project:

public void SendPerfStatusUpdate(string connectionId, 
 string systemName, 
 string status, 
 ICollection<string> statusDetails) 
{ 
    Clients.Client(connectionId).ProcessPerfStatusMessage(systemName, 
 status, 
 statusDetails); 
} 

And in the web page itself:

hub.client.processPerfStatusMessage = function (systemName, 
 status, 
 statusDetails) { 
    // show the row
    $("#" + systemName + "Row").css("visibility", "visible"); 

    // get appropriate class from status
    var c = "btn btn-lg"; 

    if (status == "Critical") { 
        c = "btn btn-lg btn-danger"; 
    } 

    if (status == "Warning") { 
        c = "btn btn-lg btn-warning"; 
    } 

    if (status == "Normal") { 
        c = "btn btn-lg btn-success"; 
    } 

    // assign the class to the appropriate button
    $("#" + systemName).attr("class", c); 

    // assign details
    var detailsName = "#" + systemName + "Details"; 

    $(detailsName).text(""); 

    $.each(statusDetails, function (index, value) { 
        $(detailsName).append(value); 
        $(detailsName).append("<br />"); 
    }); 

Finally, the Windows application has a dispatcher timer that causes the counter values to be updated once per second. Here is the entire code-behind:

private Common.PerfStatusCounter _status = null; 
private DispatcherTimer _timer = null; 
 
public MainWindow() 
{ 
    InitializeComponent(); 

    var localMachineName = Environment.MachineName; 

    _status = new Common.PerfStatusCounter(); 
    _status.CounterName = "PRD3"; 
    _status.Counters.Add(
 new Common.CPUPerformanceCounter(localMachineName)
 ); 
    _status.Counters.Add(
 new Common.ProcessorQueueLengthPerformanceCounter(localMachineName)
 ); 

    this.DataContext = _status; 

    _timer = new DispatcherTimer(); 
    _timer.Interval = new TimeSpan(0,0,1); 
    _timer.Tick += timer_Task; 
    _timer.Start(); 
} 

private void timer_Task(object sender, EventArgs e) 
{ 
    _status.Update(); 
} 

Other than the timer and the performance-counter code, this new demo works in exactly the same way as the previous one does. However, instead of reporting the values of a bunch of sliders, this new application lifts performance data from the local system. It is much more realistic than using sliders.

Download the code

SignalRDashboard2.zip 

• This post covers SignalR and how it is used to provide real-time "health" updates to a web page.
• Part 2 covers how to use the .NET PerformanceCounter class to pull actual status information and forward it to the dashboard.

Lately, I have received a number of requests for help with simple dashboard applications. Most of the people making these requests have similar requirements. They would like an application that:

• Runs in a web page
• Acquires updated information without page refreshes or post-backs
• Is easy to code
• Receives data within seconds of that data being generated

Some people have additional requirements. Their application must also:

• Run on different browser brands and versions
• Obtain data from non-web sources, such as console or Windows applications

My demo addresses all of these points, and consists of two parts. The first is a web application that displays the health of a fictitious environment that contains six computers. Those computers are divided into three different environments; Development (DEV), User-Acceptance (UAT), and Production (PRD). Each computer name is derived, imaginatively enough, from its environment and ordinal position within that environment. We therefore have DEV1 and DEV2 in the development area, UAT1 and UAT2 in the user-acceptance area, and PRD1 and PRD2 in the production area.

In this sample, you can quickly see that the computers in the production environment are just fine, but that we have a possible situation in development, and an outright problem in acceptance.

The second part of the solution is a Windows application that provides the status values for this fictitious environment.

You can see that there is a slider for each machine, and that the data values here are reflected in the web page. The demo implements a one-way communications channel from the Windows application to the web page. Changes made in this Windows application are quickly transmitted to the web page.

By the way, in a real implementation, this Windows application would be a background task that constantly assesses the health of the environment. It could be any type of application; a console app, a Windows service, or even a PowerShell script. Anything that can communicate using HTTP protocols will work. Here, however, we are concerned about how the data is sent from the source to the web page and not on the data collection itself. Therefore, we have a simple set of sliders.

Try it out

I will describe the solution in some detail below. However, if you would like to try this for yourself first, then follow these steps:

1. Navigate to the web page. The URL is https://signalrdashboard.azurewebsites.net/ .
2. Run the Windows application. It is a ClickOnce-deployed application hosted at https://signalrdashboard.blob.core.windows.net/wpfclient/publish.htm . (You will probably need to add https://signalrdashboard.blob.core.windows.net to your trusted sites list in order to run the application. It was signed with an untrusted, temporary certificate.)
3. Copy the "Client ID" value from the web page and paste it into the Windows application. (Because this demo is hosted in the cloud, many people may try to use it at the same time. To keep things simple, each instance of the Windows application will send data only to the client whose ID matches that entered into the application's "Client ID" textbox.)
4. Fiddle with the sliders and watch the web page change. (Don't fiddle TOO fast. Again, I'm trying to keep things simple. The demo does not throttle slider-value changes, so it is possible to change the slider values faster than the web page can apply them. In a real application, messages will normally be throttled in an appropriate manner.)

Read the details

The demo uses a SignalR Hub to facilitate easy communications. The hub is defined in the web application code-behind, so it runs on the Web server. It is defined in a class called StatusHub:

namespace SignalRDashboard.Web
{ 
    public class StatusHub: Hub
    { 
        public void SendStatus(string connectionId, 
                               string systemName, 
                               string value, 
                               string status) 
        { 
            Clients.Client(connectionId).ProcessStatusMessage(
                                          systemName, 
                                          value, 
                                          status); 
        } 
    }
}

The hub class defines a method (SendStatus) that sends a message to a particular client. The command is broken down like this:

Clients                        ß returns an IHubCallerConnectionContext that
                                  allows access to clients
Client(connectionId)           ß returns a connection to the client with
                                  the specified Id
ProcessStatusMessage(...);     ß invokes the ProcessStatusMessage function 
                                  defined in the web page

The ProcessStatusMessage function is defined in the JavaScript in the web page itself:

hub.client.processStatusMessage = function (systemName, value, status) { 
    // get appropriate class from status
    var c = "btn btn-lg"; 

    if (status == "Critical") { 
        c = "btn btn-lg btn-danger"; 
    } 

    if (status == "Warning") { 
        c = "btn btn-lg btn-warning"; 
    } 

    if (status == "Normal") { 
        c = "btn btn-lg btn-success"; 
    } 

    // assign the class to the appropriate button
    $("#" + systemName).attr("class", c); 

    // assign name based on value
    $("#" + systemName).text(systemName + " (" + value + ")") 
} 

The cool part is that SignalR wires up the communications between the function in the code-behind on the server (SendStatus) and the function in the JavaScript in the browser (ProcessStatusMessage). It does this based on the capabilities of the specific web server and browser being used. It implements various transport protocols and chooses the most –appropriate one for the situation. This eliminates a lot of tedious programming.

Now that we know that the hub can send data to the browser client, we need to know how to send data to the hub. In this demo, the data is generated in the Windows application, so that is where the communication happens as well. In the SignalRSupport class, there are two interesting sections of code.

First, in the constructor:

private SignalRSupport() 
{ 
    // create a connection to the hub
    // note that this is a disposable object, but I do not dispose of it here.
    // the connection will be used for the life of the application, so this is acceptable.
    var hubConnection = new HubConnection("https://signalrdashboard.azurewebsites.net/"); 

    // create a client proxy class to use to communicate with the hub.
    statusHubProxy = hubConnection.CreateHubProxy("StatusHub"); 

    // start the connection and wait for it to complete.
    // without .wait, the code would continue while the connection is made.
    hubConnection.Start().Wait();       
} 

The code creates a connection to the hub via its URL. (Hey! I KNOW that this shouldn't be hard-coded, but this is a demo. Do what I say, not what I do.) It next creates a Hub proxy that will be used to execute the SendStatus function mentioned above. Finally, it starts the connection. Note the "Wait" method call. The Start method is asynchronous. Without Wait, the code would continue executing even though the connection hasn't started. In many applications, this is fine. In this demo though, I didn't want to deal with people moving sliders around when the hub connection wasn't ready.

The second interesting section is the SendStatusUpdate method:

public void SendStatusUpdate(string clientId, string systemName, string value, string status) 
{ 
    // invoke the SendStatus method that is defined on the hub.
    statusHubProxy.Invoke("SendStatus", clientId, systemName, value, status); 
} 

This code uses the proxy that was create in the constructor to invoke the SendStatus method that is defined in the Hub. Once again, SignalR takes care of wiring up the communications between the Windows application and the Web server. (Remember when I said that the Hub class ran on the server?) It negotiates the best protocol and handles the connection automatically. More tedious code that I don't have to write.

Believe it or not, the SignalR part of the application is complete. The rest of the example is all XAML and data-binding, which is not the point of this post. However, it goes something like this:

The main window has 6 instances of the StatusControl usercontrol, which contains the slider that is used to control a single machine value. Each StatusControl binds to an instance of the StatusCounter class. The StatusCounter value property contains code that initiates the SignalR communications described above:

public int Value 
{ 
    get
    { 
        return _value; 
    } 
    set
    { 
        // has the value changed?
        if (_value != value) 
        { 
            // the value has changed, so apply it.
            _value = value; 

            // raise propertychanged events so that databinding can work
            if (PropertyChanged != null) 
            { 
                PropertyChanged(this, new PropertyChangedEventArgs("Value")); 
                PropertyChanged(this, new PropertyChangedEventArgs("Status")); 

                SignalRSupport.Instance.SendStatusUpdate(this.ClientId, this.CounterName, this.Value.ToString(), this.Status.ToString()); 
            } 
        } 
    } 
} 

Therefore, when a slider value is changed, data-binding drives the sending of that value to the appropriate machine counter on the correct client. Gotta love data-binding!

Download the code

 SignalRDashboard.zip

Read the references

Introduction to SignalR

Please leave a comment if you find this useful.

function ZipFiles( $zipfilename, $sourcedir )
{
     Add-Type -Assembly System.IO.Compression.FileSystem 
     $compressionLevel = [System.IO.Compression.CompressionLevel]::Optimal
     [System.IO.Compression.ZipFile]::CreateFromDirectory($sourcedir, 
                                                          $zipfilename,
                                                          $compressionLevel, 
                                                          $false)
}

Unfortunately, this would not work for me.  This script zips everything in a folder, whereas I needed to zip a specific file.  I therefore searched some more and found a combination of three blogs that gave me what I needed:

[CmdletBinding()]
Param(
     [Parameter(Mandatory=$True)]
     [ValidateScript({Test-Path -Path $_ -PathType Leaf})]
     [string]$sourceFile,

     [Parameter(Mandatory=$True)]
     [ValidateScript({-not(Test-Path -Path $_ -PathType Leaf)})]
     [string]$destinationFile
)

<#
     .SYNOPSIS
     Creates a ZIP file that contains the specified innput file.

     .EXAMPLE
     FileZipper -sourceFile c:\test\inputfile.txt
                -destinationFile c:\test\outputFile.zip
#>

function New-Zip
{
     param([string]$zipfilename)
     set-content $zipfilename
          ("PK" + [char]5 + [char]6 + ("$([char]0)" * 18))
     (dir $zipfilename).IsReadOnly = $false
}

function Add-Zip
{
     param([string]$zipfilename)

     if(-not (test-path($zipfilename)))
     {
          set-content $zipfilename
               ("PK" + [char]5 + [char]6 + ("$([char]0)" * 18))
          (dir $zipfilename).IsReadOnly = $false   

     }

     $shellApplication = new-object -com shell.application
     $zipPackage = $shellApplication.NameSpace($zipfilename)
    

     foreach($file in $input)
     { 
          $zipPackage.CopyHere($file.FullName)
          Start-sleep -milliseconds 500
     }
}

dir $sourceFile | Add-Zip $destinationFile

The three posts that helped were:

• Compress Files with Windows PowerShell then package a Windows Vista Sidebar Gadget
• Simplify Your PowerShell Script with Parameter Validation
• Hey, Scripting Guy! How Do I Add Help Information for Windows PowerShell Parameters?

I hope this saves someone else some time.

This:

becomes this:

New goodies include better Web tooling (MVC, WebAPI, JSON, CSS) and vastly-increased debugging capabilities.  This is a free update, and it is well worth the download time. 

The REAL reason for this post, however, is to make sure that people know about these add-ins:

• Productivity Power Tools 2013
• Web Essentials 2013

I have been doing more development lately, and these tools are really useful. 

Productivity Power Tools provides about 25 useful features to general development.  My favorites are:

• Peek Help (Alt + F1) - invoke context-sensitive help from MSDN and display it in the "Peek Definition" window.
• Solution Explorer Errors - Solution Explorer now places "squiggles" beneath files, folders, projects, and solutions that contain errors.  Now it is obvious where my errors lie.  Hovering the mouse pointer over a squiggle causes the error messages to pop up in a little window.
• Structure Visualizer - Vertical lines connect the begin and end of block constructs, such as if statements.  This is really nice when there are a lot of nested structures or one structure is large than one screen height.
• Document Well - Customize many of the color and behaviors of the tabs in the source editor window.

All of the features are configurable, and can be enabled or disabled as you see fit.  The full feature list is available on the Visual Studio Gallery page.

Web Essentials adds enhanced support for Web page development, including CSS (more Intellisense), JavaScript (Minification, Auto-complete braces), and more.  It also enhances BrowserLink so that it is even more useful than before. Check out the web site for a full list of features.

The goal was to run Windows 8.1 on a laptop, but to have the option to boot into Windows 7 when needed.  I used an HP EliteBook 8540w, which is easily able to run Windows 7.  (It has Windows 7 drivers available, uses BIOS instead of UEFI, and has no SecureBoot support.)  My son used his Dell Inspiron 15 7000 Touch, which does NOT have Windows 7 drivers available.  His laptop has all the latest goodies, including UEFI and SecureBoot. 

Here is our list of steps:

1. Create a fixed-size hard disk with Hyper-V Manager.  You need to use the VHD format, because VHDX only works with Windows 8.x / Widows Server 2012 and above.  
2. Create a VM for your VHD, and install Windows 7.  I also installed SP1 and all of the updates and patches.
3. Run SysPrep on the VM, and specify OOBE, Generalize, and Shutdown.
4. Copy the VHD to the laptop that will use it for boot.  (I created the VHD on a new, faster, laptop.)
5. Mount the VHD with Disk Manager and note the driver letter that is assigned.  On my laptop, it was drive G:
6. Open an Administrative Command Prompt
7. Run BCDBoot G:\Windows
8. Run BCDBoot C:\Windows
9. Reboot the laptop.

After following these steps, my laptop could successfully boot into Windows 7.   My son's could not.  We believe that the only difference was that my laptop has Windows 7 driver support, while his does not.

I believe that this is an easier process, because I did not have to use BCDEdit or ImageX, which were recommended in all of the posts that I found.  These steps are very similar to those that I use to create VMs in Hyper-V, so I find them more intuitive.

There are some caveats:

• If you have enabled Hyper-V one the machine, this this process will disable it.  You can re-enable the hypervisor by running this command from and Administrative Command Prompt:
• BCDEdit /set {current} hypervisorlaunchtype auto
• Your laptop has to be able to run the guest OS in the first place (my son's could not because there are no Windows 7 drivers available)
• You need to disable BIOS/UEFI features that are not supported by your guest OS (SecureBoot, for example)
• You can only use the VHDX format if your guest OS supports it (Windows 8.x / Windows Server 2012)
• Be ready to admit that your son knows more about this than you do. :)

Public Shared Function GetMethodOrPropertyName(
			<CallerMemberName> Optional memberName As String = Nothing) 
			As String
    Return memberName
End Function

The key here is that I do not specify the memberName parameter when I call the function, so the compiler fills it in for me.  (That's what the attribute is for.)  Now I can call this function whenever I need the current method's name.  NO custom reflection code required.

Last Updated: 10/3/2014

Recent and upcoming changes are highlighted in red.

SQL Server

• 7.0
• No longer supported
• 2000
• No longer supported
• 2005
• In extended support
• Leaves support completely on 4/12/2016
• SP4 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=7218
• 2008
• In extended support
• Leaves support completely on 7/9/2019
• SP4 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=44278
• 2008 R2
• In extended support
• Leaves support completely on 7/9/2019
• SP3 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=44271
• 2012
• In mainstream support
• Goes into extended support on 7/11/2017
• Leaves support completely on 7/12/2022
• SP1 leaves support on 7/14/2015
• SP2 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=43340
• 2014
• In mainstream support
• Goes into extended support on 7/9/2019
• Leaves support completely on 7/9/2024

.NET Framework

• 1.0
• No longer supported
• 1.1
• Standalone versions are no longer supported
• Support for the .NET Framework 1.1 version bundled with Windows 2003 SP2 x86 will continue until 7/14/2015, when the operating system support ends.
• 2.0
• In extended support
• Leaves support completely on 4/12/2016
• SP2 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=1639
• 3.0
• No longer supported
• 3.5
• RTM is no longer supported
• SP1 is now considered a part of the operating system on which it is supported.  It will be supported and serviced along with the operating system.
• SP1 download: https://www.microsoft.com/en-us/download/details.aspx?id=22
• 3.5.1
• 3.5.1 is now considered a part of the operating system on which it is supported.  It will be supported and serviced along with the operating system.
• 4.0
• 4.0 is now considered a part of the operating system on which it is supported.  It will be supported and serviced along with the operating system.
• 4.5
• It is a replacement for .NET 4.0, not a separate install (4.5 updates 4.0)
• It is considered a component of the operating on which it is installed.  It will be supported and serviced along with the operating system.
• 4.5.1
• It is a replacement for .NET 4.0 and .NET 4.5, not a separate install (4.5.1 updates 4.x)
• It is considered a component of the operating on which it is installed.  It will be supported and serviced along with the operating system.

Visual Studio

• 2002
• No longer supported
• 2003
• No longer supported
• 2005
• In extended support
• Leaves support completely on 4/12/2016
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=5553
• 2005 Team Editions
• All versions except the database edition
• In extended support
• Leaves support completely on 4/12/2016
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=5553
• Database edition
• In extended support
• Leaves support completely on 4/11/2017
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=5553
• 2008
• In extended support
• Leaves support completely on 4/10/2018
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=10986
• 2010
• In mainstream support
• Goes into extended support on 7/14/2015
• Leaves support completely on 9/8/2020
• SP1 is the current service pack: https://www.microsoft.com/download/en/details.aspx?id=23691
• 2012
• In mainstream support
• Goes into extended support on 1/9/2018
• Leaves support completely on 1/10/2023
• RTM (no service pack) is the current version
• Update 4 is available: https://www.microsoft.com/en-us/download/details.aspx?id=39305
• 2013
• In mainstream support
• Goes into extended support on 4/9/2019
• Leaves support completely on 4/9/2024
• RTM (no service pack) is the current version
• Update 3 is available: https://www.microsoft.com/en-us/download/details.aspx?id=43721

Team Foundation Server

• 2005
• In extended support
• Leaves support completely on 7/12/2016
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=15789
• 2008
• In extended support
• Leaves support completely on 4/10/2018
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=6097
• 2010
• In mainstream support
• Goes into extended support on 7/14/2015
• Leaves support completely on 9/8/2020
• SP1 is the current service pack: https://www.microsoft.com/download/en/details.aspx?displaylang=en&id=20506
• 2012
• In mainstream support
• Goes into extended support on 1/9/2018
• Leaves support completely on 1/10/2023
• RTM (no service pack) is the current version
• 2013
• In mainstream support
• Goes into extended support on 4/9/2019
• Leaves support completely on 4/9/2024
• RTM (no service pack) is the current version

Windows Server

• 2000
• No longer supported
• 2003
• In extended support
• Leaves support completely on 7/14/2015
• SP2 is the current service pack: https://technet.microsoft.com/en-us/windowsserver/bb229701.aspx
• 2003 R2
• In extended support
• Leaves support completely on 7/14/2015
• SP2 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=11276
• 2008
• In mainstream support
• Goes into extended support on 1/13/2015
• Leaves support completely on 1/14/2020
• SP2 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=16468
• 2008 R2
• In mainstream support
• Goes into extended support on 1/13/2015
• Leaves support completely on 1/14/2020
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=5842
• 2012
• In mainstream support
• Goes into extended support on 1/9/2018
• Leaves support completely on 1/10/2023
• RTM (no service pack) is the current version
• 2012 R2
  • In mainstream support
  • Goes into extended support on 1/9/2018
  • Leaves support completely on 1/10/2023
  • RTM (no service pack) is the current version

Windows Client

• XP
• No longer supported
• Vista
• In extended support
• Leaves support completely on 4/11/2017
• SP2 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=16468
• 7
• In mainstream support
• Goes into extended support on 1/13/2015
• Leaves support completely on 1/14/2020
• SP1 is the current service pack: https://www.microsoft.com/en-us/download/details.aspx?id=5842
• 8
• In mainstream support
• Must move to Windows 8.1 by 1/12/2016 in order to remain supported
• RTM (no service pack) is the current version
• 8.1
• In mainstream support
• Goes into extended support on 1/9/2018
• Leaves support completely on 1/10/2023
• RTM (no service pack) is the current version

First, I wanted to test using a single connection:

     Dim sw As Stopwatch = Stopwatch.StartNew

     Using conn As New SqlConnection(My.Settings.ConnectionString)
          conn.Open()

          For i = 1 To 1000
               Using cmd As New SqlCommand("select * from dbo.person", conn)
                    Using rdr As SqlDataReader = cmd.ExecuteReader()
                         While rdr.Read
                         End While
                    End Using
               End Using
          Next
     End Using

     sw.Stop()
     Dim elapsed As Long = sw.ElapsedMilliseconds

     MessageBox.Show(elapsed.ToString)

I called this test “OC” for “One Connection”.

Next, I wanted to test opening and closing the connection with and without connection pooling:

     Private Sub MultipleConnections(connectionString As String)

          Dim sw As Stopwatch = Stopwatch.StartNew

          For i = 1 To 1000
               Using conn As New SqlConnection(connectionString)
                    conn.Open()
                    Using cmd As New SqlCommand("select * from dbo.person", conn)
                         Using rdr As SqlDataReader = cmd.ExecuteReader()
                              While rdr.Read
                              End While
                         End Using
                    End Using
                    conn.Close()

               End Using
          Next

          sw.Stop()
          Dim elapsed As Long = sw.ElapsedMilliseconds

          MessageBox.Show(elapsed.ToString)

     End Sub

I called this two ways.  With pooling enabled (the default, called “CP”):

     MultipleConnections(My.Settings.ConnectionString)

and with pooling disabled (called “NCP”):

     MultipleConnections(My.Settings.ConnectionString & ";Pooling='false'")

I then ran each test 10 times and placed the results in a table (values indicate milliseconds):

Now, what does this mean?  Clearly, if you disable connection pooling, then you will likely suffer a significant performance penalty.  I expected this.  I also expected that using one connection (OC) was faster than using connection pooling (CP).  In these tests, OC is roughly 19% faster than CP.  This sounds significant, but remember that the test code looped 1,000 times.  On average, a single OC call was .066 milliseconds faster than a single CP call.  Unless you are hitting the database many times, such as when running a multi-user ASP.NET application, you won’t notice six hundredths of a millisecond.  (The connection pooling system does a pretty good job of managing the connections.)  Still, it is good to see hard numbers back up what I “know”.

So, for the question:  "What are the risks of NOT moving my applications off of VB 6?"

Visual Basic 6 support falls into three categories; the IDE, the source code itself, and the runtime. 

Support for the IDE and source code expired a while ago. Support for the runtime, however, will continue for quite some time.  The VB 6 runtime files are considered to be a part of the operating system with which they shipped.  As you can see from our official support statement (https://msdn.microsoft.com/en-us/vbrun/ms788708.aspx ), the VB 6 runtime will be supported for the life of Windows 7 and Windows Server 2008.  (This means that VB 6 applications will be supported on Windows Server 2008 until support for that system expires in 2020.)  This sounds like a very long time, but there are caveats:

1. Microsoft does not provide support for third-party VB 6 controls.  We have no way of knowing whether these controls will function on newer operating systems.
2. VB 6 applications are 32-bit only.  When running on a 64-bit system, VB 6 apps run in the emulated WOW environment.  This can cause problems with some applications.
3. Not all VB 6 controls are supported on Windows Vista and later operating systems.  You can see a list of these controls in the official support statement (https://msdn.microsoft.com/en-us/vbrun/ms788708.aspx ).
4. IMPORTANT:  When you apply a new service pack, install a hot fix, or move to a newer operating system, new security requirements may interfere with the expected performance of your VB 6 application.   Microsoft may not be able to restore the former functionality of your application without reducing security.  In these cases, Microsoft is not required to issue a "fix".  In other words, Microsoft does not have to roll back or remove security enhancements so that your application will continue to work.  This is important to understand, since VB 6 applications were often written and tested on systems where users had administrative rights. 
5. There are no plans to include VB6 runtime in future versions of Windows beyond Windows 7 and Windows Server 2008.  Although these operating systems are supported until 2020 and 2018 respectively, new systems will most likely be available well before then.  These new systems may not include VB 6.

As always, the views stated here are my opinion and not Microsoft's.  You should contact your Microsoft respresentative for an official statement for your specific situation.