The following example uses the Environment class to display information about the current environment to the console:

using System;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_01
    {
        public static void Main()
        {
            // Command line.
            Console.WriteLine("Command line : " + Environment.CommandLine);

            // OS and CLR version information.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("OS PlatformID : " +
                Environment.OSVersion.Platform);
            Console.WriteLine("OS Major Version : " +
                Environment.OSVersion.Version.Major);
            Console.WriteLine("OS Minor Version : " +
                Environment.OSVersion.Version.Minor);
            Console.WriteLine("CLR Version : " + Environment.Version);

            // User, machine, and domain name information.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("User Name : " + Environment.UserName);
            Console.WriteLine("Domain Name : " + Environment.UserDomainName);
            Console.WriteLine("Machine name : " + Environment.MachineName);

            // Other environment information.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Is interactive? : "
                + Environment.UserInteractive);
            Console.WriteLine("Shutting down? : "
                + Environment.HasShutdownStarted);
            Console.WriteLine("Ticks since startup : "
                + Environment.TickCount);

            // Display the names of all logical drives.
            Console.WriteLine(Environment.NewLine);
            foreach (string s in Environment.GetLogicalDrives())
            {
                Console.WriteLine("Logical drive : " + s);
            }

            // Standard folder information.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Current folder : "
                + Environment.CurrentDirectory);
            Console.WriteLine("System folder : "
                + Environment.SystemDirectory);

