C#Obtener memoria usada en%

performancecounter

Question

Creé un contador de rendimiento que puede verificar el uso total de la memoria en%, pero el problema es que no me da el mismo valor que el administrador de tareas me muestra. por ejemplo: mi programa dice 34% pero el administrador de tareas dice 40%.

¿Algunas ideas?

NOTA
Intento obtener la RAM disponible del sistema, no la RAM utilizada por un proceso.

Código actual

private PerformanceCounter performanceCounterRAM = new PerformanceCounter();

performanceCounterRAM.CounterName = "% Committed Bytes In Use";
performanceCounterRAM.CategoryName = "Memory";

progressBarRAM.Value = (int)(performanceCounterRAM.NextValue());
            labelRAM.Text = "RAM: " + progressBarRAM.Value.ToString(CultureInfo.InvariantCulture) + "%";

EDITAR
Actualizo la barra de progreso y la etiqueta cada segundo con un temporizador.

Answer 1

Creo que el porcentaje de memoria física reportado por el Administrador de tareas es en realidad una medida diferente del % Committed Bytes In Use está usando su contador de rendimiento.

En mi máquina hay una clara diferencia del 20% entre estos valores cuando se ven en el monitor de rendimiento:

Este artículo indica que la métrica% Committed Bytes tiene en cuenta el tamaño del archivo de paginación, no solo la memoria física de la máquina. Esto explicaría por qué este valor es consistentemente más bajo que el valor del Administrador de tareas.

Puede que tenga más suerte al calcular un porcentaje utilizando la métrica Memory / Available Bytes , pero no estoy seguro de cómo obtener la cantidad total de memoria física de PerformanceCounter.

Answer 2

Los contadores de rendimiento no son una buena idea. Use este código para obtener% de uso de memoria del Administrador de tareas

var wmiObject = new ManagementObjectSearcher("select * from Win32_OperatingSystem");

var memoryValues = wmiObject.Get().Cast<ManagementObject>().Select(mo => new {
    FreePhysicalMemory = Double.Parse(mo["FreePhysicalMemory"].ToString()),
    TotalVisibleMemorySize = Double.Parse(mo["TotalVisibleMemorySize"].ToString())
}).FirstOrDefault();

if (memoryValues != null) {
    var percent = ((memoryValues.TotalVisibleMemorySize - memoryValues.FreePhysicalMemory) / memoryValues.TotalVisibleMemorySize) * 100;
}

Answer 3

Puede usar "mostrar descripción" en la parte inferior del monitor de rendimiento. Citar

% Bytes en uso en uso es la proporción de memoria / Bytes comprometidos con el límite de memoria / compromiso. La memoria comprometida es la memoria física en uso para la que se ha reservado espacio en el archivo de paginación en caso de que deba escribirse en el disco. El límite de compromiso está determinado por el tamaño del archivo de paginación. Si el archivo de paginación se amplía, el límite de compromiso aumenta y la relación se reduce). Este contador muestra solo el valor porcentual actual; no es un promedio

Soo yes PM usa el archivo de paginación, mientras que TM usa RAM real.

Answer 4

Puede usar la API de Windows GetPerformanceInfo, muestra exactamente los mismos valores que Windows Task Manager en Windows 7, aquí está la aplicación de consola que obtiene la memoria física disponible, puede obtener fácilmente otra información que GetPerformanceInfo devuelve, consulte la documentación de la estructura PERFORMANCE_INFORMATION MSDN para ver cómo para calcular el valor en MiB, básicamente todos los valores de SIZE_T están en páginas, por lo que debe multiplicarlo con PageSize.

Actualización: Actualicé este código para mostrar el porcentaje, no es óptimo porque llama a GetPerformanceInfo dos veces, pero espero que entiendas la idea.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

namespace ConsoleApplicationPlayground
{
  class Program
  {
    static void Main(string[] args)
    {
      while (true)
      {
        Int64 phav = PerformanceInfo.GetPhysicalAvailableMemoryInMiB();
        Int64 tot = PerformanceInfo.GetTotalMemoryInMiB();
        decimal percentFree = ((decimal)phav / (decimal)tot) * 100;
        decimal percentOccupied = 100 - percentFree;
        Console.WriteLine("Available Physical Memory (MiB) " + phav.ToString());
        Console.WriteLine("Total Memory (MiB) " + tot.ToString());
        Console.WriteLine("Free (%) " + percentFree.ToString());
        Console.WriteLine("Occupied (%) " + percentOccupied.ToString());
        Console.ReadLine();
      }
    }
  }

  public static class PerformanceInfo
  {
    [DllImport("psapi.dll", SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    public static extern bool GetPerformanceInfo([Out] out PerformanceInformation PerformanceInformation, [In] int Size);

    [StructLayout(LayoutKind.Sequential)]
    public struct PerformanceInformation
    {
      public int Size;
      public IntPtr CommitTotal;
      public IntPtr CommitLimit;
      public IntPtr CommitPeak;
      public IntPtr PhysicalTotal;
      public IntPtr PhysicalAvailable;
      public IntPtr SystemCache;
      public IntPtr KernelTotal;
      public IntPtr KernelPaged;
      public IntPtr KernelNonPaged;
      public IntPtr PageSize;
      public int HandlesCount;
      public int ProcessCount;
      public int ThreadCount;
    }

    public static Int64 GetPhysicalAvailableMemoryInMiB()
    {
        PerformanceInformation pi = new PerformanceInformation();
        if (GetPerformanceInfo(out pi, Marshal.SizeOf(pi)))
        {
          return Convert.ToInt64((pi.PhysicalAvailable.ToInt64() * pi.PageSize.ToInt64() / 1048576));
        }
        else
        {
          return -1;
        }

    }

    public static Int64 GetTotalMemoryInMiB()
    {
      PerformanceInformation pi = new PerformanceInformation();
      if (GetPerformanceInfo(out pi, Marshal.SizeOf(pi)))
      {
        return Convert.ToInt64((pi.PhysicalTotal.ToInt64() * pi.PageSize.ToInt64() / 1048576));
      }
      else
      {
        return -1;
      }

    }
  }
}