private async Task GetSnapShot()

in src/Microsoft.IIS.Administration.WebServer.Monitoring/AppPools/AppPoolMonitor.cs [40:156]
109 lines of code
31 McCabe index (conditional complexity)

        private async Task<AppPoolSnapshot> GetSnapShot(ApplicationPool pool)
        {
            var snapshot = new AppPoolSnapshot();

            snapshot.Name = pool.Name;
            snapshot.ProcessCount = pool.GetWorkerProcesses().Count();

            long percentCpu = 0;

            foreach (IPerfCounter counter in await Query(pool)) {

                if (counter.CategoryName.Equals(WorkerProcessCounterNames.Category)) {
                    switch (counter.Name) {
                        case WorkerProcessCounterNames.ActiveRequests:
                            snapshot.ActiveRequests += counter.Value;
                            break;
                        case WorkerProcessCounterNames.RequestsSec:
                            snapshot.RequestsSec += counter.Value;
                            break;
                        case WorkerProcessCounterNames.TotalRequests:
                            snapshot.TotalRequests += counter.Value;
                            break;
                        case WorkerProcessCounterNames.CurrentFileCacheMemoryUsage:
                            snapshot.FileCacheMemoryUsage += counter.Value;
                            break;
                        case WorkerProcessCounterNames.CurrentFilesCached:
                            snapshot.CurrentFilesCached += counter.Value;
                            break;
                        case WorkerProcessCounterNames.CurrentUrisCached:
                            snapshot.CurrentUrisCached += counter.Value;
                            break;
                        case WorkerProcessCounterNames.FileCacheHits:
                            snapshot.FileCacheHits += counter.Value;
                            break;
                        case WorkerProcessCounterNames.FileCacheMisses:
                            snapshot.FileCacheMisses += counter.Value;
                            break;
                        case WorkerProcessCounterNames.OutputCacheCurrentItems:
                            snapshot.OutputCacheCurrentItems += counter.Value;
                            break;
                        case WorkerProcessCounterNames.OutputCacheCurrentMemoryUsage:
                            snapshot.OutputCacheCurrentMemoryUsage += counter.Value;
                            break;
                        case WorkerProcessCounterNames.OutputCacheTotalHits:
                            snapshot.OutputCacheTotalHits += counter.Value;
                            break;
                        case WorkerProcessCounterNames.OutputCacheTotalMisses:
                            snapshot.OutputCacheTotalMisses += counter.Value;
                            break;
                        case WorkerProcessCounterNames.TotalFilesCached:
                            snapshot.TotalFilesCached += counter.Value;
                            break;
                        case WorkerProcessCounterNames.TotalUrisCached:
                            snapshot.TotalUrisCached += counter.Value;
                            break;
                        case WorkerProcessCounterNames.UriCacheHits:
                            snapshot.UriCacheHits += counter.Value;
                            break;
                        case WorkerProcessCounterNames.UriCacheMisses:
                            snapshot.UriCacheMisses += counter.Value;
                            break;
                        default:
                            break;
                    }
                }

                else if (counter.CategoryName.Equals(ProcessCounterNames.Category)) {
                    switch (counter.Name) {
                        case ProcessCounterNames.PercentCpu:
                            snapshot.PercentCpuTime += counter.Value;
                            break;
                        case ProcessCounterNames.HandleCount:
                            snapshot.HandleCount += counter.Value;
                            break;
                        case ProcessCounterNames.PrivateBytes:
                            snapshot.PrivateBytes += counter.Value;
                            break;
                        case ProcessCounterNames.ThreadCount:
                            snapshot.ThreadCount += counter.Value;
                            break;
                        case ProcessCounterNames.PrivateWorkingSet:
                            snapshot.PrivateWorkingSet += counter.Value;
                            break;
                        case ProcessCounterNames.WorkingSet:
                            snapshot.WorkingSet += counter.Value;
                            break;
                        case ProcessCounterNames.IOReadSec:
                            snapshot.IOReadSec += counter.Value;
                            break;
                        case ProcessCounterNames.IOWriteSec:
                            snapshot.IOWriteSec += counter.Value;
                            break;
                        case ProcessCounterNames.PageFaultsSec:
                            snapshot.PageFaultsSec += counter.Value;
                            break;
                        default:
                            break;
                    }
                }

                else if (counter.CategoryName.Equals(MemoryCounterNames.Category)) {
                    switch (counter.Name) {
                        case MemoryCounterNames.AvailableBytes:
                            snapshot.AvailableMemory += counter.Value;
                            break;
                        default:
                            break;
                    }
                }

                snapshot.PercentCpuTime = percentCpu / _processorCount;
                snapshot.TotalInstalledMemory = MemoryData.TotalInstalledMemory;
                snapshot.SystemMemoryInUse = MemoryData.TotalInstalledMemory - snapshot.AvailableMemory;
            }

            return snapshot;
        }