Okay, So I'm basically trying to create a list of installed Performance Counter Categories, like the one you get in PerfMon. For this I'm using

```
System.Diagnostics.PerformanceCounterCategory.GetCategories()

```

which seems like it works, until you inspect the list, and find out that some are missing. The first one I spotted missing was the ReadyBoost Cache. This was because the project was set to compile on "x86". Changing this to "Any CPU" fixed that issue.

However there are still some that are missing, for instance, one of the test machines has a "Authorization Manager Applications" Category (mine doesn't, and nobody seems to know why, or where it comes from) However, on that machine, that Performance Counter Category shows up in PerfMon, but not when invoking the `GetCategories()` method from C#.

Does anyone know why? Is there a more reliable way to get `PerformanceCounterCategories`? Is this because I'm using .Net? Is there some native API I can use instead?

**EDIT**

I'm sorry, I still don't get it. I've written this code to perhaps better illustrate it:

```
using System;
using System.Diagnostics;
using System.Linq;
using System.Text.RegularExpressions;
using Microsoft.Win32;

namespace PccHack
{
    class Program
    {
        private static readonly Regex Numeric = new Regex(@"^\d+$");
        static void Main(string[] args)
        {
            var pcc1 = PerformanceCounterCategory.GetCategories();
            Console.Out.WriteLine("Getting automatically from the microsoft framework gave {0} results.", pcc1.Count());
            string[] counters;
            using (var regKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009"))
            {
                counters = regKey.GetValue("Counter") as string[];
            }
            var pcc2 = counters.Where(counter => !Numeric.IsMatch(counter)).ToList();
            pcc2.Sort();
            Console.Out.WriteLine("Getting manually from the registry gave {0} results.", pcc2.Count());
            Console.In.ReadLine();
        }
    }
}

```

This now gives me 3236 results. Because it gets all the performance counters in the system. So I figure all I need to do is filter out those that are actually performance counters, leaving me with just categories. However there does not seem to be a constructor for the PerformanceCounter which takes just the name(because this is not unique), nor does there seem to be one which takes the index value. I've discovered a Win32 API named Performance Data Helper, but this doesn't seem to have the functionality I want either. So. If I have a Performance Counter Index, how do I, in C# get the PerformanceCounterCategory, for that index? PerfMon does it, so it must be possible. Is there some way to parse the Index "Magic Number" to figure out which is which?

**EDIT 2**

Okay. So this is doing my head in. The latest version of the code using the three different approaches suggested (.Net / Registry / PowerShell):

```
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using Microsoft.Win32;
using System.Management.Automation;

namespace PccHack
{
    internal class Program
    {
        private static void Main()
        {
            var counterMap = new Dictionary<string, string>();
            using (var regKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009"))
            {
                var counter = regKey.GetValue("Counter") as string[];
                for (var i = 0; i < counter.Count() - 1; i += 2)
                {
                    counterMap.Add(counter[i], counter[i + 1]);
                }
            }

            var pcc1 = PerformanceCounterCategory.GetCategories().Select(o => o.CategoryName).ToList();
            var pcc2 = new List<string>();
            // Get v1 providers
            using (var regKey = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\services"))
            {
                foreach (var subKeyName in regKey.GetSubKeyNames())
                {
                    using (var subKey = regKey.OpenSubKey(subKeyName))
                    {
                        if (!subKey.GetSubKeyNames().Contains("Performance")) continue;
                        using (var perfKey = subKey.OpenSubKey("Performance"))
                        {
                            var blah = (string) perfKey.GetValue("Object List");
                            if (blah != null)
                            {
                                pcc2.AddRange(blah.Split(' ').Select(b => counterMap[b]));
                            }
                        }
                    }
                }
            }
            // Get v2 providers
            using (var regKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\_V2Providers"))
            {
                foreach (var subKeyName in regKey.GetSubKeyNames())
                {
                    using (var subKey = regKey.OpenSubKey(subKeyName))
                    {
                        foreach (var perfKeyName in subKey.GetSubKeyNames())
                        {
                            using (var perfKey = subKey.OpenSubKey(perfKeyName))
                            {
                                var blah = (string) perfKey.GetValue("NeutralName");
                                if (blah != null)
                                {
                                    pcc2.Add(blah);
                                }
                            }
                        }
                    }
                }
            }
            var ps = PowerShell.Create();

            ps.AddCommand("Get-Counter").AddParameter("listSet", "*");
            var pcc3 = ps.Invoke().Select(result => result.Members["CounterSetName"].Value.ToString()).ToList();

            pcc1.Sort();
            pcc2.Sort();
            pcc3.Sort();
            Console.Out.WriteLine("Getting automatically from the microsoft framework gave {0} results.", pcc1.Count());
            Console.Out.WriteLine("Getting manually from the registry gave {0} results.", pcc2.Count());
            Console.Out.WriteLine("Getting from PowerShell gave {0} results.", pcc3.Count());
            Console.In.ReadLine();
        }
    }
}

```

On my machine I get 138 using the .Net framework, 117 by parsing the registry, and 157 by using PowerShell (which is the correct answer).

However depending on the user having installed PowerShell/Windows SDK is not really an option.

Anyone have any ideas at all? Are there some top secret version 3 performance counter categories, hidden somewhere else in the registry, that I need to track down? I've not only run out of ideas to try, I've run out of bad ideas to try as well. Are there any secret command line switches I can use on perfmon, to get it to list all the Categories?