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

Za pomocą języka C # chcę uzyskać całkowitą ilość pamięci RAM, którą ma mój komputer. Dzięki PerformanceCounter mogę uzyskać ilość dostępnej pamięci RAM, ustawiając:

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

Ale nie mogę znaleźć sposobu, aby uzyskać całkowitą ilość pamięci. Jak bym to zrobił?

Aktualizacja:

MagicKat: Widziałem to, kiedy szukałem, ale to nie działa - „Brakuje Ci zestawu lub referencji?”. Chciałem dodać to do odniesień, ale nie widzę tego tam.

Funkcję Windows API GlobalMemoryStatusExmożna wywołać za pomocą 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);

Następnie użyj:

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

Lub możesz użyć WMI (zarządzanej, ale wolniejszej) do wykonywania zapytań TotalPhysicalMemoryw Win32_ComputerSystemklasie.

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

ComputerInfoKlasa posiada wszystkie informacje, które potrzebujesz.

Dodaj odwołanie do Microsoft.VisualBasic.dll, jak ktoś wspomniany powyżej. Uzyskanie całkowitej pamięci fizycznej jest tak proste (tak, testowałem to):

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

Wszystkie odpowiedzi tutaj, w tym zaakceptowana, podają całkowitą ilość dostępnej pamięci RAM . I być może tego chciał OP.

Ale jeśli jesteś zainteresowany uzyskaniem ilości zainstalowanej pamięci RAM, będziesz chciał wykonać wywołanie funkcji GetPhysicallyInstalledSystemMemory .

Z linku w sekcji Uwagi:

Funkcja GetPhysicallyInstalledSystemMemory pobiera ilość fizycznie zainstalowanej pamięci RAM z tabel oprogramowania układowego SMBIOS komputera. Może się ona różnić od ilości zgłoszonej przez funkcję GlobalMemoryStatusEx , która ustawia element członkowski ullTotalPhys struktury MEMORYSTATUSEX na ilość pamięci fizycznej, która jest dostępna dla systemu operacyjnego. Ilość pamięci dostępnej dla systemu operacyjnego może być mniejsza niż ilość pamięci fizycznie zainstalowanej w komputerze, ponieważ system BIOS i niektóre sterowniki mogą rezerwować pamięć jako regiony we / wy dla urządzeń mapowanych w pamięci, przez co pamięć jest niedostępna dla systemu operacyjnego i aplikacje.

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 używasz Mono, możesz być zainteresowany, aby wiedzieć, że Mono 2.8 (który zostanie wydany jeszcze w tym roku) będzie miał licznik wydajności, który zgłasza rozmiar pamięci fizycznej na wszystkich platformach, na których działa Mono (w tym Windows). Wartość licznika można pobrać za pomocą 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 jesteś zainteresowany kodem C, który zapewnia licznik wydajności, możesz go znaleźć tutaj .

Innym sposobem, aby to zrobić, jest użycie narzędzi do wykonywania zapytań .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;

Dla tych, którzy korzystają, .net Core 3.0nie ma potrzeby korzystania z PInvokeplatformy w celu uzyskania dostępnej pamięci fizycznej. GCKlasa wprowadził nową metodę GC.GetGCMemoryInfo, która zwraca GCMemoryInfo Structsię TotalAvailableMemoryBytesw postaci nieruchomości. Ta właściwość zwraca całkowitą dostępną pamięć dla modułu odśmiecania pamięci. (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 odniesienie

using Microsoft.VisualBasic.Devices;

a 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 w systemie Windows XP i nowszych:

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

Stosowanie:

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 ComputerInfokodu źródłowego is PerformanceCounterdla Mono i jako kopia zapasowa 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ł o GetPerformanceInfo . Podpisy PInvoke są dostępne.

Ta funkcja udostępnia następujące informacje o całym systemie:

• CommitTotal
• CommitLimit
• CommitPeak
• Suma fizyczna
• Fizyczny Dostępny
• SystemCache
• KernelTotal
• KernelPaged
• KernelNonpaged
• Rozmiar strony
• HandleCount
• ProcessCount
• Ilość wątków

PhysicalTotaljest tym, czego szuka OP, chociaż wartością jest liczba stron, więc aby przekonwertować na bajty, należy pomnożyć przez PageSizezwróconą wartość.

.NIT ma ograniczenie łącznej ilości pamięci, do której może uzyskać dostęp. Jest procent, a następnie 2 GB w xp to twardy sufit.

Możesz mieć w nim 4 GB i zabije aplikację, gdy osiągnie 2 GB.

Również w trybie 64-bitowym istnieje procent pamięci, którego możesz użyć poza systemem, więc nie jestem pewien, czy możesz poprosić o całość, czy też jest to specjalnie chronione.

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