rusanu.com

Update: a version of this sample that accepts parameters is available in the post Passing Parameters to a Background Procedure

Recently an user on StackOverflow raised the question Execute a stored procedure from a windows form asynchronously and then disconnect?. This is a known problem, how to invoke a long running procedure on SQL Server without constraining the client to wait for the procedure execution to terminate. Most times I’ve seen this question raised in the context of web applications when waiting for a result means delaying the response to the client browser. On Web apps the time constraint is even more drastic, the developer often desires to launch the procedure and immediately return the page even when the execution lasts only few seconds. The application will retrieve the execution result later, usually via an Ajax call driven by the returned page script.

Frankly I was a bit surprised to see that the responses gravitated either around the SqlClient asynchronous methods (BeginExecute…) or around having a dedicated process with the sole pupose of maintaining the client connection alive for the duration of the long running procedure.

This problem is perfectly addressed by Service Broker Activation. Since I wanted to preserve the solution for further reference, I decided to put it in as a blog entry, with additional comments. For many of you Service Broker aficionados that read my blog regularly, this article is not innovative as is mostly a rehash of well known techniques I’ve been talking about on forums for many years now.

I’m going to use a table to store the result of the procedure execution. In this version I’ll keep things simple by not allowing for any parameters to be passed to the procedure, nor collecting any execution result set data. So the table will only contain the procedure start time, the execution finish time and any error that occurred during the procedure execution:

create table [AsyncExecResults] (
	[token] uniqueidentifier primary key
	, [submit_time] datetime not null
	, [start_time] datetime null
	, [finish_time] datetime null
	, [error_number]	int null
	, [error_message] nvarchar(2048) null);
go

Next we’re going to create the service and queue we need. I will use one single service for both roles (initiator and target) and I won’t create an explicit contract, relying instead on the predefined DEFAULT contract:

create queue [AsyncExecQueue];
go

create service [AsyncExecService] on queue [AsyncExecQueue] ([DEFAULT]);
GO

Next is the core of our asynchronous execution: the activated procedure. The procedure has to dequeue the message that specifies the user procedure, run the procedure and write the result in the results table. I will also deploy the error handling template I elaborated on my previous article Exception handling and nested transactions:

