web-dev-qa-db-ja.com

合計RAMはコンピューターにありますか？

C＃を使用して、コンピューターのRAMの合計量を取得します。PerformanceCounterを使用して、使用可能なRAMの量を取得するには、次のように設定します。

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

しかし、メモリの総量を取得する方法を見つけることができないようです。これをどうやってやるの？

更新：

MagicKat：検索しているときにそれを見ましたが、機能しません-「アセンブリまたは参照がありませんか？」。私はそれを参照に追加しようとしましたが、そこには表示されません。

c#memoryperformancecounter
73
Joel

P/invoke方法[〜＃〜] edit [〜＃〜]：正確な結果を得るためにGlobalMemoryStatusExに変更されました（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);

次に、次のように使用します：

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

または、WMI（管理されているが低速）を使用して、「Win32_ComputerSystem」クラスの「TotalPhysicalMemory」を照会できます。

編集 joel-llamaduck.blogspot.comからのコメントごとのコードを修正

57
Philip Rieck

Microsoft.VisualBasicおよびusing Microsoft.VisualBasic.Devices;への参照を追加します。

ComputerInfoクラスには、必要なすべての情報が含まれています。

172
MagicKat

上記の誰かとして、Microsoft.VisualBasic.dllへの参照を追加します。合計物理メモリを取得するのは、これと同じくらい簡単です（はい、テストしました）：

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

Monoを使用している場合、Mono 2.8（今年後半にリリース予定）には、Monoが実行されているすべてのプラットフォーム（Windowsを含む）の物理メモリサイズを報告するパフォーマンスカウンターがあります。次のコードスニペットを使用して、カウンターの値を取得します。

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

パフォーマンスカウンターを提供するCコードに興味がある場合は、 here にあります。

29
grendel

ここでのすべての回答は、受け入れられたものを含め、RAM availableの合計量を使用に提供します。そして、それはOPが望んだことだったかもしれません。

しかし、installed RAMの量を取得することに興味がある場合は、 GetPhysicallyInstalledSystemMemoryを呼び出します。 関数。

リンクの[備考]セクションで：

GetPhysicallyInstalledSystemMemory 関数は、コンピューターのSMBIOSファームウェアテーブルから物理的にインストールされたRAMの量を取得します。これは、 GlobalMemoryStatusEx 関数によって報告される量とは異なる場合があります。この関数は、MEMORYSTATUSEX構造体のullTotalPhysメンバーを、オペレーティングシステムが使用できる物理メモリの量に設定します。 オペレーティングシステムで使用可能なメモリの量は、コンピューターに物理的にインストールされているメモリの量より少ない場合がありますメモリマップデバイスのI/O領域としてメモリを予約し、オペレーティングシステムとアプリケーションがメモリを使用できないようにします。

サンプルコード：

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

これを行う別の方法は、.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;
11
zgerd

このコードを使用してこれらの情報を取得し、参照を追加するだけです

using Microsoft.VisualBasic.Devices;

そして、単に次のコードを使用します

    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();
    }
6
Nilan Niyomal

WMIを使用できます。スニペットを見つけました。

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
4
CodeRot
// 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";
}
3
Mehul Sant

この関数（ManagementQuery）はWindows XP以降で動作します：

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

使用法：

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

.NITには、全体のアクセスできるメモリの量に制限があります。 Theresパーセンテージがあり、それからXPで2 GBが厳しい天井でした。

4 GBを使用できますが、2 GBに達するとアプリが終了します。

また、64ビットモードでは、システム外で使用できるメモリの割合があるため、すべてを要求できるかどうか、またはこれが特に保護されているかどうかはわかりません。

0
DevelopingChris

。NetおよびMonoと互換性がある（Win10/FreeBSD/CentOSでテスト済み）

MonoのComputerInfoソースコードとPerformanceCountersを使用し、.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)))
            };
        }
    }
}
0
Soroush Falahati

まだ誰も言及していません GetPerformanceInfo 。 PInvoke署名 が利用可能です。

この関数は、次のシステム全体の情報を利用可能にします。

  • CommitTotal
  • CommitLimit
  • CommitPeak
  • PhysicalTotal
  • 物理的
  • SystemCache
  • KernelTotal
  • KernelPaged
  • KernelNonpaged
  • ページサイズ
  • HandleCount
  • ProcessCount
  • スレッド数

PhysicalTotalはOPが探しているものですが、値はページ数なので、バイトに変換するには、返されるPageSize値を掛けます。

0
Roman Starkov