CloudWatchMonitor.MonitorService.SubmitMemoryMetrics C# (CSharp) Метод

        private void SubmitMemoryMetrics(List<Amazon.CloudWatch.Model.MetricDatum> metrics)
        {
            Info("Adding memory metrics");

            var dimensions = new List<Amazon.CloudWatch.Model.Dimension>();
            dimensions.Add(new Amazon.CloudWatch.Model.Dimension()
            {
                Name = "InstanceId",
                Value = _instanceId
            });

            // Why is this in a visual basic namespace?
            var computerInfo = new Microsoft.VisualBasic.Devices.ComputerInfo();

            double availablePhysicalMemory = computerInfo.AvailablePhysicalMemory;
            double totalPhysicalMemory = computerInfo.TotalPhysicalMemory;
            double physicalMemoryUsed = (totalPhysicalMemory - availablePhysicalMemory);
            double physicalMemoryUtilized = (physicalMemoryUsed / totalPhysicalMemory) * 100;

            Info("\tTotal Physical Memory: {0:N0} bytes", totalPhysicalMemory);

            if (_isSubmitPhysicalMemoryUsed)
            {
                Info("\tPhysical Memory Used: {0:N0} bytes", physicalMemoryUsed);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "PhysicalMemoryUsed",
                    Unit = "Bytes",
                    Value = physicalMemoryUsed,
                    Dimensions = dimensions
                });
            }

            if (_isSubmitPhysicalMemoryAvailable)
            {
                Info("\tAvailable Physical Memory: {0:N0} bytes", availablePhysicalMemory);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "PhysicalMemoryAvailable",
                    Unit = "Bytes",
                    Value = availablePhysicalMemory,
                    Dimensions = dimensions
                });
            }

            if (_isSubmitPhysicalMemoryUtilization)
            {
                Info("\tPhysical Memory Utilization: {0:F1}%", physicalMemoryUtilized);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "PhysicalMemoryUtilization",
                    Unit = "Percent",
                    Value = physicalMemoryUtilized,
                    Dimensions = dimensions
                });
            }

            double availableVirtualMemory = computerInfo.AvailableVirtualMemory;
            double totalVirtualMemory = computerInfo.TotalVirtualMemory;
            double virtualMemoryUsed = (totalVirtualMemory - availableVirtualMemory);
            double virtualMemoryUtilized = (virtualMemoryUsed / totalVirtualMemory) * 100;

            Info("\tTotal Virtual Memory: {0:N0} bytes", totalVirtualMemory);

            if (_isSubmitVirtualMemoryUsed)
            {
                Info("\tVirtual Memory Used: {0:N0} bytes", physicalMemoryUsed);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "VirtualMemoryUsed",
                    Unit = "Bytes",
                    Value = virtualMemoryUsed,
                    Dimensions = dimensions
                });
            }

            if (_isSubmitVirtualMemoryAvailable)
            {
                Info("\tAvailable Virtual Memory: {0:N0} bytes", availableVirtualMemory);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "VirtualMemoryAvailable",
                    Unit = "Bytes",
                    Value = availableVirtualMemory,
                    Dimensions = dimensions
                });
            }

            if (_isSubmitVirtualMemoryUtilization)
            {
                Info("\tVirtual Memory Utilization: {0:F1}%", virtualMemoryUtilized);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "VirtualMemoryUtilization",
                    Unit = "Percent",
                    Value = virtualMemoryUtilized,
                    Dimensions = dimensions
                });
            }

            double availableMemory = availablePhysicalMemory + availableVirtualMemory;
            double totalMemory = totalPhysicalMemory + totalVirtualMemory;
            double memoryUsed = (totalMemory - availableMemory);
            double memoryUtilized = (memoryUsed / totalMemory) * 100;

            Info("\tTotal Memory: {0:N0} bytes", totalMemory);

            if (_isSubmitMemoryUsed)
            {
                Info("\tMemory Used: {0:N0} bytes", physicalMemoryUsed);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "MemoryUsed",
                    Unit = "Bytes",
                    Value = memoryUsed,
                    Dimensions = dimensions
                });
            }

            if (_isSubmitMemoryAvailable)
            {
                Info("\tAvailable Memory: {0:N0} bytes", availableMemory);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "MemoryAvailable",
                    Unit = "Bytes",
                    Value = availableMemory,
                    Dimensions = dimensions
                });
            }

            if (_isSubmitMemoryUtilization)
            {
                Info("\tMemory Utilization: {0:F1}%", memoryUtilized);
                metrics.Add(new Amazon.CloudWatch.Model.MetricDatum()
                {
                    MetricName = "MemoryUtilization",
                    Unit = "Percent",
                    Value = memoryUtilized,
                    Dimensions = dimensions
                });
            }
        }