create procedure usp_AsyncExecActivated
as
begin
    set nocount on;
    declare @h uniqueidentifier
        , @messageTypeName sysname
        , @messageBody varbinary(max)
        , @xmlBody xml
        , @procedureName sysname
        , @startTime datetime
        , @finishTime datetime
        , @execErrorNumber int
        , @execErrorMessage nvarchar(2048)
        , @xactState smallint
        , @token uniqueidentifier;

    begin transaction;
    begin try;
        receive top(1) 
            @h = [conversation_handle]
            , @messageTypeName = [message_type_name]
            , @messageBody = [message_body]
            from [AsyncExecQueue];
        if (@h is not null)
        begin
            if (@messageTypeName = N'DEFAULT')
            begin
                -- The DEFAULT message type is a procedure invocation.
                -- Extract the name of the procedure from the message body.
                --
                select @xmlBody = CAST(@messageBody as xml);
                select @procedureName = @xmlBody.value(
                    '(//procedure/name)[1]'
                    , 'sysname');

                save transaction usp_AsyncExec_procedure;
                select @startTime = GETUTCDATE();
                begin try
                    exec @procedureName;
                end try
                begin catch
                -- This catch block tries to deal with failures of the procedure execution
                -- If possible it rolls back to the savepoint created earlier, allowing
                -- the activated procedure to continue. If the executed procedure 
                -- raises an error with severity 16 or higher, it will doom the transaction
                -- and thus rollback the RECEIVE. Such case will be a poison message,
                -- resulting in the queue disabling.
                --
                select @execErrorNumber = ERROR_NUMBER(),
                    @execErrorMessage = ERROR_MESSAGE(),
                    @xactState = XACT_STATE();
                if (@xactState = -1)
                begin
                    rollback;
                    raiserror(N'Unrecoverable error in procedure %s: %i: %s', 16, 10,
                        @procedureName, @execErrorNumber, @execErrorMessage);
                end
                else if (@xactState = 1)
                begin
                    rollback transaction usp_AsyncExec_procedure;
                end
                end catch

                select @finishTime = GETUTCDATE();
                select @token = [conversation_id] 
                    from sys.conversation_endpoints 
                    where [conversation_handle] = @h;
                if (@token is null)
                begin
                    raiserror(N'Internal consistency error: conversation not found', 16, 20);
                end
                update [AsyncExecResults] set
                    [start_time] = @starttime
                    , [finish_time] = @finishTime
                    , [error_number] = @execErrorNumber
                    , [error_message] = @execErrorMessage
                    where [token] = @token;
                if (0 = @@ROWCOUNT)
                begin
                    raiserror(N'Internal consistency error: token not found', 16, 30);
                end
                end conversation @h;
            end 
            else if (@messageTypeName = N'http://schemas.microsoft.com/SQL/ServiceBroker/EndDialog')
            begin
                end conversation @h;
            end
            else if (@messageTypeName = N'http://schemas.microsoft.com/SQL/ServiceBroker/Error')
            begin
                declare @errorNumber int
                    , @errorMessage nvarchar(4000);
                select @xmlBody = CAST(@messageBody as xml);
                with xmlnamespaces (DEFAULT N'http://schemas.microsoft.com/SQL/ServiceBroker/Error')
                select @errorNumber = @xmlBody.value ('(/Error/Code)[1]', 'INT'),
                    @errorMessage = @xmlBody.value ('(/Error/Description)[1]', 'NVARCHAR(4000)');
                -- Update the request with the received error
                select @token = [conversation_id] 
                    from sys.conversation_endpoints 
                    where [conversation_handle] = @h;
                update [AsyncExecResults] set
                    [error_number] = @errorNumber
                    , [error_message] = @errorMessage
                    where [token] = @token;
                end conversation @h;
             end
           else
           begin
                raiserror(N'Received unexpected message type: %s', 16, 50, @messageTypeName);
           end
        end
        commit;
    end try
    begin catch
        declare @error int
            , @message nvarchar(2048);
        select @error = ERROR_NUMBER()
            , @message = ERROR_MESSAGE()
            , @xactState = XACT_STATE();
        if (@xactState <> 0)
        begin
            rollback;
        end;
        raiserror(N'Error: %i, %s', 1, 60,  @error, @message) with log;
    end catch
end
go

To make the procedure activated we need to attach it to our service queue. This will ensure this procedure is run whenever a message arrives to our [AsyncExecService]:

alter queue [AsyncExecQueue]
    with activation (
    procedure_name = [usp_AsyncExecActivated]
    , max_queue_readers = 1
    , execute as owner
    , status = on);
go

And finaly the last piece of the puzzle: the procedure that submits the message to invoke the desired asyncronous executed procedure. This procedure resturns an output parameter ‘token’ than can be used to lookup the asynchronous execution result.

create procedure [usp_AsyncExecInvoke]
    @procedureName sysname
    , @token uniqueidentifier output
as
begin
    declare @h uniqueidentifier
	    , @xmlBody xml
        , @trancount int;
    set nocount on;

	set @trancount = @@trancount;
    if @trancount = 0
        begin transaction
    else
        save transaction usp_AsyncExecInvoke;
    begin try
        begin dialog conversation @h
            from service [AsyncExecService]
            to service N'AsyncExecService', 'current database'
            with encryption = off;
        select @token = [conversation_id]
            from sys.conversation_endpoints
            where [conversation_handle] = @h;
        select @xmlBody = (
            select @procedureName as [name]
            for xml path('procedure'), type);
        send on conversation @h (@xmlBody);
        insert into [AsyncExecResults]
            ([token], [submit_time])
            values
            (@token, getutcdate());
    if @trancount = 0
        commit;
    end try
    begin catch
        declare @error int
            , @message nvarchar(2048)
            , @xactState smallint;
        select @error = ERROR_NUMBER()
            , @message = ERROR_MESSAGE()
            , @xactState = XACT_STATE();
        if @xactState = -1
            rollback;
        if @xactState = 1 and @trancount = 0
            rollback
        if @xactState = 1 and @trancount > 0
            rollback transaction usp_my_procedure_name;

        raiserror(N'Error: %i, %s', 16, 1, @error, @message);
    end catch
