Come si ottiene la quantità totale di RAM di cui dispone il computer?

Utilizzando C #, voglio ottenere la quantità totale di RAM di cui dispone il mio computer. Con il PerformanceCounter posso ottenere la quantità di RAM disponibile, impostando:

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

Ma non riesco a trovare un modo per ottenere la quantità totale di memoria. Come potrei fare questo?

Aggiornare:

MagicKat: L'ho visto durante la ricerca, ma non funziona - "Ti manca un assembly o un riferimento?". Ho cercato di aggiungerlo ai riferimenti, ma non lo vedo lì.

La funzione API di Windows GlobalMemoryStatusExpuò essere chiamata con 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);

Quindi usa come:

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

Oppure puoi usare WMI (gestito ma più lento) per eseguire query TotalPhysicalMemorynella Win32_ComputerSystemclasse.

Aggiungi un riferimento a Microsoft.VisualBasice ausing Microsoft.VisualBasic.Devices; .

La ComputerInfoclasse ha tutte le informazioni di cui hai bisogno.

Aggiungi un riferimento a Microsoft.VisualBasic.dll, come qualcuno menzionato sopra. Quindi ottenere la memoria fisica totale è semplice come questo (sì, l'ho testato):

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

Tutte le risposte qui, inclusa quella accettata, ti daranno la quantità totale di RAM disponibile per l'uso. E forse era quello che voleva OP.

Ma se sei interessato a ottenere la quantità di RAM installata , allora ti consigliamo di effettuare una chiamata alla funzione GetPhysicallyInstalledSystemMemory .

Dal link, nella sezione Osservazioni:

La funzione GetPhysicallyInstalledSystemMemory recupera la quantità di RAM installata fisicamente dalle tabelle del firmware SMBIOS del computer. Ciò può essere diverso dalla quantità riportata dalla funzione GlobalMemoryStatusEx , che imposta il membro ullTotalPhys della struttura MEMORYSTATUSEX sulla quantità di memoria fisica che è disponibile per il sistema operativo da utilizzare. La quantità di memoria disponibile per il sistema operativo può essere inferiore alla quantità di memoria fisicamente installata nel computer perché il BIOS e alcuni driver possono riservare memoria come regioni di I / O per i dispositivi mappati in memoria, rendendo la memoria non disponibile per il sistema operativo e applicazioni.

Codice d'esempio:

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

Se ti capita di utilizzare Mono, potresti essere interessato a sapere che Mono 2.8 (che verrà rilasciato entro la fine dell'anno) avrà un contatore delle prestazioni che riporta la dimensione della memoria fisica su tutte le piattaforme su cui viene eseguito Mono (incluso Windows). Recupererai il valore del contatore utilizzando questo frammento di codice:

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

Se sei interessato al codice C che fornisce il contatore delle prestazioni, puoi trovarlo qui .

Un altro modo per eseguire questa operazione è utilizzare le funzionalità di query di .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;

Per coloro che stanno utilizzando .net Core 3.0non è necessario utilizzare la PInvokepiattaforma per ottenere la memoria fisica disponibile. La GCclasse ha aggiunto un nuovo metodo GC.GetGCMemoryInfoche restituisce a GCMemoryInfo Structcon TotalAvailableMemoryBytescome proprietà. Questa proprietà restituisce la memoria disponibile totale per il Garbage Collector. (Stesso valore di MEMORYSTATUSEX)

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

puoi semplicemente usare questo codice per ottenere quelle informazioni, basta aggiungere il riferimento

using Microsoft.VisualBasic.Devices;

e usa semplicemente il codice seguente

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

Potresti usare WMI. Trovato uno 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

Questa funzione ( ManagementQuery) funziona su Windows XP e versioni successive:

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

Utilizzo:

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

Compatibile con .Net e Mono (testato con Win10 / FreeBSD / CentOS)

Utilizzo del ComputerInfocodice sorgente PerformanceCounteres per Mono e come backup per .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)))
            };
        }
    }
}

Nessuno ha ancora menzionato GetPerformanceInfo . Le firme di PInvoke sono disponibili.

Questa funzione rende disponibili le seguenti informazioni a livello di sistema:

• CommitTotal
• CommitLimit
• CommitPeak
• PhysicalTotal
• PhysicalAvailable
• SystemCache
• KernelTotal
• KernelPaged
• KernelNonpaged
• Dimensioni della pagina
• HandleCount
• ProcessCount
• ThreadCount

PhysicalTotalè ciò che l'OP sta cercando, sebbene il valore sia il numero di pagine, quindi per convertire in byte, moltiplicare per il PageSizevalore restituito.

.NIT ha un limite alla quantità di memoria a cui può accedere rispetto al totale. C'è una percentuale, e poi 2 GB in xp erano il limite massimo.

Potresti avere 4 GB in esso e ucciderebbe l'app quando raggiunge 2 GB.

Anche in modalità 64 bit, c'è una percentuale di memoria che puoi usare fuori dal sistema, quindi non sono sicuro se puoi chiedere l'intera cosa o se questo è specificamente protetto.

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