// Enumerate all special folders and display them.
            Console.WriteLine(Environment.NewLine);
            foreach (Environment.SpecialFolder s in
                Enum.GetValues(typeof(Environment.SpecialFolder)))
            {
                Console.WriteLine("{0} folder : {1}",
                    s, Environment.GetFolderPath(s));
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

Here is an example that demonstrates how to use all three methods:

using System;
using System.Collections;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_02
    {
        public static void Main()
        {
            // Retrieve a named environment variable.
            Console.WriteLine("Path = " +
                Environment.GetEnvironmentVariable("Path"));
            Console.WriteLine(Environment.NewLine);

            // Substitute the value of named environment variables.
            Console.WriteLine(Environment.ExpandEnvironmentVariables(
                    "The Path on %computername% is %Path%"));
            Console.WriteLine(Environment.NewLine);

            // Retrieve all environment variables targeted at the process and
            // display the values of all that begin with the letter  U.
            IDictionary vars = Environment.GetEnvironmentVariables(
                EnvironmentVariableTarget.Process);

            foreach (string s in vars.Keys)
            {
                if (s.ToUpper().StartsWith("U"))
                {
                    Console.WriteLine(s + " = " + vars[s]);
                }
            }

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use the static members of the EventLog class to write an entry to the event log of the local machine. You must run the example as administrator in order to create the event source—if you do not, a security exception will be thrown.

using System;
using System.Diagnostics;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_03
    {
        public static void Main ()
        {
            // If it does not exist, register an event source for this
            // application against the Application log of the local machine.
            // Trying to register an event source that already exists on the
            // specified machine will throw a System.ArgumentException.
            if (!EventLog.SourceExists("Visual C# Recipes"))
            {
                EventLog.CreateEventSource("Visual C# Recipes",
                    "Application");
            }

            // Write an event to the event log.
            EventLog.WriteEntry(
                "Visual C# Recipes",      // Registered event source
                "A simple test event.",        // Event entry message
                EventLogEntryType.Information, // Event type
                1,                             // Application-specific ID
                0,                             // Application-specific category
                new byte[] {10, 55, 200}       // Event data
            );

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example demonstrates how to use GetValue and SetValue to read from and write to the registry. Every time the example is run, it reads usage information from the registry and displays it to the screen. The example also updates the stored usage information, which you can see the next time you run the example.

using System;
using Microsoft.Win32;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_04
    {
        public static void Main(String[] args)
        {
            // Variables to hold usage information read from registry.
            string lastUser;
            string lastRun;
            int runCount;

            // Read the name of the last user to run the application from the
            // registry. This is stored as the default value of the key and is
            // accessed by not specifying a value name. Cast the returned Object
            // to a string.
            lastUser = (string)Registry.GetValue(
                @"HKEY_CURRENT_USERSoftwareApressVisual C# Recipes",
                "", "Nobody");

// If lastUser is null, it means that the specified registry key
            // does not exist.
            if (lastUser == null)
            {
                // Set initial values for the usage information.
                lastUser = "Nobody";
                lastRun = "Never";
                runCount = 0;
            }
            else
            {
                // Read the last run date and specify a default value of
                // "Never". Cast the returned Object to string.
                lastRun = (string)Registry.GetValue(
                    @"HKEY_CURRENT_USERSoftwareApressVisual C# Recipes",
                    "LastRun", "Never");

                // Read the run count value and specify a default value of
                // 0 (zero). Cast the Object to Int32 and assign to an int.
                runCount = (Int32)Registry.GetValue(
                    @"HKEY_CURRENT_USERSoftwareApressVisual C# Recipes",
                    "RunCount", 0);
            }

            // Display the usage information.
            Console.WriteLine("Last user name: " + lastUser);
            Console.WriteLine("Last run date/time: " + lastRun);
            Console.WriteLine("Previous executions: " + runCount);

            // Update the usage information. It doesn't matter if the registry
            // key exists or not, SetValue will automatically create it.

            // Update the "last user" information with the current username.
            // Specify that this should be stored as the default value
            // for the key by using an empty string as the value name.
            Registry.SetValue(
                @"HKEY_CURRENT_USERSoftwareApressVisual C# Recipes",
                "", Environment.UserName, RegistryValueKind.String);

            // Update the "last run" information with the current date and time.
            // Specify that this should be stored as a string value in the
            // registry.
            Registry.SetValue(
                @"HKEY_CURRENT_USERSoftwareApressVisual C# Recipes",
                "LastRun", DateTime.Now.ToString(), RegistryValueKind.String);

            // Update the usage count information. Specify that this should
            // be stored as an integer value in the registry.
            Registry.SetValue(
                @"HKEY_CURRENT_USERSoftwareApressVisual C# Recipes",
                "RunCount", ++runCount, RegistryValueKind.DWord);

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example takes a single command-line argument and recursively searches the CurrentUser hive of the registry looking for keys with names matching the supplied argument. When the example finds a match, it displays all string type values contained in the key to the console.

using System;
using Microsoft.Win32;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_05
    {
        public static void SearchSubKeys(RegistryKey root, String searchKey)
        {
            try
            {
                // Get the subkeys contained in the current key.
                string[] subkeys = root.GetSubKeyNames();

                // Loop through all subkeys contained in the current key.
                foreach (string keyname in subkeys)
                {
                    try
                    {
                        using (RegistryKey key = root.OpenSubKey(keyname))
                        {

if (keyname == searchKey) PrintKeyValues(key);
                            SearchSubKeys(key, searchKey);
                        }
                    }
                    catch (System.Security.SecurityException)
                    {
                        // Ignore SecurityException for the purpose of the example.
                        // Some subkeys of HKEY_CURRENT_USER are secured and will
                        // throw a SecurityException when opened.
                    }
                }
            }
            catch (UnauthorizedAccessException)
            {
                // Ignore UnauthorizedAccessException for the purpose of the example
                // - this exception is thrown if the user does not have the
                // rights to read part of the registry.
            }

        }

        public static void PrintKeyValues(RegistryKey key)
        {
            // Display the name of the matching subkey and the number of
            // values it contains.
            Console.WriteLine("Registry key found : {0} contains {1} values",
                key.Name, key.ValueCount);

            // Loop through the values and display.
            foreach (string valuename in key.GetValueNames())
            {
                if (key.GetValue(valuename) is String)
                {
                    Console.WriteLine("  Value : {0} = {1}",
                        valuename, key.GetValue(valuename));
                }
            }
        }

        public static void Main(String[] args)
        {
            if (args.Length > 0)
            {
                // Open the CurrentUser base key.
                using (RegistryKey root = Registry.CurrentUser)
                {
                    // Search recursively through the registry for any keys
                    // with the specified name.
                    SearchSubKeys(root, args[0]);
                }
            }

// Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

Running the example using the command Recipe14-05 Environment will display output similar to the following when executed using the command on a machine running Windows 7:

Registry key found : HKEY_CURRENT_USEREnvironment contains 2 values

Value : TEMP = C:UsersAdamAppDataLocalTemp

Value : TMP = C:UsersAdamAppDataLocalTemp

The following Windows service example uses a configurable System.Timers.Timer to write an entry to the Windows event log periodically. You can start, pause, and stop the service using the Services application in the Control Panel.

using System;
using System.Timers;
using System.ServiceProcess;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_06 : ServiceBase
    {
        // A Timer that controls how frequently the example writes to the
        // event log.
        private System.Timers.Timer timer;

public Recipe14_06()
        {
            // Set the ServiceBase.ServiceName property.
            ServiceName = "Recipe 14_06 Service";

            // Configure the level of control available on the service.
            CanStop = true;
            CanPauseAndContinue = true;
            CanHandleSessionChangeEvent = true;

            // Configure the service to log important events to the
            // Application event log automatically.
            AutoLog = true;
        }

        // The method executed when the timer expires and writes an
        // entry to the Application event log.
        private void WriteLogEntry(object sender, ElapsedEventArgs e)
        {
            // Use the EventLog object automatically configured by the
            // ServiceBase class to write to the event log.
            EventLog.WriteEntry("Recipe14_06 Service active : " + e.SignalTime);
        }

        protected override void OnStart(string[] args)
        {
            // Obtain the interval between log entry writes from the first
            // argument. Use 5000 milliseconds by default and enforce a 1000
            // millisecond minimum.
            double interval;

            try
            {
                interval = Double.Parse(args[0]);
                interval = Math.Max(1000, interval);
            }
            catch
            {
                interval = 5000;
            }

            EventLog.WriteEntry(String.Format("Recipe14_06 Service starting. " +
                "Writing log entries every {0} milliseconds...", interval));

            // Create, configure, and start a System.Timers.Timer to
            // periodically call the WriteLogEntry method. The Start
            // and Stop methods of the System.Timers.Timer class
            // make starting, pausing, resuming, and stopping the
            // service straightforward.
            timer = new Timer();
            timer.Interval = interval;

timer.AutoReset = true;
            timer.Elapsed += new ElapsedEventHandler(WriteLogEntry);
            timer.Start();
        }

        protected override void OnStop()
        {
            EventLog.WriteEntry("Recipe14_06 Service stopping...");
            timer.Stop();

            // Free system resources used by the Timer object.
            timer.Dispose();
            timer = null;
        }

        protected override void OnPause()
        {
            if (timer != null)
            {
                EventLog.WriteEntry("Recipe14_06 Service pausing...");
                timer.Stop();
            }
        }

        protected override void OnContinue()
        {
            if (timer != null)
            {
                EventLog.WriteEntry("Recipe14_06 Service resuming...");
                timer.Start();
            }
        }

        protected override void OnSessionChange(SessionChangeDescription change)
        {
            EventLog.WriteEntry("Recipe14_06 Session change..." +
                change.Reason);
        }

        public static void Main()
        {
            // Create an instance of the Recipe14_06 class that will write
            // an entry to the Application event log. Pass the object to the
            // static ServiceBase.Run method.
            ServiceBase.Run(new Recipe14_06());
        }
    }
}

If you want to run multiple services in a single process, you must create an array of ServiceBase objects and pass it to the ServiceBase.Run method. Although service classes have a Main method, you can't execute service code directly or run a service class directly. Recipe 14-7 describes what you must do to install your service before it will execute.

The following example is an installer for the Recipe14_06 Windows service created in recipe 14-6. The sample project contains the code from recipe 14-6 and for the installer class. This is necessary for the service installation to function correctly. To compile the example, you must reference two additional assemblies: System.Configuration.Install.dll and System.ServiceProcess.dll.

using System.Configuration.Install;
using System.ServiceProcess;
using System.ComponentModel;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    [RunInstaller(true)]
    public class Recipe14_07 : Installer
    {
        public Recipe14_07()
        {
            // Instantiate and configure a ServiceProcessInstaller.
            ServiceProcessInstaller ServiceExampleProcess =
                new ServiceProcessInstaller();
            ServiceExampleProcess.Account = ServiceAccount.LocalSystem;

            // Instantiate and configure a ServiceInstaller.
            ServiceInstaller ServiceExampleInstaller =
                new ServiceInstaller();
            ServiceExampleInstaller.DisplayName =
                "Visual C# Recipes Service Example";

ServiceExampleInstaller.ServiceName = "Recipe 14_06 Service";
            ServiceExampleInstaller.StartType = ServiceStartMode.Automatic;

            // Add both the ServiceProcessInstaller and ServiceInstaller to
            // the Installers collection, which is inherited from the
            // Installer base class.
            Installers.Add(ServiceExampleInstaller);
            Installers.Add(ServiceExampleProcess);
        }
    }
}

To install the Recipe14_06 service, build the project, navigate to the directory where Recipe14-07.exe is located (bindebug by default), and execute the command Installutil Recipe14-07.exe—you will need to do this as an administrator. You can then see and control the Visual C# Recipes Service Example service using the Windows Computer Management console. However, even though you have specified a StartType of Automatic, the service is initially installed without being started; you must start the service manually (or restart your computer) before the service will write entries to the event log. Once the service is running, you can view the entries it writes to the Application event log using the Event Viewer application. To uninstall the Recipe14_06 service, add the /u switch to the Installutil command, as follows: Installutil /u Recipe14-07.exe.

The following example class creates a shortcut to Notepad.exe on both the desktop and Start menu of the current user. The example creates both shortcuts by calling the CreateShortcut method and specifying a different destination folder for each shortcut file. This approach makes it possible to create the shortcut file in any of the special folders returned by the WshShell.SpecialFolders property.

using System;
using System.IO;
using IWshRuntimeLibrary;

namespace Apress.VisualCSharpRecipes.Chapter14
{
    class Recipe14_08
    {
        public static void CreateShortcut(string destination)
        {
            // Create a WshShell instance through which to access the
            // functionality of the Windows shell.
            WshShell wshShell = new WshShell();

            // Assemble a fully qualified name that places the Notepad.lnk
            // file in the specified destination folder. You could use the
            // System.Environment.GetFolderPath method to obtain a path, but
            // the WshShell.SpecialFolders method provides access to a wider
            // range of folders. You need to create a temporary object reference
            // to the destination string to satisfy the requirements of the
            // Item method signature.
            object destFolder = (object)destination;
            string fileName = Path.Combine(
                (string)wshShell.SpecialFolders.Item(ref destFolder),
                "Notepad.lnk"
            );

            // Create the shortcut object. Nothing is created in the
            // destination folder until the shortcut is saved.
            IWshShortcut shortcut =
                (IWshShortcut)wshShell.CreateShortcut(fileName);

            // Configure the fully qualified name to the executable.
            // Use the Environment class for simplicity.
            shortcut.TargetPath = Path.Combine(
                Environment.GetFolderPath(Environment.SpecialFolder.System),
                "notepad.exe"
            );

            // Set the working directory to the Personal (My Documents) folder.
            shortcut.WorkingDirectory =
                Environment.GetFolderPath(Environment.SpecialFolder.Personal);

            // Provide a description for the shortcut.
            shortcut.Description = "Notepad Text Editor";

            // Assign a hotkey to the shortcut.
            shortcut.Hotkey = "CTRL+ALT+N";

            // Configure Notepad to always start maximized.
            shortcut.WindowStyle = 3;

// Configure the shortcut to display the first icon in Notepad.exe.
            shortcut.IconLocation = "notepad.exe, 0";

            // Save the configured shortcut file.
            shortcut.Save();
        }

        public static void Main()
        {
            // Create the Notepad shortcut on the desktop.
            CreateShortcut("Desktop");

            // Create the Notepad shortcut on the Windows Start menu of
            // the current user.
            CreateShortcut("StartMenu");

            // Wait to continue.
            Console.WriteLine(Environment.NewLine);
            Console.WriteLine("Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example uses the Microsoft.WindowsAPICodePack.Taskbar.JumpList class to populate the Windows 7 Jump List with three items. The first item opens a command prompt. The second item opens Notepad and displays the Notepad icon in the Jump List. The third item shows how to open another application's file using a Jump List. To compile the example, you must build the Windows API CodePack for .NET Framework and reference the Microsoft.WindowsAPICodePack.dll and Microsoft.WindowsAPICodePack.Shell.dll assemblies.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.IO;
using System.Windows.Forms;

using Microsoft.WindowsAPICodePack.Shell;
using Microsoft.WindowsAPICodePack.Taskbar;

namespace Recipe14_09
{
    public partial class Form1 : Form
    {
        public Form1()
        {

// Call the default intializer.
            InitializeComponent();

            // Register an event handler for when the windows is shown.
            this.Shown += new EventHandler(onWindowShown);
        }

        void onWindowShown(object sender, EventArgs e)
        {
            // Create a new Jump List.
            JumpList jumpList = JumpList.CreateJumpList();

            // Create a user task.
            jumpList.AddUserTasks(
                new JumpListLink("cmd.exe", "Open Command Prompt"));

            // Create a user task with an icon.
            jumpList.AddUserTasks(new JumpListLink("notepad.exe", "Open Notepad")
            {
                IconReference = new IconReference("notepad.exe", 0)
            });

            // Create a user task with a document.
            jumpList.AddUserTasks(
                new JumpListLink(@"C:UsersAdamDesktop	est.txt",

  "Open Text File"));

        }
    }
}

The following example is a Windows Forms application that uses the FileExtension and FileName attributes to search for files in the current user's directories. The user interface, built using the Visual Studio designer, is shown in Figure 14-1. To compile the example, you must build Windows API CodePack for Microsoft .NET Framework and reference the Microsoft.WindowsAPICodePack.dll and Microsoft.WindowsAPICodePack.Shell.dll assemblies.

Figure 14.1. Example search application

The button1_Click method is called when the Search button is pressed. A SearchCondition is created using the values that the user has entered for the file name and extension, and combined using the SearchConditionType.And enumeration value. The search results are read from the ShellSearchFolder and name of each file found is added to the large text box.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.WindowsAPICodePack.Shell;
using Microsoft.WindowsAPICodePack.Shell.PropertySystem;

namespace Recipe14_10
{
    public partial class Recipe14_10 : Form
    {

public Recipe14_10()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Create the leaf condition for the file extension.
            SearchCondition fileExtCondition =
                SearchConditionFactory.CreateLeafCondition(
                SystemProperties.System.FileExtension, textBox1.Text,
                SearchConditionOperation.Equal);

            // Create the leaf condition for the file name.
            SearchCondition fileNameCondition =
                SearchConditionFactory.CreateLeafCondition(
                SystemProperties.System.FileName, textBox2.Text,
                SearchConditionOperation.ValueContains);

            // Combine the two leaf conditions.
            SearchCondition comboCondition =
                SearchConditionFactory.CreateAndOrCondition(
                SearchConditionType.And,
                false, fileExtCondition, fileNameCondition);

            // Create the search folder.
            ShellSearchFolder searchFolder = new ShellSearchFolder(
                comboCondition, (ShellContainer)KnownFolders.UsersFiles);

            // Clear the result text box.
            textBox3.Clear();
            textBox3.AppendText("Processing search results...
");

            // Run through each search result.
            foreach (ShellObject shellObject in searchFolder)
            {
                textBox3.AppendText("Result: "
                    + shellObject.ParsingName + "
");
            }

            // Display a final message to the user.
            textBox3.AppendText("All results processed
");

        }
    }
}

The following example uses the IsConnectedToInternet property of the Microsoft.WindowsAPICodePack.Net.NetworkListManager class, and if the result is positive, gets the list of network connections and writes out the name of those that are connected. To compile the example, you must build Windows API CodePack for Microsoft .NET Framework and reference the Microsoft.WindowsAPICodePack.dll assembly.

using System;
using Microsoft.WindowsAPICodePack.Net;

namespace Recipe14_11
{
    class Recipe14_11
    {
        static void Main(string[] args)
        {
            // Check the internet connection state.
            bool isInternetConnected =
                NetworkListManager.IsConnectedToInternet;

            Console.WriteLine("Machine connected to Internet: {0}",
                isInternetConnected);

            if (isInternetConnected)
            {

// Get the list of all network connections.
                NetworkCollection netCollection =
                    NetworkListManager.GetNetworks(
                       NetworkConnectivityLevels.Connected);

                // Work through the set of connections and write out the
                // name of those that are connected to the internet.
                foreach (Network network in netCollection)
                {
                    if (network.IsConnectedToInternet)
                    {
                        Console.WriteLine(
                            "Connection {0} is connected to the internet",
                            network.Name);
                    }
                }
            }

            Console.WriteLine("
Main method complete. Press Enter.");
            Console.ReadLine();
        }
    }
}

The following example is a Windows Forms application comprising a button and a text area. To compile the example, you must build the Windows API CodePack for Microsoft .NET Framework and reference the Microsoft.WindowsAPICodePack.dll assembly. The user interface is shown in Figure 14-2. We have added an event handler such that the showElevatedTaskRequest method is called when the button is clicked.

Figure 14.2. Windows Forms interface

When the button is clicked, we create a new instance of TaskDialog and configure the basic settings, allowing the user to cancel the dialog and specifying which buttons should be displayed at the bottom of the dialog window. We then create an instance of TaskDialogCommandLink, using sample text as the constructor parameters and add it to the TaskDialog.Controls property. We register an event handler so that we can add a line of text to the text box on the main window when the elevated task button is clicked. The dialog interface is shown in Figure 14-3.

Figure 14.3. Elevated task dialog

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.WindowsAPICodePack.Dialogs;

namespace Recipe14_12
{
    public partial class Form1 : Form
    {

public Form1()
        {
            InitializeComponent();
        }

        void showElevatedTaskRequest(object sender, EventArgs args)
        {
            // Create the TaskDialog and configure the basics.
            TaskDialog taskDialog = new TaskDialog();
            taskDialog.Cancelable = true;
            taskDialog.InstructionText = "This is a Task Dialog";
            taskDialog.StandardButtons =
                TaskDialogStandardButtons.Ok | TaskDialogStandardButtons.Close;


            // Create the control that will represent the elevated task.
            TaskDialogCommandLink commLink = new TaskDialogCommandLink(
                "adminTask", "First Line Of Text", "Second Line of Text");
            commLink.ShowElevationIcon = true;

            // Add the control to the task dialog.
            taskDialog.Controls.Add(commLink);

            // Add an event handler to the command link so that
            // we are notified when the user presses the button.
            commLink.Click += new EventHandler(performElevatedTask);

            // display the task dialog
            taskDialog.Show();
        }

        void performElevatedTask(object sender, EventArgs args)
        {
            textBox1.AppendText("Elevated task button pressed
");
        }
    }
}

The following example creates a new performance counter category called Recipe 14-13 Performance Counters and populates it with three counters: NumberOfItems32, AverageTimer32, and AverageBase.

Two of the counters are closely related. When creating a counter of the AverageTimer32 type, the next counter that is created must be of the AverageBase type. The two counters are used together to report the number of occurrences of an operation over time. We update the AverageBase value to report how many operations have been performed and the AverageTimer32 value to report how many ticks have passed since you last updated the AverageBase value.

Having created the category and counters, we then create three instance of PerformanceCounter and enter a loop so that the counter values are updated randomly.

using System;
using System.Security.Principal;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Recipe14_13
{
    class Recipe14_13
    {

        [DllImport("Kernel32.dll")]
        public static extern void QueryPerformanceCounter(ref long ticks);

        static void Main(string[] args)
        {

            if (!checkElevatedPrivilege())
            {
                Console.WriteLine("This recipe requires administrator rights");
                Console.ReadLine();
                Environment.Exit(1);
            }

            // Define the category name for the performance counters.
            string categoryName = "Recipe 14-13 Performance Counters";

            if (!PerformanceCounterCategory.Exists(categoryName))
            {
                Console.WriteLine("Creating counters.");

                // We need to create the category.
                CounterCreationDataCollection counterCollection
                    = new CounterCreationDataCollection();

                // Create the individual counters.
                CounterCreationData counter1 = new CounterCreationData();
                counter1.CounterType = PerformanceCounterType.NumberOfItems32;
                counter1.CounterName = "Number of Items Counter";
                counter1.CounterHelp = "A sample 32-bit number counter";

                CounterCreationData counter2 = new CounterCreationData();
                counter2.CounterType = PerformanceCounterType.AverageTimer32;

counter2.CounterName = "Average Timer Counter";
                counter2.CounterHelp = "A sample average timer counter";

                CounterCreationData counter3 = new CounterCreationData();
                counter3.CounterType = PerformanceCounterType.AverageBase;
                counter3.CounterName = "Average Base Counter";
                counter3.CounterHelp = "A sample average base counter";

                // Add the counters to the collection.
                counterCollection.Add(counter1);
                counterCollection.Add(counter2);
                counterCollection.Add(counter3);

                // Create the counters category.
                PerformanceCounterCategory.Create(categoryName,
                    "Category for Visual C# Recipe 14-13",
                    PerformanceCounterCategoryType.SingleInstance,
                    counterCollection);
            }
            else
            {
                Console.WriteLine("Counters already exist.");
            }

            // Open the counters for reading.
            PerformanceCounter perfCounter1 = new PerformanceCounter();
            perfCounter1.CategoryName = categoryName;
            perfCounter1.CounterName = "Number of Items Counter";
            perfCounter1.ReadOnly = false;

            PerformanceCounter perfCounter2 = new PerformanceCounter();
            perfCounter2.CategoryName = categoryName;
            perfCounter2.CounterName = "Average Timer Counter";
            perfCounter2.ReadOnly = false;

            PerformanceCounter perfCounter3 = new PerformanceCounter();
            perfCounter3.CategoryName = categoryName;
            perfCounter3.CounterName = "Average Base Counter";
            perfCounter3.ReadOnly = false;

            // Create a number generator to produce values.
            Random numberGenerator = new Random();

            // Enter a loop to update the values every second.
            long startTickCount = 0, endTickCount = 0;
            while (true)
            {
                // Get the high-frequency tick count.
                QueryPerformanceCounter(ref startTickCount);
                // put the thread to sleep for up to a second
                System.Threading.Thread.Sleep(numberGenerator.Next(1000));

// Get the high-frequency tick count again.
                QueryPerformanceCounter(ref endTickCount);

                Console.WriteLine("Updating counter values.");
                perfCounter1.Increment();
                perfCounter2.IncrementBy(endTickCount - startTickCount);
                perfCounter3.Increment();
            }
        }

        static bool checkElevatedPrivilege()
        {
            WindowsIdentity winIdentity = WindowsIdentity.GetCurrent();
            WindowsPrincipal winPrincipal = new WindowsPrincipal(winIdentity);
            return winPrincipal.IsInRole(WindowsBuiltInRole.Administrator);
        }
    }
}

The following example reads values from the counters that we created in the previous recipe. In the previous recipe, we noted that two of the counters were related. When reading data from such a pair, you only read values from the first counter—Windows returns the calculated value (the number of operations/second). If you need to access the underlying data, then consult the .NET documentation for details of the System.Diagnostics.CounterSample class, instances of which can be obtained from the PerformanceCounter.NextSample method. You must run the previous example at the same time as this example; otherwise, you will only be able to read zeros from the counters, as no updates will be generated.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Security.Principal;

namespace Recipe14_14
{
    class Recipe14_14
    {
        static void Main(string[] args)
        {

            if (!checkElevatedPrivilege())
            {
                Console.WriteLine("This recipe requires administrator rights");
                Console.ReadLine();
                Environment.Exit(1);
            }

            // Define the category name for the performance counters.
            string categoryName = "Recipe 14-13 Performance Counters";

            // Open the counters for reading.
            PerformanceCounter perfCounter1 = new PerformanceCounter();
            perfCounter1.CategoryName = categoryName;
            perfCounter1.CounterName = "Number of Items Counter";

            PerformanceCounter perfCounter2 = new PerformanceCounter();
            perfCounter2.CategoryName = categoryName;
            perfCounter2.CounterName = "Average Timer Counter";
            while (true)
            {
                float value1 = perfCounter1.NextValue();
                Console.WriteLine("Value for first counter: {0}", value1);
                float value2 = perfCounter2.NextValue();
                Console.WriteLine("Value for second counter: {0}", value2);

// Put the thread to sleep for a second.
                System.Threading.Thread.Sleep(1000);
            }
        }

        static bool checkElevatedPrivilege()
        {
            WindowsIdentity winIdentity = WindowsIdentity.GetCurrent();
            WindowsPrincipal winPrincipal = new WindowsPrincipal(winIdentity);
            return winPrincipal.IsInRole(WindowsBuiltInRole.Administrator);
        }
    }
}

In the following example, the performNormalTasks method represents normal operation and the performElevatedTasks method represents the tasks that require elevation. When the example is started, the Main method is called and the arguments are checked to determine which of these methods should be called.

The checkElevatedPrivilege method uses the System. Security.Principal.WindowsIdentity and System.Security.Principal.WindowsPrincipal classes to establish our privilege level. We don't want to start a new process if the application has been started with elevated privileges, so the performNormalTasks method checks the elevation level before calling the startElevatedInstance method.

Starting the example normally will result in an elevated process being started with the elevated argument. The new process will perform the elevated task and then exit. Starting the process as administrator will result in the elevated tasks being performed within the same process.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Security.Principal;
using System.Diagnostics;


namespace Recipe14_15
{
    class Program
    {
        static void Main(string[] args)
        {
            // Check to see if the first argument is "elevated".
            if (args.Length > 0 && args[0] == "elevated")
            {
                Console.WriteLine("Started with command line argument");
                performElevatedTasks();
            }
            else
            {
                Console.WriteLine("Started without command line argument");
                performNormalTasks();
            }
        }

        static void performNormalTasks()
        {

            Console.WriteLine("Press return to perform elevated tasks");
            Console.ReadLine();
            // Check to see if we have been started with elevated privileges.
            if (checkElevatedPrivilege())
            {

// We already have privileges - perform the tasks.
                performElevatedTasks();
            }
            else
            {
                // We need to start an elevated instance.
                startElevatedInstance();
            }
        }

        static void performElevatedTasks()
        {
            // Check to see that we have elevated privileges.
            if (checkElevatedPrivilege())
            {
                // perform the elevated task
                Console.WriteLine("Elevated tasks performed");
            }
            else
            {
                // We are not able to perform the elevated tasks.
                Console.WriteLine("Cannot perform elevated tasks");
            }
            Console.WriteLine("Press return to exit");
            Console.ReadLine();
        }

        static bool checkElevatedPrivilege()
        {
            WindowsIdentity winIdentity = WindowsIdentity.GetCurrent();
            WindowsPrincipal winPrincipal = new WindowsPrincipal(winIdentity);
            return winPrincipal.IsInRole (WindowsBuiltInRole.Administrator);
        }

        static void startElevatedInstance()
        {
            ProcessStartInfo procstartinf = new ProcessStartInfo("Recipe14-15.exe");
            procstartinf.Arguments = "elevated";
            procstartinf.Verb = "runas";
            Process.Start(procstartinf).WaitForExit();
        }
    }
}