end
go

To test our asynchronous execution infrastructure we create a test procedure and invoke it asynchronously. I will create two test procedures, one that simply waits for 5 seconds to simulate a ‘long’ running procedure and one that produces intentionally a primary key violation, to simulate a fault in the asynchronously executed procedure:

create procedure [usp_MyLongRunningProcedure]
as
begin
    waitfor delay '00:00:05';
end
go

create procedure [usp_MyFaultyProcedure]
as
begin
    set nocount on;
    declare @t table (id int primary key);
    insert into @t (id) values (1);
    insert into @t (id) values (1);
end
go


declare @token uniqueidentifier;
exec usp_AsyncExecInvoke N'usp_MyLongRunningProcedure', @token output;
select * from [AsyncExecResults] where [token] = @token;
go

declare @token uniqueidentifier;
exec usp_AsyncExecInvoke N'usp_MyFaultyProcedure', @token output;
select * from [AsyncExecResults] where [token] = @token;
go

waitfor delay '00:00:10';
select * from [AsyncExecResults];
go

Activation Context

If you check the start time of the second asynchronosuly executed procedure you will notice that it started right after the first one finished. This is because we declare a max_queue_readers value of 1 when we set up activation on the queue. This restricts that at most one activated procedure to run at any time, effectively serializing all the asynchronously executed procedures. Whether this is desired or not depends a lot on the actual usage scenario. The limit can be increased as necessary.

If you start playing around with this method of invoking procedures asynchronously you will notice that sometimes the asynchrnously executed procedure is misteriously denied access to other databases or to server scoped objects. When the same procedure is run manually from a query window in SSMS, it executes fine. This is caused by the EXECUTE AS context under which activation occurs. the details are explained in MSDN’s Extending Database Impersonation by Using EXECUTE AS and myself I had covered this subject repeatedly in this blog. The best solution is to simply turn the trustworthy bit on on the database where the activated procedure runs. When this is not desired, or not allowed by your hosting environment, the solution is to code sign the activated procedure: Signing an activated procedure.

Using Service Broker Activation to invoke procedures asynchronously may look daunting at beginning. It sure is significantly more complex than just calling BeginExecuteNonQuery. But what needs to be understood is that this is a reliable way to invoke the procedure. The client is free to disconnect as soon as it commited the call to usp_AsyncExecInvoke. The procedure invoked will run, even if the server is stopped and restarted, even if a mirroring or clustering failover occurs. The server may even crash and be completely rebuilt. As soon as the database is back online, that queue will activate and invoke the asynchronous execution. Such level of reliability is difficult, if not impossible, to guarantee by using a client process.

Update

Andrei Ignat pointed out there is a class in the .Net Framework that deals exactly with this issue: NetworkChange Class. That is definitely a better approach than leveraging the native API through p-Invoke. The MSDN sample also shows how to check for network availability on each interface, when notified of a change.

Original post:

A common problem for applications that use the network stack is to detect when they are connected to the network. It would be ideal if the application was notified when you plugged in your network cable into your laptop, or when it came in range of a WiFi station and has joined a wireless network.

The Windows API has a function for registering for exactly such notifications: NotifyAddrChange. An application can register a wait handle with this function and the handle will be signaled by the operating system every time a change occurs in the IP address to interface mapping table. Technically is true that ‘IP address table change’ does mean strictly that ‘network connectivity has changed’, but in reality the overwhelming majority of IP address table changes can be associated with the network connectivity being gained or lost.

