Wie erhalten Sie Gesamtmenge an RAM auf dem Computer?

Question

Mit C #, mag ich die Gesamtmenge an RAM erhalten, die mein Computer hat. Mit der Performance kann ich die Menge an verfügbarem RAM erhalten, indem Sie:

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

Aber ich kann nicht scheinen, einen Weg zu finden, um die Gesamtmenge des Speichers zu erhalten. Wie würde ich über das tun dies gehen?

Update:

Magickat: Ich sah, dass, wenn ich war auf der Suche, aber es funktioniert nicht - „Sind Sie eine Baugruppe oder Referenz fehlt?“. Ich habe sah, dass auf die Referenzen hinzuzufügen, aber ich sehe es nicht gibt.

Answer 1

Der p / aufrufen Art und Weise Bearbeiten : Geänderte zu GlobalMemoryStatusEx genaue Ergebnisse zu erhalten (heh)

  [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 verwenden wie:

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

Oder Sie WMI verwenden können (verwaltete aber langsamer) abfragen "Totalphysicalmemory" in der "Win32_ComputerSystem" -Klasse.

Bearbeiten festgelegter Code pro Kommentar von joel-llamaduck.blogspot.com

Answer 2

einen Verweis In den Microsoft.VisualBasic und using Microsoft.VisualBasic.Devices;.

Die ComputerInfo Klasse hat alle Informationen, die Sie benötigen.

Answer 3

Fügen Sie einen Verweis auf Microsoft.VisualBasic.dll, wie jemand oben erwähnt. Dann gesamter physischer Speicher bekommen, da dies so einfach ist (ja, Ich habe es getestet):

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

Answer 4

Wenn Sie Mono passieren zu verwenden, dann könnten Sie daran interessiert zu wissen, dass Mono 2.8 (die später in diesem Jahr veröffentlicht werden) einen Leistungsindikatoren haben, die die physikalische Speichergröße berichtet über alle Plattformen läuft Mono auf (einschließlich Windows ). Sie würden den Wert des Zählers mit diesem Code-Snippet 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 Interesse an C-Code sind, die den Leistungsindikator bietet, kann gefunden werden, hier .

Answer 5

die Antworten hier Alle, einschließlich der akzeptierten ein, werden Sie die Gesamtmenge an RAM verfügbar für den Einsatz. Und das auch gewesen sein mag, was OP wollte.

Aber wenn Sie daran interessiert sind, bekommen die Menge von installiert RAM, dann werden Sie einen Anruf an die GetPhysicallyInstalledSystemMemory Funktion.

Von dem Link im Abschnitt Bemerkung:

  

Die GetPhysicallyInstalledSystemMemory Funktion ruft die Menge an physikalisch installierte RAM von dem SMBIOS Firmware Tabellen des Computers. Dies kann aus dem durch die gemeldeten Betrag unterscheiden GlobalMemoryStatusEx Funktion, die das ullTotalPhys Mitglied der MEMORYSTATUSEX Struktur auf die Größe des physikalischen Speichers setzt, die verfügbar ist für das Betriebssystem zu verwenden. Die Menge des verfügbaren Speichers für das Betriebssystem kann als die Menge an Speicher weniger physisch auf dem Computer installiert , da das BIOS und einige Treiber kann der Speicher als E / A-Regionen reservieren für Memory-Mapped-Geräte, so dass der Speicher nicht verfügbar für das Betriebssystem 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.");
}

Answer 6

Eine andere Möglichkeit, dies zu tun, ist durch die .NET System.Management Abfrage Einrichtungen mit:

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;

Answer 7

Sie können einfach diesen Code verwenden, um diese Informationen zu erhalten, fügen Sie einfach den Verweis

using Microsoft.VisualBasic.Devices;

und die 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();
    }

Answer 8

Sie können WMI verwenden. Fand eine snippit.

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

Answer 9

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

Answer 10

Diese Funktion (ManagementQuery) arbeitet 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;
}

Verbrauch:

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

Answer 11

Niemand erwähnt hat GetPerformanceInfo noch. PInvoke Signaturen zur Verfügung stehen.

Diese Funktion macht die folgenden systemweiten Informationen zur Verfügung:

• CommitTotal
• CommitLimit
• CommitPeak
• PhysicalTotal
• PhysicalAvailable
• SystemCache
• KernelTotal
• KernelPaged
• KernelNonpaged
• Pagesize
• Handle
• ProcessCount
• Thread

PhysicalTotal ist, was die OP sucht, obwohl der Wert die Anzahl der Seiten ist, wenn man so Bytes zu konvertieren, multiplizieren Sie mit dem PageSize Wert zurückgegeben.

Answer 12

.NIT hat auf die Menge an Speicher, der eine Grenze es der Gesamt zugreifen können. Theres einen Prozentsatz, und dann 2 GB in xp war die Festdecke.

Sie können 4 GB an ihm haben, und es würde die App töten, wenn es 2GB getroffen.

Auch in 64-Bit-Modus gibt es einen Prozentsatz des Speichers können Sie aus dem System verwenden, so dass ich bin mir nicht sicher, ob Sie für die ganze Sache fragen können oder wenn dies ausdrücklich geschützt gegen.

Answer 13

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

Mit ComputerInfo Quellcode 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)))
            };
        }
    }
}

Answer 14

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