Jak uzyskać całkowitą ilość pamięci RAM komputera?

Dodaj odniesienie do Microsoft.VisualBasic i using Microsoft.VisualBasic.Devices;.

Klasa ComputerInfo zawiera wszystkie potrzebne informacje.

Dodaj odniesienie do Microsoft.VisualBasic.dll, jak ktoś wyżej wspomniał. Następnie uzyskanie całkowitej pamięci fizycznej jest tak proste jak to (tak, testowałem to):

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

Wszystkie odpowiedzi tutaj, łącznie z zaakceptowaną, da ci całkowitą ilość pamięci RAM dostępne do użytku. I to mogło być to, czego chciała operacja.

Ale jeśli jesteś zainteresowany uzyskaniem kwoty Zainstalowane RAM, następnie będziesz chciał wykonać połączenie do funkcji Getphysicalyinstalledsystemmemory .

Z linku, w sekcji Uwagi:

Funkcja Getphysicalyinstalledsystemmemory pobiera ilość fizycznie zainstalowanej pamięci RAM z tabel oprogramowania sprzętowego komputera SMBIOS. Może to różnić się od ilości zgłaszanej przez funkcję GlobalMemoryStatusEx, która ustawia element ullTotalPhys struktury MEMORYSTATUSEX na ilość fizycznej pamięci dostępnej dla systemu operacyjnego. ilość pamięci dostępnej dla systemu operacyjnego może być mniejsza niż ilość pamięci fizycznie zainstalowanej w komputerze ponieważ BIOS i niektóre sterowniki mogą rezerwować pamięć jako regiony wejścia / wyjścia dla urządzeń mapowanych pamięcią, co sprawia, że pamięć jest niedostępna dla systemu operacyjnego i aplikacji.

Przykładowy kod:

[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.");
}

Jeśli przypadkiem używasz Mono, możesz być zainteresowany, aby wiedzieć, że Mono 2.8 (zostanie wydany jeszcze w tym roku) będzie miał licznik wydajności, który informuje o wielkości fizycznej pamięci na wszystkich platformach, na których działa Mono (w tym Windows). Możesz pobrać wartość licznika używając tego fragmentu kodu:

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

Jeśli interesuje Cię kod C, który dostarcza licznik wydajności, można go znaleźć tutaj .

Innym sposobem jest użycie systemu. NET.Zaplecze zarządzania:

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;

Dla tych, którzy używają .net Core 3.0 nie ma potrzeby korzystania z platformy PInvoke, aby uzyskać dostępną pamięć fizyczną. Klasa GC dodała nową metodę GC.GetGCMemoryInfo, która zwraca GCMemoryInfo Struct z TotalAvailableMemoryBytes jako właściwością. Ta właściwość zwraca całkowitą dostępną pamięć dla garbage collector.(ta sama wartość co MEMORYSTATUSEX)

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

Możesz po prostu użyć tego kodu, aby uzyskać te informacje, po prostu dodaj referencję

using Microsoft.VisualBasic.Devices;

I po prostu użyj następującego kodu

    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";
}

Możesz użyć WMI. Znalazłem fragment.

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

Ta funkcja (ManagementQuery) działa na Windows XP i nowszych systemach:

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;
}

Użycie:

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

Kompatybilny z. Net i Mono (testowany z Win10/FreeBSD/CentOS)

Używanie kodu źródłowego ComputerInfo i PerformanceCounterS dla Mono oraz jako kopii zapasowej dla. 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)))
            };
        }
    }
}

Nikt jeszcze nie wspomniał GetPerformanceInfo . podpisy PInvoke są dostępne.

Ta funkcja sprawia, że następujące informacje dla całego systemu dostępne:

• CommitTotal
• commit
• CommitPeak
• Fizyka
• PhysicalAvailable
• SystemCache
• KernelTotal
• KernelPaged
• KernelNonpaged
• PageSize
• HandleCount
• ProcessCount
• ThreadCount

PhysicalTotal jest tym, czego szuka OP, chociaż wartością jest liczba stron, więc aby przekonwertować na bajty, pomnóż wartość PageSize zwrócony.

.NIT ma limit ilości pamięci, do której może uzyskać dostęp. Jest procent, a następnie 2 GB w xp był twardy pułap.

Możesz mieć w nim 4 GB, a to zabije aplikację, gdy trafi 2GB.

Również w trybie 64 bitowym jest pewien procent pamięci, który możesz wykorzystać poza systemem, więc nie jestem pewien, czy możesz poprosić o całość, czy jest to specjalnie zabezpieczone przed.

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