To leverage this API from managed code we have to use p-Invoke. I use a helper class that wraps the registration for notification and handling the event notification in a simple to use package:

    /// <summary>
    /// Raises an event each time a change occurs 
    /// on the system IP address table.
    /// </summary>
    public class NotifyAddressChanges: IDisposable
    {
        #region State fields
        /// <summary>
        /// The OVERLAPPED structure passed to NotifyAddrChange
        /// </summary>
        private NativeOverlapped _overlapped;

        /// <summary>
        /// File handle created  by NotifyAddrChange
        /// </summary>
        private IntPtr _handle;

        /// <summary>
        /// The event signaled by NotifyAddrChange
        /// </summary>
        private AutoResetEvent _eventChanged;

        /// <summary>
        /// The thread pool notification registration
        /// </summary>
        private RegisteredWaitHandle _registered;

        /// <summary>
        /// Submitted state tracking
        /// </summary>
        private volatile int _submitted;

        #endregion

        #region Win32 API declarations

        [DllImport("Iphlpapi.dll", SetLastError = true)]
        private static extern UInt32 NotifyAddrChange(
            ref IntPtr Handle, 
            ref NativeOverlapped overlapped);
        [DllImport("Iphlpapi.dll", SetLastError = true)]
        private static extern bool CancelIPChangeNotify(
            ref NativeOverlapped overlapped);
        #endregion

        #region Public usable methods and events

        /// <summary>
        /// The event raised when a change in the system
        /// IP address table occurs. 
        /// </summary>
        public event EventHandler AddressChanged;


        /// <summary>
        /// CTOR. Initializes the notifications event and submits it
        /// to the ThreadPool. Caller need to call Submit() to enable
        /// system IP address notifications to raise the AddressChange event.
        /// </summary>
        public NotifyAddressChanges()
        {
            _submitted = 0;
            _eventChanged = new AutoResetEvent(false);
            _overlapped.EventHandle = _eventChanged.SafeWaitHandle.DangerousGetHandle();

            _registered = ThreadPool.RegisterWaitForSingleObject(
                _eventChanged,
                new WaitOrTimerCallback(AddressChangedNotification),
                null,
                Timeout.Infinite,
                false);
        }

        /// <summary>
        /// Enables the system IP address notifications to raise the AddressChange event.
        /// </summary>
        public void Submit()
        {
            if (0 == Interlocked.CompareExchange(
                ref _submitted, 1, 0))
            {
                NotifyAddrChange(ref _handle, ref _overlapped);
            }
        }

        #endregion

        #region Callback and event raising

        /// <summary>
        /// IP address change notification callback.
        /// </summary>
        private void AddressChangedNotification(object state, bool timedOut)
        {
            if (1 == Interlocked.CompareExchange(
                ref _submitted, 0, 1))
            {
                EventHandler handler = AddressChanged;
                if (null != handler)
                {
                    try
                    {
                        handler(this, EventArgs.Empty);
                    }
                    catch (Exception)
                    {
                        // silent ignore
                    }
                }
                Submit();
            }
        }
        #endregion

        #region Dispose Logic
        private void Dispose(bool userInvoked)
        {
            if (null != _registered)
            {
                _registered.Unregister(_eventChanged);
            }
            if (1 == Interlocked.CompareExchange(
                ref _submitted, 0, 1))
            {
                CancelIPChangeNotify(ref _overlapped);
            }
        }

        ~NotifyAddressChanges()
        {
            Dispose(false);
        }


        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        #endregion
    }

To use this class, simply create an instance, add an event handler to the AddressChanged event and then call the Submit() method to start getting notifications. The AddressChanged event will be raised each time the system changes an IP address on any of its network interfaces. For example consider a simple form named Form1 to which I added a TextBox named textbox1 (in other words I created a new Windows forms application and I dropped a multiline text box on its surface, without bothering to rename either). Here is how I can hook up the IP address change event to display ‘changed’ on a new line in the text box:

    public partial class Form1 : Form
    {
        private NotifyAddressChanges _notification;

        public Form1()
        {
            InitializeComponent();

            _notification = new NotifyAddressChanges();
            _notification.AddressChanged += 
                new EventHandler(_notification_AddressChanged);
            _notification.Submit();
        }

        void _notification_AddressChanged(object sender, EventArgs e)
        {
            Invoke(new MethodInvoker(delegate ()
            {
                textBox1.AppendText("changed\r\n");
            }));
        }
    }

