Wie erhält man die Gesamtmenge an RAM, über die der Computer verfügt?

Mit C # möchte ich die Gesamtmenge an RAM abrufen, über die mein Computer verfügt. Mit dem PerformanceCounter kann ich die Menge des verfügbaren RAM erhalten, indem ich Folgendes einstelle:

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

Aber ich kann anscheinend keinen Weg finden, um die gesamte Speichermenge zu erhalten. Wie würde ich das machen?

Aktualisieren:

MagicKat: Ich habe das gesehen, als ich gesucht habe, aber es funktioniert nicht - "Fehlt Ihnen eine Baugruppe oder Referenz?". Ich habe versucht, das zu den Referenzen hinzuzufügen, aber ich sehe es dort nicht.

Die Windows-API-Funktion GlobalMemoryStatusExkann mit p / invoke aufgerufen werden:

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

Dann benutze wie:

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

Oder Sie können WMI (verwaltet, aber langsamer) verwenden, um TotalPhysicalMemoryin der Win32_ComputerSystemKlasse abzufragen .

Fügen Sie einen Verweis auf Microsoft.VisualBasicund a hinzu using Microsoft.VisualBasic.Devices;.

Die ComputerInfoKlasse verfügt über alle Informationen, die Sie benötigen.

Fügen Sie einen Verweis auf Microsoft.VisualBasic.dll hinzu, wie oben erwähnt. Dann ist es so einfach, den gesamten physischen Speicher zu erhalten (ja, ich habe ihn getestet):

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

Alle Antworten hier, einschließlich der akzeptierten, geben Ihnen die Gesamtmenge an RAM, die zur Verwendung verfügbar ist . Und das war vielleicht das, was OP wollte.

Wenn Sie jedoch an der Menge des installierten Arbeitsspeichers interessiert sind , sollten Sie die Funktion GetPhysicallyInstalledSystemMemory aufrufen .

Über den Link im Abschnitt "Bemerkungen":

Die Funktion GetPhysicallyInstalledSystemMemory ruft die Menge des physisch installierten RAM aus den SMBIOS-Firmware-Tabellen des Computers ab. Dies kann von der von der GlobalMemoryStatusEx- Funktion gemeldeten Menge abweichen , mit der das ullTotalPhys-Mitglied der MEMORYSTATUSEX-Struktur auf die Menge an physischem Speicher festgelegt wird, die für das Betriebssystem verfügbar ist. Die für das Betriebssystem verfügbare Speichermenge kann geringer sein als die physisch auf dem Computer installierte Speichermenge, da das BIOS und einige Treiber möglicherweise Speicher als E / A-Bereiche für Geräte mit Speicherzuordnung reservieren und der Speicher für das Betriebssystem nicht verfügbar ist und Anwendungen.

Beispielcode:

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

Wenn Sie Mono verwenden, könnte es Sie interessieren, dass Mono 2.8 (das später in diesem Jahr veröffentlicht wird) über einen Leistungsindikator verfügt, der die physische Speichergröße auf allen Plattformen angibt, auf denen Mono ausgeführt wird (einschließlich Windows). Sie würden den Wert des Zählers mit diesem Codeausschnitt abrufen:

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

Wenn Sie an C-Code interessiert sind, der den Leistungsindikator bereitstellt, finden Sie ihn hier .

Eine andere Möglichkeit hierfür ist die Verwendung der .NET System.Management-Abfragefunktionen:

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;

Für diejenigen, die verwenden, .net Core 3.0ist es nicht erforderlich, die PInvokePlattform zu verwenden, um den verfügbaren physischen Speicher zu erhalten. Die GCKlasse hat eine neue Methode hinzugefügt GC.GetGCMemoryInfo, die ein GCMemoryInfo Structwith TotalAvailableMemoryBytesals Eigenschaft zurückgibt . Diese Eigenschaft gibt den insgesamt verfügbaren Speicher für den Garbage Collector zurück (gleicher Wert wie MEMORYSTATUSEX).

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

Sie können diesen Code einfach verwenden, um diese Informationen zu erhalten. Fügen Sie einfach die Referenz hinzu

using Microsoft.VisualBasic.Devices;

und verwenden Sie einfach den folgenden Code

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

Sie könnten WMI verwenden. Ich habe einen Ausschnitt gefunden.

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

Diese Funktion ( ManagementQuery) funktioniert unter Windows XP und höher:

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

Verwendung:

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

Kompatibel mit .Net und Mono (getestet mit Win10 / FreeBSD / CentOS)

Verwenden von ComputerInfoQuellcode und PerformanceCounters für Mono und als Backup für .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)))
            };
        }
    }
}

Bisher hat noch niemand GetPerformanceInfo erwähnt . PInvoke-Signaturen sind verfügbar.

Diese Funktion stellt folgende systemweite Informationen zur Verfügung:

• CommitTotal
• CommitLimit
• CommitPeak
• PhysicalTotal
• Physisch verfügbar
• SystemCache
• KernelTotal
• KernelPaged
• KernelNonpaged
• Seitengröße
• HandleCount
• ProcessCount
• Fadenzahl

PhysicalTotalist das, wonach das OP sucht, obwohl der Wert die Anzahl der Seiten ist. Um in Bytes umzuwandeln, multiplizieren Sie mit dem zurückgegebenen PageSizeWert.

.NIT hat eine Begrenzung für die Speichermenge, auf die insgesamt zugegriffen werden kann. Es gibt einen Prozentsatz und dann 2 GB in XP war die harte Decke.

Sie könnten 4 GB enthalten, und es würde die App töten, wenn es 2 GB erreicht.

Auch im 64-Bit-Modus gibt es einen Prozentsatz des Speichers, den Sie außerhalb des Systems verwenden können. Daher bin ich mir nicht sicher, ob Sie nach dem Ganzen fragen können oder ob dies speziell geschützt ist.

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