Як отримати загальну кількість оперативної пам’яті, яку має комп’ютер?

Використовуючи C #, я хочу отримати загальну кількість оперативної пам'яті, яку має мій комп'ютер. За допомогою PerformanceCounter я можу отримати кількість доступної оперативної пам'яті, встановивши:

counter.CategoryName = "Memory";
counter.Countername = "Available MBytes";

Але я, здається, не можу знайти спосіб отримати загальний обсяг пам'яті. Як би я це зробив?

Оновлення:

MagicKat: Я бачив це, коли шукав, але це не працює - "Вам бракує збірки чи довідки?". Я прагнув додати це до посилань, але я не бачу цього там.

Функцію Windows API GlobalMemoryStatusExможна викликати за допомогою p / invoke:

  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
  private class MEMORYSTATUSEX
  {
     public uint dwLength;
     public uint dwMemoryLoad;
     public ulong ullTotalPhys;
     public ulong ullAvailPhys;
     public ulong ullTotalPageFile;
     public ulong ullAvailPageFile;
     public ulong ullTotalVirtual;
     public ulong ullAvailVirtual;
     public ulong ullAvailExtendedVirtual;
     public MEMORYSTATUSEX()
     {
        this.dwLength = (uint)Marshal.SizeOf(typeof(NativeMethods.MEMORYSTATUSEX));
     }
  }


  [return: MarshalAs(UnmanagedType.Bool)]
  [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
  static extern bool GlobalMemoryStatusEx([In, Out] MEMORYSTATUSEX lpBuffer);

Потім використовуйте як:

ulong installedMemory;
MEMORYSTATUSEX memStatus = new MEMORYSTATUSEX();
if( GlobalMemoryStatusEx( memStatus))
{ 
   installedMemory = memStatus.ullTotalPhys;
}

Або ви можете використовувати WMI (керований, але повільніший) для запитів TotalPhysicalMemoryу Win32_ComputerSystemкласі.

Додайте посилання на Microsoft.VisualBasicта a using Microsoft.VisualBasic.Devices;.

У ComputerInfoкласі є вся необхідна інформація.

Додайте посилання на Microsoft.VisualBasic.dll, як хтось згадав вище. Тоді отримати загальну фізичну пам’ять так просто (так, я тестував):

static ulong GetTotalMemoryInBytes()
{
    return new Microsoft.VisualBasic.Devices.ComputerInfo().TotalPhysicalMemory;
}

Усі відповіді тут, включаючи прийняту, дадуть вам загальну кількість оперативної пам’яті, доступної для використання. І це, можливо, було тим, що хотів ОП.

Але якщо ви зацікавлені в тому, щоб отримати обсяг встановленої оперативної пам'яті, тоді вам потрібно буде зателефонувати до функції GetPhysicallyInstalledSystemMemory .

За посиланням, у розділі Зауваження:

Функція GetPhysicallyInstalledSystemMemory отримує обсяг фізично встановленої оперативної пам'яті з таблиць мікропрограми SMBIOS на комп'ютері. Це може відрізнятися від суми, повідомленої функцією GlobalMemoryStatusEx , яка встановлює член ullTotalPhys структури MEMORYSTATUSEX на обсяг фізичної пам'яті, доступний для використання операційною системою. Обсяг пам’яті, доступний операційній системі, може бути меншим, ніж обсяг фізично встановленої в комп’ютері пам’яті, оскільки BIOS і деякі драйвери можуть резервувати пам’ять як регіони вводу-виводу для відображених у пам'яті пристроїв, що робить пам’ять недоступною для операційної системи та додатки.

Зразок коду:

[DllImport("kernel32.dll")]
[return: MarshalAs(UnmanagedType.Bool)]
static extern bool GetPhysicallyInstalledSystemMemory(out long TotalMemoryInKilobytes);

static void Main()
{
    long memKb;
    GetPhysicallyInstalledSystemMemory(out memKb);
    Console.WriteLine((memKb / 1024 / 1024) + " GB of RAM installed.");
}

Якщо ви випадково використовуєте Mono, можливо, вам буде цікаво знати, що Mono 2.8 (який вийде пізніше цього року) матиме лічильник продуктивності, який повідомляє про фізичний обсяг пам'яті на всіх платформах, на яких працює Mono (включаючи Windows). Ви отримаєте значення лічильника, використовуючи цей фрагмент коду:

using System;
using System.Diagnostics;

class app
{
   static void Main ()
   {
       var pc = new PerformanceCounter ("Mono Memory", "Total Physical Memory");
       Console.WriteLine ("Physical RAM (bytes): {0}", pc.RawValue);
   }
}

Якщо вас цікавить код С, який містить лічильник продуктивності, його можна знайти тут .

Іншим способом зробити це є використання засобів .NET System.Management для запитів:

string Query = "SELECT Capacity FROM Win32_PhysicalMemory";
ManagementObjectSearcher searcher = new ManagementObjectSearcher(Query);

UInt64 Capacity = 0;
foreach (ManagementObject WniPART in searcher.Get())
{
    Capacity += Convert.ToUInt64(WniPART.Properties["Capacity"].Value);
}

return Capacity;

Для тих, хто користується .net Core 3.0, немає необхідності використовувати PInvokeплатформу, щоб отримати доступну фізичну пам’ять. GCКлас доданий новий метод , GC.GetGCMemoryInfoякий повертає GCMemoryInfo Structз TotalAvailableMemoryBytesяк властивість. Ця властивість повертає загальну доступну пам'ять для збирача сміття. (Те саме значення, що і MEMORYSTATUSEX)

var gcMemoryInfo = GC.GetGCMemoryInfo();
installedMemory = gcMemoryInfo.TotalAvailableMemoryBytes;
// it will give the size of memory in MB
var physicalMemory = (double) installedMemory / 1048576.0;

Ви можете просто використовувати цей код, щоб отримати цю інформацію, просто додайте посилання

using Microsoft.VisualBasic.Devices;

і просто використовуйте наступний код

    private void button1_Click(object sender, EventArgs e)
    {
        getAvailableRAM();
    }

    public void getAvailableRAM()
    {
        ComputerInfo CI = new ComputerInfo();
        ulong mem = ulong.Parse(CI.TotalPhysicalMemory.ToString());
        richTextBox1.Text = (mem / (1024*1024) + " MB").ToString();
    }

// use `/ 1048576` to get ram in MB
// and `/ (1048576 * 1024)` or `/ 1048576 / 1024` to get ram in GB
private static String getRAMsize()
{
    ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
    ManagementObjectCollection moc = mc.GetInstances();
    foreach (ManagementObject item in moc)
    {
       return Convert.ToString(Math.Round(Convert.ToDouble(item.Properties["TotalPhysicalMemory"].Value) / 1048576, 0)) + " MB";
    }

    return "RAMsize";
}

Ви можете використовувати WMI. Знайшов сніппіт.

Set objWMIService = GetObject("winmgmts:" _
& "{impersonationLevel=impersonate}!\\" _ 
& strComputer & "\root\cimv2") 
Set colComputer = objWMIService.ExecQuery _
("Select * from Win32_ComputerSystem")

For Each objComputer in colComputer 
  strMemory = objComputer.TotalPhysicalMemory
Next

Ця функція ( ManagementQuery) працює у Windows XP та новіших версіях:

private static string ManagementQuery(string query, string parameter, string scope = null) {
    string result = string.Empty;
    var searcher = string.IsNullOrEmpty(scope) ? new ManagementObjectSearcher(query) : new ManagementObjectSearcher(scope, query);
    foreach (var os in searcher.Get()) {
        try {
            result = os[parameter].ToString();
        }
        catch {
            //ignore
        }

        if (!string.IsNullOrEmpty(result)) {
            break;
        }
    }

    return result;
}

Використання:

Console.WriteLine(BytesToMb(Convert.ToInt64(ManagementQuery("SELECT TotalPhysicalMemory FROM Win32_ComputerSystem", "TotalPhysicalMemory", "root\\CIMV2"))));

Сумісний з .Net та Mono (протестовано на Win10 / FreeBSD / CentOS)

Використання ComputerInfoвихідного коду та PerformanceCounters для Mono та як резервної копії для .Net:

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;

public class SystemMemoryInfo
{
    private readonly PerformanceCounter _monoAvailableMemoryCounter;
    private readonly PerformanceCounter _monoTotalMemoryCounter;
    private readonly PerformanceCounter _netAvailableMemoryCounter;

    private ulong _availablePhysicalMemory;
    private ulong _totalPhysicalMemory;

    public SystemMemoryInfo()
    {
        try
        {
            if (PerformanceCounterCategory.Exists("Mono Memory"))
            {
                _monoAvailableMemoryCounter = new PerformanceCounter("Mono Memory", "Available Physical Memory");
                _monoTotalMemoryCounter = new PerformanceCounter("Mono Memory", "Total Physical Memory");
            }
            else if (PerformanceCounterCategory.Exists("Memory"))
            {
                _netAvailableMemoryCounter = new PerformanceCounter("Memory", "Available Bytes");
            }
        }
        catch
        {
            // ignored
        }
    }

    public ulong AvailablePhysicalMemory
    {
        [SecurityCritical]
        get
        {
            Refresh();

            return _availablePhysicalMemory;
        }
    }

    public ulong TotalPhysicalMemory
    {
        [SecurityCritical]
        get
        {
            Refresh();

            return _totalPhysicalMemory;
        }
    }

    [SecurityCritical]
    [DllImport("Kernel32", CharSet = CharSet.Auto, SetLastError = true)]
    private static extern void GlobalMemoryStatus(ref MEMORYSTATUS lpBuffer);

    [SecurityCritical]
    [DllImport("Kernel32", CharSet = CharSet.Auto, SetLastError = true)]
    [return: MarshalAs(UnmanagedType.Bool)]
    private static extern bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX lpBuffer);

    [SecurityCritical]
    private void Refresh()
    {
        try
        {
            if (_monoTotalMemoryCounter != null && _monoAvailableMemoryCounter != null)
            {
                _totalPhysicalMemory = (ulong) _monoTotalMemoryCounter.NextValue();
                _availablePhysicalMemory = (ulong) _monoAvailableMemoryCounter.NextValue();
            }
            else if (Environment.OSVersion.Version.Major < 5)
            {
                var memoryStatus = MEMORYSTATUS.Init();
                GlobalMemoryStatus(ref memoryStatus);

                if (memoryStatus.dwTotalPhys > 0)
                {
                    _availablePhysicalMemory = memoryStatus.dwAvailPhys;
                    _totalPhysicalMemory = memoryStatus.dwTotalPhys;
                }
                else if (_netAvailableMemoryCounter != null)
                {
                    _availablePhysicalMemory = (ulong) _netAvailableMemoryCounter.NextValue();
                }
            }
            else
            {
                var memoryStatusEx = MEMORYSTATUSEX.Init();

                if (GlobalMemoryStatusEx(ref memoryStatusEx))
                {
                    _availablePhysicalMemory = memoryStatusEx.ullAvailPhys;
                    _totalPhysicalMemory = memoryStatusEx.ullTotalPhys;
                }
                else if (_netAvailableMemoryCounter != null)
                {
                    _availablePhysicalMemory = (ulong) _netAvailableMemoryCounter.NextValue();
                }
            }
        }
        catch
        {
            // ignored
        }
    }

    private struct MEMORYSTATUS
    {
        private uint dwLength;
        internal uint dwMemoryLoad;
        internal uint dwTotalPhys;
        internal uint dwAvailPhys;
        internal uint dwTotalPageFile;
        internal uint dwAvailPageFile;
        internal uint dwTotalVirtual;
        internal uint dwAvailVirtual;

        public static MEMORYSTATUS Init()
        {
            return new MEMORYSTATUS
            {
                dwLength = checked((uint) Marshal.SizeOf(typeof(MEMORYSTATUS)))
            };
        }
    }

    private struct MEMORYSTATUSEX
    {
        private uint dwLength;
        internal uint dwMemoryLoad;
        internal ulong ullTotalPhys;
        internal ulong ullAvailPhys;
        internal ulong ullTotalPageFile;
        internal ulong ullAvailPageFile;
        internal ulong ullTotalVirtual;
        internal ulong ullAvailVirtual;
        internal ulong ullAvailExtendedVirtual;

        public static MEMORYSTATUSEX Init()
        {
            return new MEMORYSTATUSEX
            {
                dwLength = checked((uint) Marshal.SizeOf(typeof(MEMORYSTATUSEX)))
            };
        }
    }
}