I can now start my test application and play with the network cable. As I unplug and plug back the cable, the system looses and re-gains the IP address from my base station DHCP server and it signals the NotifyAddrChange registered events. My form gets notified and it adds a “changed” line to the text box. I can also release and renew my DHCP license from the command line running ipconfig /release and ipconfig /renew.

Note that this notification occurs with any change, both on IP4 and IPv6 interfaces. You will be notified if a VPN is connected or disconnected, if a dial-up connection is established and so on and so forth. Being notified does not mean that network is available, nor that is unavailable. It simply means a change occurred. While I could add support to the AddressChanged event to indicate what change, that would needlessly complicate this simple class, because the number of possible changes is actually much bigger than one would expect (think again at all those VPN, dial-up, point-to-point and other connections). My goal with this class was to eliminate the need to periodically wake the application and check if the network is available every minute, based on a timer. I can simply wait for the AddressChanged notification and then I can try to see if I can establish a connection.

I wanted to use a template for writing procedures that behave as intuitively as possible in regard to nested transactions. My goals were:

• The procedure template should wrap all the work done in the procedure in a transaction.
• The procedures should be able to call each other and the calee should nest its transaction inside the outer caller transaction.
• The procedure should only rollback its own work in case of exception, if possible.
• The caller should be able to resume and continue even if the calee rolled back its work.

My solution is to use a either a transactions or a savepoint, depending on the value of @@TRANCOUNT at procedure start. The procedures start a new transaction if no transaction is pending. Otherwise they simply create a savepoint. On exit the procedure commits the transaction they started (if they started one), otherwise they simply exit. On exception, if the transaction is not doomed, the procedure either rolls back (if it started the transaction), or rolls back to the savepoint it created (if calee already provided a transaction).

Because of the use of savepoints this template does not work in all situations, since there are cases like distributed transactions, that cannot be mixed with savepoints. But for the average run of the mill procedures, this template has saved me very well.

create procedure [usp_my_procedure_name]
as
begin
	set nocount on;
	declare @trancount int;
	set @trancount = @@trancount;
	begin try
		if @trancount = 0
			begin transaction
		else
			save transaction usp_my_procedure_name;

		-- Do the actual work here
	
lbexit:
		if @trancount = 0	
			commit;
	end try
	begin catch
		declare @error int, @message varchar(4000), @xstate int;
		select @error = ERROR_NUMBER(), @message = ERROR_MESSAGE(), @xstate = XACT_STATE();
		if @xstate = -1
			rollback;
		if @xstate = 1 and @trancount = 0
			rollback
		if @xstate = 1 and @trancount > 0
			rollback transaction usp_my_procedure_name;

		raiserror ('usp_my_procedure_name: %d: %s', 16, 1, @error, @message) ;
	end catch	
end

Whenever I’m faced with a project in which I have to create a lot of tedious and repeating code I turn to the power of XML and XSLT. Rather than copy/paste the same code over and over again, just to end up with a refactoring and maintenance nightmare, I create an XML definition file and an XSLT transformation. I am then free to add new elements to the XML definition or to change the way the final code is generated from the XSLT transformation. This can be fully integrated with Visual Studio so that the code generation happens at project build time and the environment shows the generated code as a dependency of the XML definition file.

A few examples of how I’m using this code generation via XSLT are:

Data Access Layer

I know this will raise quite a few eyebrows, but I always write my own data access layer from scratch and is generated via XSLT.

Performance Counters

I create all my performance counters objects via XSLT generation, automating the process of defining/installing them and the access to emit and consume the counter values.

Wire Frames

In any project that has networking communication I access the wire format from classes generated via XSLT that take care of serialization and validation.

For example I’ll show how to create a class library that can be added to your project to expose Performance Counters from your application.

MSXSL.EXE

To start you’ll need to download the Command Line Transformation Utility (msxsl.exe). This is a command line tool that takes an XML and an XSLT file as input and produces the result transformation. As a side note I actually use the same technique on non-Windows platforms, but there of course I use the xsltproc utility.

msxsl.exe has to be placed in a convenient location from where it is accessible by Visual Studio. Download the file and place it in Visual Studio’s Common\IDE folder because the build environment has a macro for it: $DevEnvDir.

