PerformanceCounters.cs

using System.Collections.Generic;
using System.Diagnostics;
 
#pragma warning disable CA1416 // Validate platform compatibility
 
namespace Waher.IoTGateway.Svc
{
    public static class PerformanceCounters
    {
        private static readonly string[] categoryNames = GetCategoryNames();
        private static readonly Dictionary<string, CategoryRec> categories = GetCategories();
 
        private static Dictionary<string, CategoryRec> GetCategories()
        {
            Dictionary<string, CategoryRec> Result = [];
 
            foreach (PerformanceCounterCategory Category in PerformanceCounterCategory.GetCategories())
            {
                Result[Category.CategoryName] = new CategoryRec()
                {
                    Category = Category,
                    Counters = null
                };
            }
 
            return Result;
        }
 
        private static string[] GetCategoryNames()
        {
            PerformanceCounterCategory[] Categories = PerformanceCounterCategory.GetCategories();
            int i, c = Categories.Length;
            string[] Names = new string[c];
 
            for (i = 0; i < c; i++)
                Names[i] = Categories[i].CategoryName;
 
            return Names;
        }
 
        private class CategoryRec
        {
            public PerformanceCounterCategory Category;
            public PerformanceCounter[] Counters;
            public string[] InstanceNames;
            public Dictionary<string, InstanceRec> Instances;
            public Dictionary<string, PerformanceCounter> CountersByName;
        }
 
        private class InstanceRec
        {
            public PerformanceCounter[] Counters;
            public Dictionary<string, PerformanceCounter> CountersByName;
        }
 
        public static PerformanceCounterCategory[] Categories => PerformanceCounterCategory.GetCategories();
 
        public static string[] CategoryNames => categoryNames;
 
        public static PerformanceCounterCategory GetCategory(string CategoryName)
        {
            if (categories.TryGetValue(CategoryName, out CategoryRec Rec))
                return Rec.Category;
            else
                return null;
        }
 
        public static PerformanceCounter[] GetCounters(string CategoryName)
        {
            if (!categories.TryGetValue(CategoryName, out CategoryRec Rec))
                return [];
 
            Rec.Counters ??= Rec.Category.GetCounters();
 
            return Rec.Counters;
        }
 
        public static string[] GetCounterNames(string CategoryName)
        {
            PerformanceCounter[] Counters = GetCounters(CategoryName);
            int i, c = Counters.Length;
            string[] Names = new string[c];
 
            for (i = 0; i < c; i++)
                Names[i] = Counters[i].CounterName;
 
            return Names;
        }
 
        public static PerformanceCounter GetCounter(string CategoryName, string CounterName)
        {
            if (!categories.TryGetValue(CategoryName, out CategoryRec Rec))
                return null;
 
            if (Rec.CountersByName is null)
            {
                Rec.Counters ??= Rec.Category.GetCounters();
 
                Dictionary<string, PerformanceCounter> ByName = [];
 
                foreach (PerformanceCounter Counter in Rec.Counters)
                    ByName[Counter.CounterName] = Counter;
 
                Rec.CountersByName = ByName;
            }
 
            if (Rec.CountersByName.TryGetValue(CounterName, out PerformanceCounter Result))
                return Result;
            else
                return null;
        }
 
        public static double? GetCounterValue(string CategoryName, string CounterName)
        {
            PerformanceCounter C = GetCounter(CategoryName, CounterName);
            return C?.NextValue();
        }
 
        public static string[] GetInstanceNames(string CategoryName)
        {
            if (!categories.TryGetValue(CategoryName, out CategoryRec Rec))
                return [];
 
            Rec.InstanceNames ??= Rec.Category.GetInstanceNames();
 
            return Rec.InstanceNames;
        }
 
        public static PerformanceCounter[] GetCounters(string CategoryName, string InstanceName)
        {
            if (!categories.TryGetValue(CategoryName, out CategoryRec CategoryRec))
                return [];
 
            if (CategoryRec.Instances is null)
            {
                Dictionary<string, InstanceRec> Instances = [];
 
                CategoryRec.InstanceNames ??= CategoryRec.Category.GetInstanceNames();
 
                foreach (string Name in CategoryRec.InstanceNames)
                {
                    Instances[Name] = new InstanceRec()
                    {
                        Counters = CategoryRec.Category.GetCounters(Name)
                    };
                }
 
                CategoryRec.Instances = Instances;
            }
 
            if (!CategoryRec.Instances.TryGetValue(InstanceName, out InstanceRec InstanceRec))
                return [];
 
            return InstanceRec.Counters;
        }
 
        public static string[] GetCounterNames(string CategoryName, string InstanceName)
        {
            PerformanceCounter[] Counters = GetCounters(CategoryName, InstanceName);
            int i, c = Counters.Length;
            string[] Names = new string[c];
 
            for (i = 0; i < c; i++)
                Names[i] = Counters[i].CounterName;
 
            return Names;
        }
 
        public static PerformanceCounter GetCounter(string CategoryName, string InstanceName, string CounterName)
        {
            if (!categories.TryGetValue(CategoryName, out CategoryRec CategoryRec))
                return null;
 
            if (CategoryRec.Instances is null)
            {
                Dictionary<string, InstanceRec> Instances = [];
 
                CategoryRec.InstanceNames ??= CategoryRec.Category.GetInstanceNames();
 
                foreach (string Name in CategoryRec.InstanceNames)
                {
                    Instances[Name] = new InstanceRec()
                    {
                        Counters = CategoryRec.Category.GetCounters(Name)
                    };
                }
 
                CategoryRec.Instances = Instances;
            }
 
            if (!CategoryRec.Instances.TryGetValue(InstanceName, out InstanceRec InstanceRec))
                return null;
 
            if (InstanceRec.CountersByName is null)
            {
                InstanceRec.Counters ??= CategoryRec.Category.GetCounters(InstanceName);
 
                Dictionary<string, PerformanceCounter> ByName = [];
 
                foreach (PerformanceCounter Counter in InstanceRec.Counters)
                    ByName[Counter.CounterName] = Counter;
 
                InstanceRec.CountersByName = ByName;
            }
 
            if (InstanceRec.CountersByName.TryGetValue(CounterName, out PerformanceCounter Result))
                return Result;
            else
                return null;
        }
 
        public static double? GetCounterValue(string CategoryName, string InstanceName, string CounterName)
        {
            PerformanceCounter C = GetCounter(CategoryName, InstanceName, CounterName);
            return C?.NextValue();
        }
 
    }
}
 
#pragma warning restore CA1416 // Validate platform compatibility