WMI Example

This post is just to demonstrate the type of custom implementations you can do with WMI.

In the old days you had to use COM to access WMI but since .Net 2.0, Microsoft have provided WMI extensions that are built-in to the .Net framework these days. This is much easier to use
so I would recommend that approach.

Firstly, your project needs reference to System.Management
Each provider needs to be decorated with the following assembly attribute:

[assembly: WmiConfiguration(@"root\MyApplication",
 HostingModel = ManagementHostingModel.Decoupled)]

As you can see, I provide my "namespace" I am going to use for my WMI instances as well as specifying a hosting model. A decoupled hosting model is an in-process hosting model.
To inform the WMI infrastructure that the assembly contains a WMI provider, the assembly must contain an installer class that can be run by the InstallUtil.exe command.

This installer class must derive from the DefaultManagementInstaller class and be decorated
with the [RunInstaller] attribute. It does not require any additional functionality.

[RunInstaller(true)]
public class WMISampleLibraryInstaller :
 DefaultManagementInstaller { }

You can use InstallUtil in the Visual Studio Command prompt with the following line:

InstallUtil MyAssembly.dll

Read-Only Information

The most rudimentary kind of WMI provider is a WMI provider that exposes
read-only information regarding a configurable entity.

[ManagementEntity]
public class ProcessInformation
{
 Process _theProcess;
 [ManagementBind]
 public ProcessInformation(
     [ManagementName("Id")] int id)
 {
     _theProcess = Process.GetProcessById(id);
 }
 [ManagementKey]
 public int Id
 {
     get { return _theProcess.Id; }
 }
 [ManagementProbe]
 public int ThreadCount
 {
     get { return _theProcess.Threads.Count; }
 }
}

To publish the instance to the WMI infrastructure, the hosting process can use the following code:

foreach (Process p in Process.GetProcesses())
{
    InstrumentationManager.Publish(
           new ProcessInformation(p.Id));
}

You can query information on WMI with the following query:

ManagementObjectSearcher searcher =
    new ManagementObjectSearcher(@"root\MyApplication",
        "SELECT * FROM ProcessInformation");
foreach (ManagementObject obj in searcher.Get())
    Console.WriteLine("Id: " + obj["Id"] +
        ", ThreadCount: " + obj["ThreadCount"]);

There are similar tasks you can do for Write Properties and Methods. These are just different attributes you have to use. There is a limitation that Singletons cannot be used for Write Properties and Methods.

You use [ManagementTask] attribute on a method to expose it through WMI.
You use [ManagementConfiguration] attribute on a write property to expose it through WMI.

Windows Management Instrumentation (WMI)

WMI is quite an old technology that I think a lot of people have heard about but few people have actually tried. Even fewer people can use it and about a handful of people are masters of it. I have recently tried out this technology and thus I am definitely not the latter.

WMI 101 (short version):

WMI is the de-facto standard to access management information in an enterprise environment. The standard is used to address the ability to access, configure, manage and monitor system resources. WMI is commonly used by Administrators to monitor both local and remote machines using scripts. You need to know about WMI if you want your applications to be monitored in production by third party applications or Administrators and their scripts.

WMI concepts:

• Providers - Acts as an intermediary between WMI and a managed resource, such as an Event Log. Providers request information from, and send instructions to the WMI managed resource on behalf of consumer applications and scripts.
• Consumer - A script, enterprise management application or any other application that makes use of WMI resources.
• CIM - Common Information Model is a schema (object repository or class store) that models the managed environment and defines every piece of data exposed by WMI.
• CIMOM - CIM Object Manager handles the interaction between consumers and providers.
  
• Events - WMI allows you to register for events which will notify you when any WMI object is created, deleted or modified.

So why would you want to use WMI?

WMI can be used to build tools that organize and manage system information so that administrators or system managers can monitor system activities more closely. WMI allows you to access an enormous amount of information about both local and remote machines.

Lets take a moment to think about the possibilities.

• You can development an application using WMI that pages an administrator when a Web server crashes,
  
• Have a badly behaving process terminated if it exceeds more than certain about of CPU usage.
• You can also detect and discover management information such as what operating system (including service pack) is installed on a server.
• You can determine how many processors the computer system has
• Determine which services are running in a process
• Etc

All these examples are built-in WMI classes and events you can use. In addition, you can also define custom classes and events for your enterprise applications. The benefit is that all applications using the WMI infrastructure will pick up yours automatically.

Let's use another example. Let's say you have a couple of processes that are processing data on your servers. You would like these components to publish stats regarding their throughput, performance, internal queue sizes, CPU usage, etc. You would also like to restart these processes on an ad hoc or scheduled interval without stopping the whole interweaving process. You would like to be notified when certain business rules are violated or exceptions occur via different types of channels (SMS or Email).

Normally to do all this type of functionality you write custom code. This is typical System Monitoring and Control Bus implementations. Instead of writing a lot of custom code, you can rather use WMI to raise events when certain conditions occur OR publish information to performance counters and custom classes OR send WMI command to your process which will act accordingly.

The possibilities are endless. But why aren't a lot more people use it? The same reason for most things. It is difficult to use and limited documentation on it.

I still think it is worth investigating though.