The Project

Create a new project in Visual Studio. Choose a C# Class Library type project and save it as “PerformanceCounters”. After the project is created, add to it two new files, from menu Project/Add New Item or press Ctrl+Shift+A. For the first file choose an XML file type and name it Counters.xml. For the second one choose an XSLT file type and name it Counters.xslt.

"$(DevEnvDir)msxsl.exe" "$(ProjectDir)Counters.xml" "$(ProjectDir)Counters.xslt"
-o "$(ProjectDir)CountersGenerated.cs"

	  <Compile Include="CountersGenerated.cs">
		  <AutoGen>True</AutoGen>
		  <DependentUpon>Counters.xml</DependentUpon>
	  </Compile>

<?xml version="1.0" encoding="utf-8" ?>
<manager xmlns="http://rusanu.com/Schemas/PerformanceCounters/v1.0"
		clrname="PerformanceCountersManager" namespace="PerformanceCounters">
	<group name="My Counters" clrname="MyCounters" type="SingleInstance">
		<description>Demo Counters for XSLT code generation project</description>
		<counter name="My Count" type="NumberOfItems32" 
                                      clrname="MyCount" hasbase="No">Demo Counter</counter>
	</group>
</manager>

<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" 
	xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:pc="http://rusanu.com/Schemas/PerformanceCounters/v1.0">
	<xsl:output method="text" encoding="utf-8"/>
	<xsl:template match="/">
/* This file was automatically generated during project build.
Do not manually modify this file as updates will be lost.*/
using System;
using System.Diagnostics;

		<xsl:apply-templates/>
</xsl:template>
</xsl:stylesheet>

<xsl:template match="/pc:manager">
namespace <xsl:value-of select="@namespace"/>
{
public partial class <xsl:value-of select="@clrname"/>
{
	<xsl:for-each select="./pc:group[@type='SingleInstance']">
	private static <xsl:value-of select="@clrname"/> __<xsl:value-of select="@clrname"/> = 
		new <xsl:value-of select="@clrname"/>();
	public static <xsl:value-of select="@clrname"/> Default<xsl:value-of select="@clrname"/> {
		get {return __<xsl:value-of select="@clrname"/>; } 
	}
	</xsl:for-each>

	public static void LoadSingleInstance(bool fReadOnly)
	{
		<xsl:for-each select="./pc:group[@type='SingleInstance']">
		__<xsl:value-of select="@clrname"/>.Load(fReadOnly);
		</xsl:for-each>
	}		
	
	public static void DeleteSingleInstance()
	{
		<xsl:for-each select="./pc:group[@type='SingleInstance']">
		<xsl:value-of select="@clrname"/>.Delete();
		</xsl:for-each>
	}
	
	public static void CreateSingleInstance()
	{
		<xsl:for-each select="./pc:group[@type='SingleInstance']">
		<xsl:value-of select="@clrname"/>.Create();
		</xsl:for-each>
	}	
}

<xsl:for-each select="./pc:group">
public partial class <xsl:value-of select="@clrname"/>
{
	private const string __description = 
		@"<xsl:value-of select="./pc:description/text()"/>";
	private const string __category = 
		@"<xsl:value-of select="@name"/>";
	
	<xsl:for-each select="./pc:counter">
 	private PerformanceCounter _<xsl:value-of select="@clrname"/>;
	<xsl:if test="@hasbase='Yes'">
	private PerformanceCounter _<xsl:value-of select="@clrname"/>Base;
	</xsl:if>

	public void Increment<xsl:value-of select="@clrname"/>(long value)
	{
		_<xsl:value-of select="@clrname"/>.IncrementBy(value);
		<xsl:if test="@hasbase='Yes'">
		_<xsl:value-of select="@clrname"/>Base.IncrementBy(1);
		</xsl:if>
	}
	
	public float <xsl:value-of select="@clrname"/> {
		get { return _<xsl:value-of select="@clrname"/>.NextValue(); } 
	}
	
	</xsl:for-each>

