Using custom attributes to add performance counters to your application

• Download source files - 11.2 Kb

Introduction

A performance counter monitors the behavior of performance objects on a computer. These include physical components, such as processors, disks, and memory, and system objects, such as processes and threads. There are also a large number of performance counters created (and maintained) by the .NET common language run time environment, including % time spent in garbage collection, and total size of managed heaps etc.

The behaviour of your system can be monitored by running the perfmon.exe utility which has the interface as shown above. You select the performance counters that you are interested in and they are graphed for you.

Creating custom performance counters

The .NET framework includes two classes that you can use to interact with the performance monitor: PerformanceCounterCategory and PerformanceCounter - using these, you can create custom performance counters to monitor aspects of your own application to keep an eye on its performance.

Attribute for performance monitoring

The attached library contains two attribute derived classes, PerformanceCounterCategoryAttribute and PerformanceCounterAttribute, which you can use to decorate your business object classes, and then use the shared functions in the PerformanceCounterUtilities class to create and update these performance counters.

Associating a class with a performance counter category

To associate a class with a particular performance counter category, you decorate that class definition with a PerformanceCounterCategoryAttribute attribute.

<PerformanceCounterCategory("Attribute Test", _
"Test of the performance counter utility library")> _
Public Class PerformanceCounterTestClass
'- - 8< - - - - - - - - - - - - - - - - - - -

Associating a property of a class with a performance counter

To associate a public property of your class with a particular performance counter, you decorate that property definition with a PerformanceCounterAttribute attribute.

'- - 8< - - - - - - - - - - - - - - - - - - - 
<PerformanceCounter("Value List Length", _
"The number of items in the value list", _ 
PerformanceCounterType.NumberOfItems32)> _
Public ReadOnly Property CurrentList() As Collection
'- - 8< - - - - - - - - - - - - - - - - - - -

There are overloaded constructors for the PerformanceCounterAttribute attribute that allow you to specify the type of the performance counter (if none is specifically selected, PerformanceCounterType.NumberOfItems32 is assumed), and for those performance counter types that require an associated base performance counter (for example, a RawFraction counter type requires an associated Rawbase counter type), you can specify the name of the property that supplies the base performance category.

(Re)Creating the performance counters

Before you can assign values to the various performance counters, you need to create them. To do this, you pass an instance of your class (that has the attributes on it) to RebuildPerformanceCounterCategory. This creates a set of CounterCreationData objects and puts them in the right order needed to create the performance counters for that object type.

Private TestClass As New PerformanceCounterTestClass
'\\ Create and register the performance counter categories       
PerformanceCounterUtilities.PerformanceCounterUtilities.
            RebuildPerformanceCounterCategory(TestClass)

Updating all the performance counters from an instance of a class

To update all the performance counters associated with a class, call the UpdatePerformanceCounter method and pass the class instance in.

PerformanceCounterUtilities.UpdatePerformanceCounter(TestClass)

Updating a single performance counter from a class and property name

To update a single performance counter associated with a class property, call the UpdatePerformanceCounter method and pass the class instance and the property name in.

PerformanceCounterUtilities.UpdatePerformanceCounter(TestClass, _
                                                   "Iterations")

Usage scenarios

Custom performance counters are a great way of instrumenting your .NET applications in order to monitor the performance and diagnose any bottlenecks or problems with that application, and in the long term, they can save a great deal of stress and hair loss.