C# PerformanceCounter.Dispose方法代码示例

		private static void Dispose(PerformanceCounter counter)
		{
			if (null != counter)
			{
				counter.RemoveInstance();
				counter.Dispose();
			}
		}

 /// <summary>
 /// Returnes cpu usage of a specific process
 /// </summary>
 /// <param name="jobId">Id of executing job</param>
 /// <param name="clientId">Id of executor client</param>
 /// <param name="processName">name of the process</param>
 /// <returns>ServiceOutput object</returns>
 public static ServiceOutput GetCpuUsageOfSpecificProcess(long jobId, long clientId, string processName)
 {
     PerformanceCounter cpuCounter;
     var sum = (float)0;
     try
     {
         var processes = Process.GetProcessesByName(processName);
         foreach (var process in processes)
         {
             cpuCounter = new PerformanceCounter("Process", "% Processor Time", process.ProcessName, true);
             cpuCounter.NextValue();
             Thread.Sleep(250);
             sum += cpuCounter.NextValue();
             cpuCounter.Dispose();
         }
         return new ServiceOutput()
         {
             JobId = jobId,
             ClientId = clientId,
             Result = (long) sum,
             Duration = -1,
             Date = DateTime.Now
         };
     }
     catch
     {
         return new ServiceOutput()
         {
             JobId = jobId,
             ClientId = clientId,
             Result = -1,
             Duration = -1,
             Date = DateTime.Now
         };
     }
 }

        private static void collectMetrics(object state)
        {
            StateControl control = state as StateControl;
            if (control.IsRunning)
                return; // skip this run if we're already collecting data
            control.IsRunning = true;

            // restore configured culture setting for this async thread
            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(conf.DefaultCulture);
            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(conf.DefaultCulture);

            // determine how long it takes for us to collect metrics
            // we'll adjust timer so that collecting this data is slightly more accurate
            // but not too much to cause skew in performance (e.g. our CPU usage goes up when we do this)
            Stopwatch timeTaken = new Stopwatch();
            timeTaken.Start();

            // collect metric samples for each of our counters
            foreach (Config.PerformanceCounterElement counterConfig in Config.CarbonatorSection.Current.Counters)
            {
                float sampleValue = 0f;
                string metricPath = getMetricPath(counterConfig.Path);
                // counter in list
                var perfCounterEntry = _counters.FirstOrDefault(c => c.Item1 == counterConfig.CategoryName && c.Item2 == counterConfig.CounterName && c.Item3 == counterConfig.InstanceName);
                if (perfCounterEntry == null)
                {
                    PerformanceCounter counter = null;
                    try
                    {
                        counter = new PerformanceCounter(counterConfig.CategoryName, counterConfig.CounterName, counterConfig.InstanceName);
                        counter.NextValue();
                        perfCounterEntry = new Tuple<string, string, string, PerformanceCounter>(counterConfig.CategoryName, counterConfig.CounterName, counterConfig.InstanceName, counter);
                    }
                    catch (Exception any)
                    {
                        if (counter != null)
                            counter.Dispose();
                        if (Config.CarbonatorSection.Current.LogLevel >= 2)
                            EventLog.WriteEntry(Program.EVENT_SOURCE, string.Format("Unable to initialize performance counter with path '{0}': {1}", metricPath, any.Message), EventLogEntryType.Warning);
                        continue;
                    }
                    _counters.Add(perfCounterEntry);
                }

                try
                {
                    sampleValue = perfCounterEntry.Item4.NextValue();
                }
                catch (Exception any)
                {
                    if (Config.CarbonatorSection.Current.LogLevel >= 2)
                        EventLog.WriteEntry(Program.EVENT_SOURCE, string.Format("Unable to collect performance counter with path '{0}': {1}", metricPath, any.Message), EventLogEntryType.Warning);
                    // remove from list
                    perfCounterEntry.Item4.Dispose();
                    _counters.Remove(perfCounterEntry);
                    continue;
                }

                // BlockingCollection will halt this thread if we are exceeding capacity
                _metricsList.Add(new CollectedMetric(metricPath, sampleValue));
            }

            timeTaken.Stop();

            // adjust how often we collect metrics to stay within hysteresis
            int periodTime = (int)Math.Abs(1000 - (int)timeTaken.ElapsedMilliseconds);
            if (periodTime > 100 && periodTime <= 1000)
            {
                _metricCollectorTimer.Change(100, periodTime);
                if (Config.CarbonatorSection.Current.LogLevel >= 4)
                    EventLog.WriteEntry(Program.EVENT_SOURCE, string.Format("Adjusted _metricCollector periodTime={0}ms", periodTime), EventLogEntryType.Information);
            }

            control.IsRunning = false;
        }

        public override async Task<State> Poll()
        {
  
            ServerManager server = null;
            ObjectState stateResult = ObjectState.Unknown;
            State state = default(State);
            try
            {
               
               server = ServerManager.OpenRemote(serverInstance.Name) ;
                    if (server != null&& this.Exist())
                    {
                    state = new State();
                    state.Url = string.Concat(this.Name, "@", serverInstance.Name);
                    stateResult = server.ApplicationPools[Name].State;

                    if (stateResult == ObjectState.Started) {

                        if (server.ApplicationPools[Name].WorkerProcesses.Count > 0)
                        {
                            WorkerProcess wp = server.ApplicationPools[Name].WorkerProcesses
                                .Where(p => p
                                .AppPoolName.ToLowerInvariant() == Name.ToLowerInvariant())
                                .FirstOrDefault();

                            PerformanceCounter cpuCounter = new PerformanceCounter("Process"
                                  , "% Processor Time"
                                  , Process.GetProcessById(wp.ProcessId, serverInstance.Name).ProcessName
                                  , serverInstance.Name);

                            cpuPercent = cpuCounter.NextValue();
                            await Task.Delay(2000);
                            cpuPercent = cpuCounter.NextValue();
                            await Task.Delay(30000);


                            //the requests interval time is now 30000
                            int numOfRequests = wp.GetRequests(30000).Count;


                            float cpuPercentAfterThirthySeconds = cpuCounter.NextValue();

                            if (cpuPercent >= _cpuAlertTreshold && cpuPercentAfterThirthySeconds >= _cpuAlertTreshold)
                            {
                                state.Status = "High CPU Load";
                                state.Description =string.Format("The CPU for app pool {0} on {1} has reach {2}% and may cause HTTP 503 errors", Name, serverInstance.Name, cpuPercent);
                                state = GetCommonState(server, state, numOfRequests);
                            }
                            else
                            {
                                state.Status = _positiveStatusCode;

                            }

                            if (!string.IsNullOrEmpty(state.Status))
                            {
                                server.Dispose();
                                cpuCounter.Close();
                                cpuCounter.Dispose();
                            }
                        }
                        else
                        {
                            state.Status = _positiveStatusCode;

                        }

                        return state;
                        



                        } 
                    else
                    {
                        state.Description = stateResult == ObjectState.Started ? string.Format("The app pool on server {0} is in the following in {1} state, the number of worker processes is {2}", serverInstance.Name, stateResult.ToString(), server.ApplicationPools[Name].WorkerProcesses.Count) : "Unavailable";
                        state.Status = stateResult == ObjectState.Started ? _positiveStatusCode: "App Pool Not Started";

                        state = GetCommonState(server, state, 0);
                        if (stateResult == ObjectState.Stopped)
                        {
                            server.ApplicationPools[Name].Start();
                            state.Description += server.ApplicationPools[Name].State == ObjectState.Started ? "\rResolution: The appPool was started" : state.Description;
                        }


                    }


                }
                

            }
            catch(Exception ex)
            {
                state.Status = ex.GetType().Name;
                state.Description = "'polling failed with" + ex.Message;
                state.Url = string.Concat(this.Name, "@", serverInstance.Name);
                return state;
            }
//.........这里部分代码省略.........

        private static void collectMetrics(object state)
        {
            StateControl control = state as StateControl;
            if (control.IsRunning)
                return; // skip this run if we're already collecting data
            control.IsRunning = true;

            // restore configured culture setting for this async thread
            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(conf.DefaultCulture);
            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(conf.DefaultCulture);

            // collect metric samples for each of our counters
            foreach (Config.PerformanceCounterElement counterConfig in Config.CarbonatorSection.Current.Counters)
            {
                float sampleValue = 0f;
                string metricPath = getMetricPath(counterConfig.Path);
                // counter in list
                var perfCounterEntry = _counters.FirstOrDefault(c => c.Item1 == counterConfig.CategoryName && c.Item2 == counterConfig.CounterName && c.Item3 == counterConfig.InstanceName);
                if (perfCounterEntry == null)
                {
                    PerformanceCounter counter = null;
                    try
                    {
                        counter = new PerformanceCounter(counterConfig.CategoryName, counterConfig.CounterName, counterConfig.InstanceName);
                        counter.NextValue();
                        perfCounterEntry = new Tuple<string, string, string, PerformanceCounter>(counterConfig.CategoryName, counterConfig.CounterName, counterConfig.InstanceName, counter);
                    }
                    catch (Exception any)
                    {
                        if (counter != null)
                            counter.Dispose();
                        if (Config.CarbonatorSection.Current.LogLevel >= 2)
                            EventLog.WriteEntry(Program.EVENT_SOURCE, string.Format("Unable to initialize performance counter with path '{0}': {1}", metricPath, any.Message), EventLogEntryType.Warning);
                        continue;
                    }
                    _counters.Add(perfCounterEntry);
                }

                try
                {
                    sampleValue = perfCounterEntry.Item4.NextValue();
                }
                catch (Exception any)
                {
                    if (Config.CarbonatorSection.Current.LogLevel >= 2)
                        EventLog.WriteEntry(Program.EVENT_SOURCE, string.Format("Unable to collect performance counter with path '{0}': {1}", metricPath, any.Message), EventLogEntryType.Warning);
                    // remove from list
                    perfCounterEntry.Item4.Dispose();
                    _counters.Remove(perfCounterEntry);
                    continue;
                }

                // BlockingCollection will halt this thread if we are exceeding capacity
                _metricsList.Add(new CollectedMetric(metricPath, sampleValue));
            }

            control.IsRunning = false;
        }

        //private static float GetPerformanceCounterValueByInstanceDeux(string perfCategory, string perfCounterName, string perfInstanceName, out string PerfCounterType, int sleep = 50)
        //{
        //    pCounter = new PerformanceCounter();
        //    PerfCounterType = "";
        //    try
        //    {
        //        pCounter.CategoryName = perfCategory;
        //        pCounter.CounterName = perfCounterName;
        //        pCounter.InstanceName = perfInstanceName;
        //        try
        //        {
        //            pCounter.NextValue();
        //            pFirstSample = pCounter.NextSample();
        //            Thread.Sleep(sleep);
        //            float nv = pCounter.NextValue();
        //            pSecondSample = pCounter.NextSample();
        //            float avg = CounterSample.Calculate(pFirstSample, pSecondSample);
        //            Console.WriteLine("{0}, {1}", nv, avg);
        //            return avg;
        //        }
        //        finally
        //        {
        //            pCounter.Dispose();
        //        }
        //    }
        //    catch
        //    {
        //        try
        //        {
        //            PerformanceCounter pc = new PerformanceCounter(LookupPerfNameByName(perfCategory), LookupPerfNameByName(perfCounterName), perfInstanceName);
        //            pc.NextValue();
        //            Thread.Sleep(sleep);
        //            try
        //            {
        //                PerfCounterType = pc.CounterType.ToString();
        //                return pc.NextValue();
        //            }
        //            finally
        //            {
        //                pc.Dispose();
        //            }
        //        }
        //        catch
        //        {
        //            // I give up, didnt manage to figure out the correct name for the PerformanceCounter.
        //            Console.WriteLine("ERROR: Error looking up PerformanceCounter '" + perfCategory + "\\" + perfCounterName + "' for " + perfInstanceName + "'");
        //            return -1;
        //        }
        //    }
        //}
        public static string GetPerformanceCounterValueAsString(string perfCategory, string perfCounterName, out string PerfCounterType, int sleep = 50)
        {
            //float badresult = -1;
            try
            {
                PerformanceCounter pc = new PerformanceCounter(perfCategory, perfCounterName);
                pc.NextValue();
                Console.WriteLine(pc.NextSample());
                Thread.Sleep(sleep);
                try
                {
                    PerfCounterType = pc.CounterType.ToString();
                    return pc.NextValue().ToString("0.0");
                }
                finally
                {
                    pc.Dispose();
                }

                //return pc.RawValue;
            }
            catch
            {
                try
                {
                    PerformanceCounter pc = new PerformanceCounter(LookupPerfNameByName(perfCategory), LookupPerfNameByName(perfCounterName));
                    pc.NextValue();
                    Thread.Sleep(sleep);

                    try {
                        PerfCounterType = pc.CounterType.ToString();
                        return pc.NextValue().ToString("0.0");
                    }
                    finally
                    {
                        pc.Dispose();
                    }
                }
                catch
                {
                    // I give up, didnt manage to figure out the correct name for the PerformanceCounter.
                    Console.WriteLine("ERROR: Error looking up PerformanceCounter '" + perfCategory + "\\" + perfCounterName + "'");
                    PerfCounterType = "missing";
                    return "missing";
                }
            }
        }

 public void _CPU_Usage()
 {
     try
     {
         string[] separators = { ",", ";", ":" };
         string value = textBox3.Text;
         string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
         Process[] processes = Process.GetProcessesByName(words[0]);
         int pL = processes.Length;
         if (pL > 0)
         {
             int sleep = 150 / countClients() + 50;
             for (int i = 0; i < processes.Length; i++)
             {
                 try
                 {
                     PerformanceCounter tt = new PerformanceCounter("Process", "% Processor Time", "_Total", true);
                     if (i == 0)
                     {
                         PerformanceCounter tp = new PerformanceCounter("Process", "% Processor Time", words[0], true);
                         tp.NextValue();
                         tt.NextValue();
                         Thread.Sleep(sleep);
                         cpuUsage[i] = Math.Round(tp.NextValue() / tt.NextValue() * 100, 1);
                         tp.Dispose();
                     }
                     else if (i > 0)
                     {
                         PerformanceCounter tp = new PerformanceCounter("Process", "% Processor Time", string.Concat(words[0], "#", i), true);
                         tp.NextValue();
                         tt.NextValue();
                         Thread.Sleep(sleep);
                         cpuUsage[i] = Math.Round(tp.NextValue() / tt.NextValue() * 100, 1);
                         tp.Dispose();
                     }
                     if (Double.IsNaN(cpuUsage[i]) || Double.IsInfinity(cpuUsage[i]))
                     {
                         cpuUsage[i] = cpuOld[i];
                     }
                     else
                     {
                         cpuOld[i] = cpuUsage[i];
                     }                            
                     tt.Dispose();
                 }
                 catch (Exception) { }
             }
         }
         else
             return;
     }
     catch (Exception) { }
 }

        void CollectServerInfo(string logFileCollectionPath = "")
        {
            // The Basics
            string serverInfo = "Name: " + Name + "\r\n" +
                                "IPAddress: " + IPAddress + "\r\n" +
                                "Fully Qualified Domain Name: " + FullyQualifiedDomainName + "\r\n\r\n";

            // Performance numbers
            PerformanceCounter cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total", Name);
            PerformanceCounter ramCounter = new PerformanceCounter("Memory", "Available MBytes", String.Empty, Name);
            serverInfo += String.Format("Processor Usage: {0:##0} %\r\n", cpuCounter.NextValue());
            serverInfo += String.Format("Available RAM: {0} MB\r\n", ramCounter.NextValue());
            cpuCounter.Dispose();
            ramCounter.Dispose();

            // Revit Servers
            foreach (string version in RevitServer.Versions())
            {
                serverInfo += "______________________________________________________________________________\r\n" +
                    "Revit Server " + version + "\r\n";
                bool versionExists = false;
                foreach (RevitServer rs in RevitServers)
                {
                    if (rs.Version == version) { versionExists = true; break; }
                }
                if (!versionExists)
                {
                    serverInfo += "Not Configured.\r\n" ;
                }
                else
                {
                    foreach (RevitServer rs in RevitServers)
                    {
                        if (rs.Version == version)
                        {
                            // Revit Server roles for this version
                            serverInfo += "Roles: " + rs.RolesAsString() + "\r\n";

                            // Location of project data
                            serverInfo += "Project Data Location: " + rs.ProjectDataPath + "\r\n";

                            // Contents of RSN.ini
                            if (rs.Hosts.Count > 0)
                            {
                                serverInfo += "Hosts in RSN.ini:\r\n";
                                int counter = 1;
                                foreach (string host in rs.Hosts)
                                {
                                    serverInfo += "  " + counter.ToString() +".  " + host +  " - latency from this machine: " + GetPingTimeString(host) + "\r\n";
                                    counter += 1;
                                }
                            } else {
                                serverInfo += "Hosts are not properly configured, or RSN.ini is missing.";
                            }

                            break;
                        }
                    }
                }
            }
            serverInfo += GetRunningProcesses();
            serverInfo += "______________________________________________________________________________\r\n";

            // Write the data
            Logging.RsiLog(serverInfo);
            System.IO.File.WriteAllText(logFileCollectionPath + "\\_ServerInfo.txt", @serverInfo);
        }

        private void Process()
        {
            while (!finalizeService)
            {
                PerformanceCounter PC = new PerformanceCounter();
                PC.CategoryName = "Processor";
                PC.CounterName = "% Processor Time";
                PC.InstanceName = "_Total";
                PC.ReadOnly = true;
                var value = PC.NextValue();
                Thread.Sleep(1000);
                value = PC.NextValue();
                PC.Close();
                PC.Dispose();

                PerformanceCounter ramCounter = new PerformanceCounter("Memory", "Available MBytes", true);
                var ramValue = ramCounter.NextValue();
                if (ramValue < MinRAMAvailable)
                {
                    SendAlertMessage(AlertType.RAM_ALERT, value,Convert.ToInt64(ramValue));
                }

                if (value > MaxCPUUsage)
                {
                    totalHits = totalHits + 1;
                    if (totalHits == Period)
                    {
                        SendAlertMessage(AlertType.PROCESS_ALERT, value, Convert.ToInt64(ramValue));
                        totalHits = 0;
                    }
                }
                else
                {
                    totalHits = 0;
                }

            }
            eventLog.WriteEntry(ServiceName +  " stoped.");
        }

        public void _Update_RAM()
        {
            string[] separators = { ",", ";", ":" };
            string value = textBox3.Text;
            string[] words = value.Split(separators, StringSplitOptions.RemoveEmptyEntries);
            try
            {
                Process[] processes = Process.GetProcessesByName(words[0]);
                int pL = processes.Length;
                count = processes.Length;
                if (pL > 0)
                {
                    for (int i = 0; i < processes.Length; i++)
                    {
                        if (pL > listView1.Items.Count)
                        {
                            cpuUsage.Add(i);
                            cpuOld.Add(i);
                            pMem.Add(i);
                        }
                        if (i == 0)
                        {
                            PerformanceCounter ramCounter = new PerformanceCounter("Process", "Working Set - Private", words[0]);
                            pMem[i] = Convert.ToInt32(ramCounter.NextValue()) / (int)(1024);
                            ramCounter.Dispose();
                        }
                        else if (i > 0)
                        {
                            PerformanceCounter ramCounter = new PerformanceCounter("Process", "Working Set - Private", string.Concat(words[0], "#", i));
                            pMem[i] = Convert.ToInt32(ramCounter.NextValue()) / (int)(1024);
                            ramCounter.Dispose();
                        }

                        #region AddItem
                        //Currently only accepting the first argument
                        //This works for single process monitoring eg "game;" 
                        //for multiple processes "game;game1;game2;game3;" this will need reworked.
                        try
                        {
                            if (pL > listView1.Items.Count)
                            {
                                //Add Items/SubItems
                                item = new ListViewItem(processes[i].ProcessName);
                                item.SubItems.Add("0%");
                                item.SubItems.Add(pMem[i].ToString("#,#") + " K");
                                listView1.Items.Add(item);
                            }
                            else if (pL < listView1.Items.Count)
                            {
                                //Remove Item/SubItems
                                listView1.Items.RemoveAt(i);
                                cpuUsage.RemoveAt(i);
                                cpuOld.RemoveAt(i);
                                pMem.RemoveAt(i);
                                return;
                            }
                            else if (pL == listView1.Items.Count)
                            {
                                //Update Item/SubItem
                                listView1.Items[i].SubItems[0].Text = processes[i].ProcessName;
                                listView1.Items[i].SubItems[2].Text = pMem[i].ToString("#,#") + " K";
                            }
                        }
                        catch (Exception) { }
                        #endregion
                    }
                }
                else if (processes.Length == 0 && listView1.Items.Count > processes.Length)
                {
                    listView1.Items.Clear();
                    cpuUsage.Clear();
                    cpuOld.Clear();
                    pMem.Clear();
                }
                else
                    return;
            }
            catch (Exception) { }
        }

        protected string GetAvailableMemory()
        {
            PerformanceCounter counter = null;

            try
            {
                counter = new PerformanceCounter("Memory", "Available MBytes");
                return counter.NextValue().ToString(CultureInfo.InvariantCulture);
            }
            catch
            {
                return "Error";
            }
            finally
            {
                if (counter != null)
                {
                    counter.Dispose();
                }
            }
        }

            private PerformanceCounter ObjectsInReferenceSystemCounterFor(IObjectContainer container)
            {
                if (_objectsCounter == null)
                {
                    _objectsCounter = Db4oPerformanceCounters.CounterFor(PerformanceCounterSpec.ObjectReferenceCount,
                        container, false);
                    var eventRegistry = EventRegistryFactory.ForObjectContainer(container);
                    eventRegistry.Closing += delegate
                    {
                        _objectsCounter.RemoveInstance();
                        _objectsCounter.Dispose();
                    };
                }

                return _objectsCounter;
            }

            public void TestMergeTableTiming(int mergeMax, int size)
            {
                PerformanceCounter PC = new PerformanceCounter();
                PC.CategoryName = "Process";
                PC.CounterName = "Working Set - Private";
                PC.InstanceName = Process.GetCurrentProcess().ProcessName;

                Console.WriteLine("TESTING:  page max({0}) record count({1})", mergeMax, size);
                var basename = "RazorDbTests.IndexingTests";
                var rand = new Random((int)DateTime.Now.Ticks);
                var indexHash = new Dictionary<ByteArray, byte[]>();
                var itemKeyLen = 35;

                var kvsName = string.Format("MergeTableTiming_{0}_{1}", mergeMax, DateTime.Now.Ticks);

                var sw = new Stopwatch();
                sw.Start();
                using (var testKVS = new KeyValueStore(Path.Combine(basename, kvsName))) {
                    // add a bunch of values that look like indexes
                    for (int r = 0; r < size; r++) {
                        var indexLen = (int)(DateTime.Now.Ticks % 60) + 50;
                        var indexKeyBytes = dataset[r];
                        var valuekeyBytes = indexKeyBytes.Skip(indexKeyBytes.Length - itemKeyLen).ToArray();
                        testKVS.Set(indexKeyBytes, valuekeyBytes); // old style index
                        indexHash.Add(new ByteArray(valuekeyBytes), indexKeyBytes);
                    }
                    TableManager.RunTableMergePass(testKVS);
                }
                sw.Stop();
                var memsize = Convert.ToInt32(PC.NextValue()) / (int)(1024);
                Console.WriteLine("Total processing time: {0} entries    {1} mergeSz    {2}  MEMORY: {3}", size, mergeMax, sw.Elapsed.ToString(), memsize);
                Console.WriteLine();
                PC.Close();
                PC.Dispose();
            }

        // 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]]);
            }
        }

        static void CollectingMemory()
        {
            Process currentProcess = Process.GetCurrentProcess();
            var privateByteCounter = new PerformanceCounter("Process", "Working Set - Private", currentProcess.ProcessName);
            var netMemoryCounter = new PerformanceCounter(".NET CLR Memory", "# Bytes in all Heaps", currentProcess.ProcessName);

            while (!done)
            {
                maxNetMemory = Math.Max(netMemoryCounter.NextSample().RawValue / 1024, maxNetMemory);
                maxPrivateWorkingSet = Math.Max(privateByteCounter.NextSample().RawValue / 1024, maxPrivateWorkingSet);
                Thread.Sleep(100);
            }

            privateByteCounter.Dispose();
            netMemoryCounter.Dispose();
        }