	<xsl:if test="@type='MultipleInstance'">
   internal void Load(bool fReadOnly, string instanceName) {
    <xsl:for-each select="./pc:counter">
      _<xsl:value-of select="@clrname"/> = new PerformanceCounter(
      __category,
      @"<xsl:value-of select="@name"/>",
      instanceName,
      fReadOnly);
      <xsl:if test="@hasbase='Yes'">
        _<xsl:value-of select="@clrname"/>Base = new PerformanceCounter(
        __category,
        @"<xsl:value-of select="@name"/>Base",
        instanceName,
        fReadOnly);
      </xsl:if>
    </xsl:for-each>
    }
	</xsl:if>

	<xsl:if test="@type='SingleInstance'">
    internal void Load (bool fReadOnly)
    {
    <xsl:for-each select="./pc:counter">
      _<xsl:value-of select="@clrname"/> = new PerformanceCounter(
      __category,
      @"<xsl:value-of select="@name"/>",
      fReadOnly);
      <xsl:if test="@hasbase='Yes'">
        _<xsl:value-of select="@clrname"/>Base = new PerformanceCounter(
        __category,
        @"<xsl:value-of select="@name"/>Base",
        fReadOnly);
      </xsl:if>    </xsl:for-each>
    }	
	</xsl:if>

   internal static bool Exists
    {
		get {return PerformanceCounterCategory.Exists(__category);}
    }

    internal static void Delete ()
    {
		PerformanceCounterCategory.Delete(__category);
    }

    public static void Create ()
    {
		CounterCreationDataCollection ccdc = new CounterCreationDataCollection();
		<xsl:for-each select="./pc:counter">
		ccdc.Add(new CounterCreationData (
			@"<xsl:value-of select="@name"/>",
			@"<xsl:value-of select="."/>",
			PerformanceCounterType.<xsl:value-of select="@type"/>));
		<xsl:if test="@hasbase='Yes'">
		ccdc.Add(new CounterCreationData (
			@"<xsl:value-of select="@name"/>Base",
			@"Base for <xsl:value-of select="."/>",
			PerformanceCounterType.AverageBase));
		</xsl:if>
		</xsl:for-each>
		PerformanceCounterCategory.Create(
			__category,
			__description,
			PerformanceCounterCategoryType.<xsl:value-of select="@type"/>,
			ccdc);
    }
}
 
</xsl:for-each>
}
</xsl:template>

/* This file was automatically generated during project build.
Do not manually modify this file as updates will be lost.*/
using System;
using System.Diagnostics;


namespace PerformanceCounters
{
public partial class PerformanceCountersManager
{

	private static MyCounters __MyCounters = 
		new MyCounters();
	public static MyCounters DefaultMyCounters {
		get {return __MyCounters; } 
	}


	public static void LoadSingleInstance(bool fReadOnly)
	{

		__MyCounters.Load(fReadOnly);

	}		

	public static void DeleteSingleInstance()
	{
		MyCounters.Delete();

	}

	public static void CreateSingleInstance()
	{
		MyCounters.Create();

	}	
}


public partial class MyCounters
{
	private const string __description = 
		@"Demo Counters for XSLT code generation project";
	private const string __category = 
		@"My Counters";


 	private PerformanceCounter _MyCount;


	public void IncrementMyCount(long value)
	{
		_MyCount.IncrementBy(value);

	}

	public float MyCount {
		get { return _MyCount.NextValue(); } 
	}


    internal void Load (bool fReadOnly)
    {
    
      _MyCount = new PerformanceCounter(
      __category,
      @"My Count",
      fReadOnly);
      
    }	


   internal static bool Exists
    {
		get {return PerformanceCounterCategory.Exists(__category);}
    }

    internal static void Delete ()
    {
		PerformanceCounterCategory.Delete(__category);
    }

    public static void Create ()
    {
		CounterCreationDataCollection ccdc = 
            new CounterCreationDataCollection();

		ccdc.Add(new CounterCreationData (
			@"My Count",
			@"Demo Counter",
			PerformanceCounterType.NumberOfItems32));

		PerformanceCounterCategory.Create(
			__category,
			__description,
			PerformanceCounterCategoryType.SingleInstance,
			ccdc);
    }
}
 

}