Про GetPerformanceInfo ще ніхто не згадував . Доступні підписи PInvoke .

Ця функція робить доступною таку загальносистемну інформацію:

• CommTotal
• CommitLimit
• CommPeak
• PhysicalTotal
• Доступний
• SystemCache
• KernelTotal
• KernelPaged
• KernelNonpaged
• Розмір сторінки
• HandleCount
• ProcessCount
• ThreadCount

PhysicalTotalце те, що шукає OP, хоча значення - це кількість сторінок, тому для перетворення в байти помножте на PageSizeповернене значення.

.NIT має обмежений обсяг пам’яті, до якого він може отримати доступ. Є відсоток, і тоді 2 ГБ в xp було жорсткою стелею.

У ньому могло бути 4 Гб, і це вбило б програму, коли вона потрапила в 2 Гб.

Також у 64-розрядному режимі є відсоток пам'яті, яку ви можете використовувати поза системою, тому я не впевнений, чи можете ви запитати все це, чи це спеціально захищено.

/*The simplest way to get/display total physical memory in VB.net (Tested)

public sub get_total_physical_mem()

    dim total_physical_memory as integer

    total_physical_memory=CInt((My.Computer.Info.TotalPhysicalMemory) / (1024 * 1024))
    MsgBox("Total Physical Memory" + CInt((My.Computer.Info.TotalPhysicalMemory) / (1024 * 1024)).ToString + "Mb" )
end sub
*/


//The simplest way to get/display total physical memory in C# (converted Form http://www.developerfusion.com/tools/convert/vb-to-csharp)

public void get_total_physical_mem()
{
    int total_physical_memory = 0;

    total_physical_memory = Convert.ToInt32((My.Computer.Info.TotalPhysicalMemory) /  (1024 * 1024));
    Interaction.MsgBox("Total Physical Memory" + Convert.ToInt32((My.Computer.Info.TotalPhysicalMemory) / (1024 * 1024)).ToString() + "Mb");
}