/// <summary> /// Gets the or create counter category. /// </summary> /// <param name="categoryInfo">The category information.</param> /// <param name="counters">The counters.</param> /// <returns>PerformanceCounterCategory.</returns> private static PerformanceCounterCategory GetOrCreateCounterCategory( PerformanceCounterCategoryInfo categoryInfo, CounterCreationData[] counters) { var creationPending = true; var categoryExists = false; var categoryName = categoryInfo.CategoryName; var counterNames = new HashSet<string>(counters.Select(info => info.CounterName)); PerformanceCounterCategory category = null; if (PerformanceCounterCategory.Exists(categoryName)) { categoryExists = true; category = new PerformanceCounterCategory(categoryName); var counterList = category.GetCounters(); if (category.CategoryType == categoryInfo.CategoryType && counterList.Length == counterNames.Count) { creationPending = counterList.Any(x => !counterNames.Contains(x.CounterName)); } } if (!creationPending) return category; if (categoryExists) PerformanceCounterCategory.Delete(categoryName); var counterCollection = new CounterCreationDataCollection(counters); category = PerformanceCounterCategory.Create( categoryInfo.CategoryName, categoryInfo.CategoryHelp, categoryInfo.CategoryType, counterCollection); return category; }
private void OptionsFormVisibleChanged(object sender, EventArgs e) { if (Visible == false) { return; } textBoxPhoneIp.Text = _options.PhoneIp; textBoxPhonePort.Text = _options.PhonePort.ToString(); textBoxMyipHost.Text = _options.MyipHost; textBoxMyipPort.Text = _options.MyipPort.ToString(); textBoxMyipUrl.Text = _options.MyipUrl; textBoxMyipInterval.Text = _options.MyipInterval.ToString(); textBoxNpFile.Text = _options.NpFile; checkBoxSendNp.Checked = _options.SendNp; // set listBoxNetworkInterface listBoxNetworkInterface.Items.Clear(); var instanceNames = new PerformanceCounterCategory("Network Interface").GetInstanceNames(); listBoxNetworkInterface.Items.AddRange(instanceNames); if (instanceNames.Length > 0) { listBoxNetworkInterface.SelectedIndex = 0; } if (instanceNames.Length > _options.NetIndex) { listBoxNetworkInterface.SelectedIndex = _options.NetIndex; } }
public void Configure() { var counters = CounterList; counters.Add("Processor Load", "Processor", "% Processor Time", "_Total"); counters.Add("Memory Usage", "Memory", "% Committed Bytes In Use"); counters.Add("IIS Requests/sec", "Web Service", "Total Method Requests/sec", "_Total"); //this one is very unreliable counters.Add("ASP.NET Request/Sec", "ASP.NET Applications", "Requests/Sec", "__Total__"); counters.Add("ASP.NET Current Requests", "ASP.NET", "Requests Current"); counters.Add("ASP.NET Queued Requests", "ASP.NET", "Requests Queued"); counters.Add("ASP.NET Requests Wait Time", "ASP.NET", "Request Wait Time"); PerformanceCounterCategory category = new PerformanceCounterCategory("Network Interface"); String[] instanceNames = category.GetInstanceNames(); foreach (string name in instanceNames) { counters.Add("Net IO Total: " + name, "Network Interface", "Bytes Total/sec", name); counters.Add("Net IO Received: " + name, "Network Interface", "Bytes Received/sec", name); counters.Add("Net IO Sent: " + name, "Network Interface", "Bytes Sent/sec", name); } }
public IEnumerable<string> GetInstances(string category) { var counterCategory = new PerformanceCounterCategory(category); var instances = counterCategory.GetInstanceNames(); return instances; }
public NetworkIO() { _dict = new Dictionary<string, double>(); PerformanceCounterCategory category = new PerformanceCounterCategory("Network Interface"); var interfaces = GetNetworkInterfaces(); var categoryList = category.GetInstanceNames(); foreach (string name in categoryList) { var nicName = name.Replace('[', '(').Replace(']', ')'); if (!interfaces.Select(t => t.Description).Contains(nicName) || nicName.ToLower().Contains("loopback")) continue; try { NetworkAdapter adapter = new NetworkAdapter(interfaces.First(t => t.Description.Contains(nicName)).Name); adapter.NetworkBytesReceived = new PerformanceCounter("Network Interface", "Bytes Received/sec", name); adapter.NetworkBytesSend = new PerformanceCounter("Network Interface", "Bytes Sent/sec", name); _adappterList.Add(adapter); // Add it to ArrayList adapter } catch { //pass } } }
public static List<PerformanceCounterCategoryModel> GetPerformanceCounterCategories() { var counterCategories = new List<PerformanceCounterCategoryModel>(); PerformanceCounterCategory.GetCategories().ToList().ForEach((i) => counterCategories.Add(new PerformanceCounterCategoryModel { Name = i.CategoryName }) ); counterCategories = counterCategories.OrderBy(x => x.Name).ToList(); counterCategories.ForEach((i) => { try { var cat = new PerformanceCounterCategory(i.Name); var instances = cat.GetInstanceNames(); if(instances.Length > 0) { foreach(var instance in instances) { i.Instances.Add(instance); } } } catch { // sometimes this freaks out when an instance can't be examined } }); return counterCategories; }
public PerfCounterMBean(string perfObjectName, string perfInstanceName, IEnumerable<string> perfCounterNames, bool useProcessInstanceName, bool useAllCounters) { _perfObjectName = perfObjectName; if (useProcessInstanceName) { Process p = Process.GetCurrentProcess(); _perfInstanceName = p.ProcessName; } else { _perfInstanceName = perfInstanceName ?? ""; } _category = new PerformanceCounterCategory(_perfObjectName); if (useAllCounters) { foreach (PerformanceCounter counter in _category.GetCounters(_perfInstanceName)) { _counters[counter.CounterName] = counter; } } else if (perfCounterNames != null) { foreach (string counterName in perfCounterNames) { PerformanceCounter counter; counter = new PerformanceCounter(_perfObjectName, counterName, _perfInstanceName, true); _counters.Add(counterName, counter); } } }
private void TryToInitializeCounters() { if (!countersInitialized) { PerformanceCounterCategory category = new PerformanceCounterCategory(".NET CLR Networking 4.0.0.0"); var instanceNames = category.GetInstanceNames().Where(i => i.Contains(string.Format("p{0}", pid))); if (instanceNames.Any()) { bytesSentPerformanceCounter = new PerformanceCounter(); bytesSentPerformanceCounter.CategoryName = ".NET CLR Networking 4.0.0.0"; bytesSentPerformanceCounter.CounterName = "Bytes Sent"; bytesSentPerformanceCounter.InstanceName = instanceNames.First(); bytesSentPerformanceCounter.ReadOnly = true; bytesReceivedPerformanceCounter = new PerformanceCounter(); bytesReceivedPerformanceCounter.CategoryName = ".NET CLR Networking 4.0.0.0"; bytesReceivedPerformanceCounter.CounterName = "Bytes Received"; bytesReceivedPerformanceCounter.InstanceName = instanceNames.First(); bytesReceivedPerformanceCounter.ReadOnly = true; countersInitialized = true; } } }
public void Enabling_performance_counters_should_result_in_performance_counters_being_created() { //This will delete an recreate the categories. PerformanceCategoryCreator.CreateCategories(); var outboundIntances = new PerformanceCounterCategory(OutboundPerfomanceCounters.CATEGORY).GetInstanceNames(); var inboundIntances = new PerformanceCounterCategory(InboundPerfomanceCounters.CATEGORY).GetInstanceNames(); Assert.Empty(outboundIntances); Assert.Empty(inboundIntances); var hostConfiguration = new RhinoQueuesHostConfiguration() .EnablePerformanceCounters() .Bus("rhino.queues://localhost/test_queue2", "test"); container = new WindsorContainer(); new RhinoServiceBusConfiguration() .UseConfiguration(hostConfiguration.ToBusConfiguration()) .UseCastleWindsor(container) .Configure(); bus = container.Resolve<IStartableServiceBus>(); bus.Start(); using (var tx = new TransactionScope()) { bus.Send(bus.Endpoint, "test message."); tx.Complete(); } outboundIntances = new PerformanceCounterCategory(OutboundPerfomanceCounters.CATEGORY).GetInstanceNames(); inboundIntances = new PerformanceCounterCategory(InboundPerfomanceCounters.CATEGORY).GetInstanceNames(); Assert.NotEmpty(outboundIntances.Where(name => name.Contains("test_queue2"))); Assert.NotEmpty(inboundIntances.Where(name => name.Contains("test_queue2"))); }
public void WatchCpuAndMemory() { var pc = new PerformanceCounter("Processor Information", "% Processor Time"); var cat = new PerformanceCounterCategory("Processor Information"); var cpuInstances = cat.GetInstanceNames(); var cpus = new Dictionary<string, CounterSample>(); var memoryCounter = new PerformanceCounter("Memory", "Available MBytes"); foreach (var s in cpuInstances) { pc.InstanceName = s; cpus.Add(s, pc.NextSample()); } var t = DateTime.Now; while (t.AddMinutes(1) > DateTime.Now) { Trace.WriteLine(string.Format("Memory:{0}MB", memoryCounter.NextValue())); foreach (var s in cpuInstances) { pc.InstanceName = s; Trace.WriteLine(string.Format("CPU:{0} - {1:f}", s, Calculate(cpus[s], pc.NextSample()))); cpus[s] = pc.NextSample(); } //Trace.Flush(); System.Threading.Thread.Sleep(1000); } }
public static bool TryGetInstanceName(Process process, out string instanceName) { try { PerformanceCounterCategory processCategory = new PerformanceCounterCategory(CategoryName); string[] instanceNames = processCategory.GetInstanceNames(); foreach (string name in instanceNames) { if (name.StartsWith(process.ProcessName)) { using ( PerformanceCounter processIdCounter = new PerformanceCounter(CategoryName, ProcessIdCounter, name, true)) { if (process.Id == (int) processIdCounter.RawValue) { instanceName = name; return true; } } } } instanceName = null; return false; } catch { instanceName = null; return false; } }
private static void EnumerateCountersFor(string category) { var sb = new StringBuilder(); var counterCategory = new PerformanceCounterCategory(category); if(counterCategory.CategoryType == PerformanceCounterCategoryType.SingleInstance) { foreach (var counter in counterCategory.GetCounters()) { sb.AppendLine(string.Format("{0}:{1}", category, counter.CounterName)); } } else { foreach (var counterInstance in counterCategory.GetInstanceNames()) { foreach (var counter in counterCategory.GetCounters(counterInstance)) { sb.AppendLine(string.Format("{0}:{1}:{2}", counterInstance, category, counter.CounterName)); } } } Console.WriteLine(sb.ToString()); }
// Try to discover GUID from buggy Performance Monitor instance names. // Note: Discover drive GUID comparing free space is uggly, but MS gave me no choice. static LogicalDisk() { // ===== WMI ===== Win32_Volume[] vols = Win32_Volume.GetAllVolumes(); // Free megabytes and volume GUID relation Dictionary<ulong, Guid> wmiFree = new Dictionary<ulong, Guid>(vols.Length); // Volume name and volume GUID relation Dictionary<string, Guid> wmiName = new Dictionary<string, Guid>(vols.Length); foreach (Win32_Volume v in vols) { if (v.Automount && v.DriveType == System.IO.DriveType.Fixed) { if (v.IsMounted) { wmiName.Add(v.Name.TrimEnd('\\'), v.DeviceGuid); } else { wmiFree.Add(v.FreeSpace / MB_MULT, v.DeviceGuid); } } } perfMonGuid = new Dictionary<Guid, string>(wmiFree.Count + wmiName.Count); // ===== PERFORMANCE MONITOR ====== PerformanceCounterCategory perfCat = new PerformanceCounterCategory( Localization.GetName(COUNTER_LOGICAL_DISK)); // TODO: Find a faster way to get instance names. string[] instances = perfCat.GetInstanceNames(); // Free megabytes and Performance Monitor instance name Dictionary<ulong, string> perfFree = new Dictionary<ulong, string>(instances.Length); foreach (string item in instances) { if (item == "_Total") continue; Guid volId = Guid.Empty; if (wmiName.TryGetValue(item, out volId)) { perfMonGuid.Add(volId, item); } else { PerformanceCounter p = new PerformanceCounter( Localization.GetName(COUNTER_LOGICAL_DISK), Localization.GetName(COUNTER_FREE_MB), item); perfFree.Add((ulong)p.RawValue, item); p.Close(); p.Dispose(); } } ulong[] warray = new ulong[wmiFree.Count]; ulong[] pmarray = new ulong[perfFree.Count]; if (warray.Length != pmarray.Length) throw new NotSupportedException(MSG_EXCEPTION); wmiFree.Keys.CopyTo(warray, 0); perfFree.Keys.CopyTo(pmarray, 0); Array.Sort<ulong>(warray); Array.Sort<ulong>(pmarray); for (int i = 0; i < warray.Length; i++) { perfMonGuid.Add(wmiFree[warray[i]], perfFree[pmarray[i]]); } }
/// <summary> /// Gets the partition label of the system partition (e.g. "C:") /// </summary> /// <returns>Returns null if the system partition cannot be identified or located</returns> public static string GetSystemPartitionLabel() { try { string systemPartition = Path.GetPathRoot(Environment.SystemDirectory); if (!string.IsNullOrEmpty(systemPartition)) { systemPartition = systemPartition.Replace(@"\", ""); var perfCategory = new System.Diagnostics.PerformanceCounterCategory("PhysicalDisk"); string[] instanceNames = perfCategory.GetInstanceNames(); foreach (string name in instanceNames) { if (name.IndexOf(systemPartition) > 0) { return(name); } } } return(null); } catch { throw; } }
/// <summary> /// Returns a collection of standard values for the data type this type converter is designed for when provided with a format context. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext"/> that provides a format context that can be used to extract additional information about the environment from which this converter is invoked. This parameter or properties of this parameter can be null.</param> /// <returns> /// A <see cref="T:System.ComponentModel.TypeConverter.StandardValuesCollection"/> that holds a standard set of valid values, or null if the data type does not support a standard set of values. /// </returns> public override System.ComponentModel.TypeConverter.StandardValuesCollection GetStandardValues(ITypeDescriptorContext context) { INuGenCounter counter = (context == null) ? null : (context.Instance as INuGenCounter); string machineName = "."; string categoryName = string.Empty; if (counter != null) { machineName = counter.MachineName; categoryName = counter.CategoryName; } try { PerformanceCounterCategory category = new PerformanceCounterCategory(categoryName, machineName); string[] instances = category.GetInstanceNames(); Array.Sort(instances, Comparer.Default); return new TypeConverter.StandardValuesCollection(instances); } catch { } return null; }
static PerfCounters() { var p = Process.GetCurrentProcess(); ProcessName = p.ProcessName; ProcessId = p.Id; CategoryProcess = new PerformanceCounterCategory("Process"); ProcessorTime = new PerformanceCounter("Process", "% Processor Time", ProcessName); UserTime = new PerformanceCounter("Process", "% User Time", ProcessName); PrivateBytes = new PerformanceCounter("Process", "Private Bytes", ProcessName); VirtualBytes = new PerformanceCounter("Process", "Virtual Bytes", ProcessName); VirtualBytesPeak = new PerformanceCounter("Process", "Virtual Bytes Peak", ProcessName); WorkingSet = new PerformanceCounter("Process", "Working Set", ProcessName); WorkingSetPeak = new PerformanceCounter("Process", "Working Set Peak", ProcessName); HandleCount = new PerformanceCounter("Process", "Handle Count", ProcessName); CategoryNetClrMemory = new PerformanceCounterCategory(".NET CLR Memory"); ClrBytesInAllHeaps = new PerformanceCounter(".NET CLR Memory", "# Bytes in all Heaps", ProcessName); ClrTimeInGC = new PerformanceCounter(".NET CLR Memory", "% Time in GC", ProcessName); ClrGen0Collections = new PerformanceCounter(".NET CLR Memory", "# Gen 0 Collections", p.ProcessName, true); ClrGen1Collections = new PerformanceCounter(".NET CLR Memory", "# Gen 1 Collections", p.ProcessName, true); ClrGen2Collections = new PerformanceCounter(".NET CLR Memory", "# Gen 1 Collections", p.ProcessName, true); }
private static void SetVariables(int eth = 0) { performanceCounterCategory = new PerformanceCounterCategory("Network Interface"); instance = performanceCounterCategory.GetInstanceNames()[eth]; // 1st NIC ! performanceCounterSent = new PerformanceCounter("Network Interface", "Bytes Sent/sec", instance); performanceCounterReceived = new PerformanceCounter("Network Interface", "Bytes Received/sec", instance); }
public static void Initialize() { if (Log.IsInfoEnabled) { Log.InfoFormat("Start to initialize {0} performance counters", CategoryName); } if (!IsUserAdmin()) { Log.Info("User has no Admin rights. CustomAuthResultCounters initialization skipped"); return; } try { PerformanceCounterCategory = GetOrCreateCategory(CategoryName, GetCounterCreationData()); } catch (Exception e) { Log.WarnFormat("Exception happened during counters initialization. Excpetion {0}", e); return; } if (Log.IsInfoEnabled) { Log.InfoFormat("{0} performance counters successfully initialized", CategoryName); } }
public ICollection GetPerfCounters(string category) { var r = new ArrayList(); var cat = new PerformanceCounterCategory(category); foreach (var counter in cat.GetCounters()) { r.Add(new DictionaryEntry(counter.CounterName, counter.NextValue())); } return r; }
public void ShouldInstallFirstCategory() { PerformanceCountersInstaller installer = GetCommandLineConfiguredInstaller(firstCategory); DoCommitInstall(installer); PerformanceCounterCategory category = new PerformanceCounterCategory(firstCategory); AssertCategoryIsCorrect(category); }
public static PerformanceCounterCategory GetPerformanceCounterCategory(string category, string machineName) { PerformanceCounterCategory cat; if (string.IsNullOrEmpty(machineName)) cat = new PerformanceCounterCategory(category); else cat = new PerformanceCounterCategory(category, machineName); return cat; }
public void DotNetClrDataCategory() { var category = new PerformanceCounterCategory(".NET CLR Data"); Assert.IsNotNull(category); var counters = category.GetCounters(); Assert.IsNotNull(counters); Assert.IsTrue(counters.Any()); foreach(var counter in counters) { Console.WriteLine("Counter={0}, InstanceName={1}", counter.CounterName, counter.InstanceName); } }
public MemoryPlugin(ApplicationConfiguration config) { using (Profiler.Step("Memory Init")) { _config = _config; var category = new PerformanceCounterCategory("Memory"); _counters = category.GetCounters(); } }
private static void EnumerateCountersFor(string category, string instance) { var sb = new StringBuilder(); var counterCategory = new PerformanceCounterCategory(category); foreach (var counter in counterCategory.GetCounters(instance)) { sb.AppendLine(string.Format("{0}:{1}:{2}", instance, category, counter.CounterName)); } Console.WriteLine(sb.ToString()); }
public object DoCheck() { PerformanceCounterCategory category = new PerformanceCounterCategory("ASP.NET"); IDictionary<string, object> values = new Dictionary<string, object>(); foreach (PerformanceCounter counter in category.GetCounters()) { values.Add(counter.CounterName, counter.NextValue()); } return values; }
private void Initialize() { var category = new PerformanceCounterCategory(Category); var instances = category.GetInstanceNames(); foreach (var instanceName in instances) { _counters.Add(new PerformanceCounter(Category, CounterName, instanceName)); } PerformanceCounterHelper.InitializeCounters(_counters.ToArray()); }
public static List<string> GetCountersForCategory(string category, string instance) { var cat = new PerformanceCounterCategory(category); var counters = string.IsNullOrEmpty(instance) ? cat.GetCounters() : cat.GetCounters(instance); var ret = new List<string>(); foreach(var counter in counters) { ret.Add(counter.CounterName); } return ret; }
/// <summary> /// Re-creates the _counters list if the number /// of valid PerformanceCounters has changed. /// </summary> private void RefreshCounters() { PerformanceCounterCategory cat = new PerformanceCounterCategory("Network Interface"); if (cat.GetInstanceNames().Length != _counters.Count) { _counters.Clear(); foreach (string instance in cat.GetInstanceNames()) { _counters.Add(new PerformanceCounter("Network Interface", _counterName, instance)); } } }
static PerformanceSampler() { if (!PerformanceCounterCategory.Exists(PerformanceCounters.CategoryName)) { logger.WarnFormat("The Performance Counters For Category {0} are not installed. Performance sampling will be disabled.", PerformanceCounters.CategoryName); _disablePerformanceSampling = true; } else { category = new PerformanceCounterCategory(PerformanceCounters.CategoryName); } }
public IEnumerable<string> GetCounterNames(string category) { var cat = new PerformanceCounterCategory(category); var instances = cat.CategoryType == PerformanceCounterCategoryType.SingleInstance ? new string[] { null } : cat.GetInstanceNames(); foreach (var instance in instances) { var coutners = string.IsNullOrEmpty(instance) ? cat.GetCounters().Select(x => x.CounterName) : cat.GetCounters(instance).Select(x => x.CounterName); foreach (var counter in coutners) { yield return counter; } } }
public CpuPlugin(ApplicationConfiguration config) { using (Profiler.Step("CPU Init")) { _config = config; var category = new PerformanceCounterCategory("Processor"); _counters = (from name in category.GetInstanceNames() select category.GetCounters(name)) .SelectMany(x => x) .ToArray(); } }
public DriveIdleMonitor() { drivesMonitored = new List <string>(); PerformanceCounterCategory cat = new System.Diagnostics.PerformanceCounterCategory("PhysicalDisk"); string[] instNames = cat.GetInstanceNames(); if (instNames.Length - 1 > 0) { timers = new DefaultTimer[instNames.Length - 1]; diskIdleTime = new PerformanceCounter[instNames.Length - 1]; } int i = 0; foreach (string inst in instNames) { if (inst.Equals("_Total")) { continue; } timers[i] = new DefaultTimer(); diskIdleTime[i] = new PerformanceCounter("PhysicalDisk", "% Idle Time", inst); diskIdleTime[i].NextValue(); timers[i].Interval = 3000; timers[i].Tick += new EventHandler(timer_Tick); timers[i].Tag = inst; timers[i].start(); char[] delimiterChars = { ' ' }; string[] drives = inst.Split(delimiterChars); foreach (String drive in drives) { int val; bool isInt = int.TryParse(drive, out val); if (!isInt) { drivesMonitored.Add(drive); } } i++; } }
public void GetDriveStats() { DriveInfo[] drives = DriveInfo.GetDrives(); var cat = new System.Diagnostics.PerformanceCounterCategory("PhysicalDisk"); var instNames = cat.GetInstanceNames(); PerformanceCounter diskCounter = new PerformanceCounter { CategoryName = "PhysicalDisk" }; foreach (DriveInfo drive in drives) { //There are more attributes you can use. //Check the MSDN link for a complete example. if (drive.IsReady && drive.DriveType == DriveType.Fixed) { BaseDisks disk = null; if (this.Disks != null) { disk = this.Disks.Find(x => x.DiskLetter == drive.Name); } if (disk == null) { disk = new BaseDisks(this.ServerID); this.Disks.Add(disk); } disk.DiskLetter = drive.Name; disk.FreeDiskSpace = ((drive.AvailableFreeSpace / 1024) / 1024); disk.TotalDiskSize = ((drive.TotalSize / 1024) / 1024); diskCounter.CounterName = "Disk Read Bytes/sec"; diskCounter.InstanceName = instNames.Where(x => x.Contains(drive.Name[0])).First(); diskCounter.NextValue(); System.Threading.Thread.Sleep(500); disk.ReadBytesPerSec = diskCounter.NextValue(); diskCounter.CounterName = "Disk Write Bytes/sec"; diskCounter.InstanceName = instNames.Where(x => x.Contains(drive.Name[0])).First(); diskCounter.NextValue(); System.Threading.Thread.Sleep(500); disk.WriteBytesPerSec = diskCounter.NextValue(); } } }
public StatDiskActivity() { sessionID = DateTime.Now.Ticks; historyIndex = -1; historyIndexHour = -1; historyIndexDay = -1; var cat = new System.Diagnostics.PerformanceCounterCategory("PhysicalDisk"); var instNames = cat.GetInstanceNames(); foreach (var s in instNames) { if (s == "_Total") { continue; } var item = new StatDiskActivityItem(s); _disks.Add(item); } _timer = new Timer(Update, null, 0, 1000); Update(null); }
public StorageMonitor() { // Disk Activity string category = "PhysicalDisk"; string activityCounterName = "% Disk Time"; string readCounterName = "Disk Read Bytes/sec"; string writeCounterName = "Disk Write Bytes/sec"; // Check Drive types HashSet <char> fixedDrives = new HashSet <char>(); { DriveInfo[] drives = DriveInfo.GetDrives(); foreach (var drive in drives) { if (drive.DriveType == DriveType.Fixed) { fixedDrives.Add(drive.Name[0]); } } } //// Instances (Filter out non fixed drives) var cat = new System.Diagnostics.PerformanceCounterCategory(category); List <string> instNames = new List <string>(); { List <string> instNames_tmp = new List <string>(cat.GetInstanceNames()); instNames_tmp.Remove("_Total"); instNames_tmp.Sort((x, y) => { if ((x.Length >= 2 && y.Length >= 2) && (x[x.Length - 2] > y[y.Length - 2])) { return(1); } else { return(-1); } }); for (int i = 0; i < instNames_tmp.Count; i++) { if (instNames_tmp[i].Length >= 3) { if (fixedDrives.Contains(instNames_tmp[i][instNames_tmp[i].Length - 2])) { instNames.Add(instNames_tmp[i]); } } } } //// Setup drives = new Drive[instNames.Count]; diskActivity = new PerformanceCounter[instNames.Count]; diskRead = new PerformanceCounter[instNames.Count]; diskWrite = new PerformanceCounter[instNames.Count]; for (int i = 0; i < instNames.Count; i++) { drives[i].letter = instNames[i].Substring(instNames[i].Length - 2, 1).ToCharArray()[0]; diskActivity[i] = new PerformanceCounter(category, activityCounterName, instNames[i]); diskRead[i] = new PerformanceCounter(category, readCounterName, instNames[i]); diskWrite[i] = new PerformanceCounter(category, writeCounterName, instNames[i]); } // Release Memory fixedDrives.Clear(); cat = null; GC.Collect(); }
public PerformanceCounterCategory(System.Diagnostics.PerformanceCounterCategory counterCategory) { this.CounterCategory = counterCategory; }
/* * public static void createIfNotExists(string categoryName, string counterName, string instanceName, string machineName, * string categoryHelp, string counterHelp) * { * * bool objectExists = false; * PerformanceCounterCategory pcc; * bool createCategory = false; * * // Verify that the category name is not blank. * if (categoryName.Length == 0) * { * throw new ArgumentException("Category name cannot be blank."); * } * * // Check whether the specified category exists. * if (machineName.Length == 0) * { * objectExists = PerformanceCounterCategory.Exists(categoryName); * } * else * { * // Handle the exception that is thrown if the computer * // cannot be found. * try * { * objectExists = PerformanceCounterCategory.Exists(categoryName, machineName); * } * catch (Exception ex) * { * throw new Exception(String.Format("Error checking for existence of " + * "category \"{0}\" on computer \"{1}\":" + "\n" + ex.Message, categoryName, machineName)); * } * } * * // Tell the user whether the specified category exists. * //Console.WriteLine("Category \"{0}\" " + (objectExists ? "exists on " : "does not exist on ") + * // (machineName.Length > 0 ? "computer \"{1}\"." : "this computer."), categoryName, machineName); * * // If no counter name is given, the program cannot continue. * if (counterName.Length == 0) * { * throw new ArgumentException("counterName name cannot be blank."); * } * * // A category can only be created on the local computer. * if (!objectExists) * { * if (machineName.Length > 0) * { * throw new Exception("A category can only be created on the local computer."); * } * else * { * createCategory = true; * } * } * else * { * // Check whether the specified counter exists. * if (machineName.Length == 0) * { * objectExists = PerformanceCounterCategory.CounterExists(counterName, categoryName); * } * else * { * objectExists = PerformanceCounterCategory.CounterExists(counterName, categoryName, machineName); * } * * // Tell the user whether the counter exists. * // Console.WriteLine("Counter \"{0}\" " + (objectExists ? "exists" : "does not exist") + * // " in category \"{1}\" on " + (machineName.Length > 0 ? "computer \"{2}\"." : "this computer."), * // counterName, categoryName, machineName); * * // If the counter does not exist, consider creating it. * if (!objectExists) * * // If this is a remote computer, * // exit because the category cannot be created. * { * if (machineName.Length > 0) * { * throw new Exception("A category can only be created on the local computer."); * } * else * { * * // Ask whether the user wants to recreate the category. * Console.Write("Do you want to delete and recreate " + * "category \"{0}\" with your new counter? [Y/N]: ", categoryName); * string userReply = Console.ReadLine(); * * // If yes, delete the category so it can be recreated later. * if (userReply.Trim().ToUpper() == "Y") * { * PerformanceCounterCategory.Delete(categoryName); * createCategory = true; * } * else * { * return; * } * * } * } * } * * // Create the category if it was deleted or it never existed. * if (createCategory) * { * pcc = PerformanceCounterCategory.Create(categoryName, categoryHelp, counterName, counterHelp); * * // Console.WriteLine("Category \"{0}\" with counter \"{1}\" created.", pcc.CategoryName, counterName); * * } * else if (instanceName.Length > 0) * { * if (machineName.Length == 0) * { * objectExists = PerformanceCounterCategory.InstanceExists(instanceName, categoryName); * } * else * { * objectExists = PerformanceCounterCategory.InstanceExists(instanceName, categoryName, machineName); * } * * // Tell the user whether the instance exists. * //Console.WriteLine("Instance \"{0}\" " + (objectExists ? "exists" : "does not exist") + * // " in category \"{1}\" on " + (machineName.Length > 0 ? "computer \"{2}\"." : "this computer."), * // instanceName, categoryName, machineName); * } * } */ public static void listCategories() { //Get all performance categories var cat = new System.Diagnostics.PerformanceCounterCategory("PhysicalDisk"); var instNames = cat.GetInstanceNames(); }
void ComboBox1SelectedIndexChanged(object sender, EventArgs e) { perfobject.Items.Clear(); string[] instanceNames; System.Collections.ArrayList counters = new System.Collections.ArrayList(); if (comboBox1.SelectedIndex != -1) { bool IsFinded = false; System.Diagnostics.PerformanceCounterCategory mycat = new System.Diagnostics.PerformanceCounterCategory(comboBox1.SelectedItem.ToString()); instanceNames = mycat.GetInstanceNames(); int proccount = 0; for (int i = 0; i < instanceNames.Length; i++) { string fortest = instanceNames[i].ToLower(); int lastdiez = fortest.LastIndexOf("#"); if (lastdiez != -1) { fortest = fortest.Remove(lastdiez, fortest.Length - lastdiez); } if (ProcessName.ToLower().Contains(fortest)) { proccount++; if (proccount >= 2) { break; } } } for (int i = 0; i < instanceNames.Length; i++) { IsFinded = false; System.Diagnostics.PerformanceCounterCategory mycattest = new System.Diagnostics.PerformanceCounterCategory(".NET CLR Memory"); System.Collections.ArrayList testcounters = new System.Collections.ArrayList(); testcounters.AddRange(mycattest.GetCounters(instanceNames[i])); foreach (System.Diagnostics.PerformanceCounter tcounter in testcounters) { if (tcounter.CounterName == "Process ID") { if ((int)tcounter.RawValue == procid) { IsFinded = true; } else { IsFinded = false; } } } if (!IsFinded || proccount >= 2) { string fortest = instanceNames[i]; int lastdiez = fortest.LastIndexOf("#"); if (lastdiez != -1) { fortest = fortest.Remove(lastdiez, fortest.Length - lastdiez); } if (ProcessName.ToLower().Contains(fortest.ToLower())) { IsFinded = true; string[] prcdet = new string[] { "" }; ListViewItem proctadd = new ListViewItem(prcdet); perfobject.Items.Add(proctadd); prcdet = new string[] { instanceNames[i] }; proctadd = new ListViewItem(prcdet); perfobject.Items.Add(proctadd); } } if (IsFinded) { counters.AddRange(mycat.GetCounters(instanceNames[i])); // Add the retrieved counters to the list. foreach (System.Diagnostics.PerformanceCounter counter in counters) { string[] prcdetails = new string[] { counter.CounterName, counter.RawValue.ToString() }; ListViewItem proc = new ListViewItem(prcdetails); perfobject.Items.Add(proc); } } if (proccount < 2 && IsFinded) { break; } } } }
public override void CopyFromComponent(IComponent component) { if (!(component is PerformanceCounter)) { throw new ArgumentException(Res.GetString("NotAPerformanceCounter")); } PerformanceCounter counter = (PerformanceCounter)component; if ((counter.CategoryName == null) || (counter.CategoryName.Length == 0)) { throw new ArgumentException(Res.GetString("IncompletePerformanceCounter")); } if (!this.CategoryName.Equals(counter.CategoryName) && !string.IsNullOrEmpty(this.CategoryName)) { throw new ArgumentException(Res.GetString("NewCategory")); } PerformanceCounterType counterType = PerformanceCounterType.NumberOfItems32; string counterHelp = string.Empty; if (string.IsNullOrEmpty(this.CategoryName)) { this.CategoryName = counter.CategoryName; } if (Environment.OSVersion.Platform == PlatformID.Win32NT) { string machineName = counter.MachineName; if (PerformanceCounterCategory.Exists(this.CategoryName, machineName)) { string name = @"SYSTEM\CurrentControlSet\Services\" + this.CategoryName + @"\Performance"; RegistryKey key = null; try { if ((machineName == ".") || (string.Compare(machineName, SystemInformation.ComputerName, StringComparison.OrdinalIgnoreCase) == 0)) { key = Registry.LocalMachine.OpenSubKey(name); } else { key = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, @"\\" + machineName).OpenSubKey(name); } if (key == null) { throw new ArgumentException(Res.GetString("NotCustomPerformanceCategory")); } object obj2 = key.GetValue("Library"); if (((obj2 == null) || !(obj2 is string)) || (string.Compare((string)obj2, "netfxperf.dll", StringComparison.OrdinalIgnoreCase) != 0)) { throw new ArgumentException(Res.GetString("NotCustomPerformanceCategory")); } PerformanceCounterCategory category = new PerformanceCounterCategory(this.CategoryName, machineName); this.CategoryHelp = category.CategoryHelp; if (category.CounterExists(counter.CounterName)) { counterType = counter.CounterType; counterHelp = counter.CounterHelp; } this.CategoryType = category.CategoryType; } finally { if (key != null) { key.Close(); } } } } CounterCreationData data = new CounterCreationData(counter.CounterName, counterHelp, counterType); this.Counters.Add(data); }
/// <include file='doc\PerformanceCounterInstaller.uex' path='docs/doc[@for="PerformanceCounterInstaller.CopyFromComponent"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public override void CopyFromComponent(IComponent component) { if (!(component is PerformanceCounter)) { throw new ArgumentException(Res.GetString(Res.NotAPerformanceCounter)); } PerformanceCounter counter = (PerformanceCounter)component; if (counter.CategoryName == null || counter.CategoryName.Length == 0) { throw new ArgumentException(Res.GetString(Res.IncompletePerformanceCounter)); } if (Counters.Count > 0 && !CategoryName.Equals(counter.CategoryName)) { throw new ArgumentException(Res.GetString(Res.NewCategory)); } PerformanceCounterType counterType = PerformanceCounterType.NumberOfItems32; string counterHelp = string.Empty; if (CategoryName == null || string.Empty.Equals(CategoryName)) { CategoryName = counter.CategoryName; if (Environment.OSVersion.Platform == PlatformID.Win32NT) { string machineName = counter.MachineName; if (PerformanceCounterCategory.Exists(CategoryName, machineName)) { string keyPath = ServicePath + "\\" + CategoryName + "\\Performance"; RegistryKey key = null; try { if (machineName == "." || String.Compare(machineName, SystemInformation.ComputerName, true, CultureInfo.InvariantCulture) == 0) { key = Registry.LocalMachine.OpenSubKey(keyPath); } else { RegistryKey baseKey = RegistryKey.OpenRemoteBaseKey(RegistryHive.LocalMachine, "\\\\" + machineName); key = baseKey.OpenSubKey(keyPath); } if (key == null) { throw new ArgumentException(Res.GetString(Res.NotCustomPerformanceCategory)); } object systemDllName = key.GetValue("Library"); if (systemDllName == null || !(systemDllName is string) || String.Compare((string)systemDllName, PerfShimName, true, CultureInfo.InvariantCulture) != 0) { throw new ArgumentException(Res.GetString(Res.NotCustomPerformanceCategory)); } PerformanceCounterCategory pcat = new PerformanceCounterCategory(CategoryName, machineName); CategoryHelp = pcat.CategoryHelp; if (pcat.CounterExists(counter.CounterName)) { counterType = counter.CounterType; counterHelp = counter.CounterHelp; } } finally { if (key != null) { key.Close(); } } } } } CounterCreationData data = new CounterCreationData(counter.CounterName, counterHelp, counterType); Counters.Add(data); }