Click to Rate and Give Feedback
MSDN
MSDN Library
.NET Development
.NET Framework 3.5
Process Class
 PrivateMemorySize64 Property

  Switch on low bandwidth view
This page is specific to
Microsoft Visual Studio 2008/.NET Framework 3.5

Other versions are also available for the following:
.NET Framework Class Library
Process..::.PrivateMemorySize64 Property

Gets the amount of private memory allocated for the associated process.

Namespace:  System.Diagnostics
Assembly:  System (in System.dll)
Visual Basic (Declaration)
<ComVisibleAttribute(False)> _
Public ReadOnly Property PrivateMemorySize64 As Long
Visual Basic (Usage)
Dim instance As Process
Dim value As Long

value = instance.PrivateMemorySize64
C#
[ComVisibleAttribute(false)]
public long PrivateMemorySize64 { get; }
Visual C++
[ComVisibleAttribute(false)]
public:
property long long PrivateMemorySize64 {
    long long get ();
}
JScript
public function get PrivateMemorySize64 () : long

Property Value

Type: System..::.Int64
The amount of memory, in bytes, allocated for the associated process that cannot be shared with other processes.
ExceptionCondition
PlatformNotSupportedException

The platform is Windows 98 or Windows Millennium Edition (Windows Me), which does not support this property.

The value returned by this property represents the current size of memory used by the process that cannot be shared with other processes.

This property can be used to monitor memory usage on computers with 32-bit processors or 64-bit processors. The property value is equivalent to the Private Bytes performance counter for the process.

Windows 98, Windows Millennium Edition Platform Note:

This property is not supported on Windows 98 or Windows Millennium Edition (Windows Me).

The following code example starts an instance of the Notepad application. The example then retrieves and displays various properties of the associated process. The example detects when the process exits, and displays its exit code and peak memory statistics.

Visual Basic
Imports System
Imports System.Diagnostics

Namespace ProcessSample
   Class ProcessMonitorSample

      Public Shared Sub Main()

         ' Define variables to track the peak
         ' memory usage of the process.
         Dim peakPagedMem As Long = 0
         Dim peakWorkingSet As Long = 0
         Dim peakVirtualMem As Long = 0

         Dim myProcess As Process = Nothing

         Try

            ' Start the process.
            myProcess = Process.Start("NotePad.exe")

            ' Display process statistics until
            ' the user closes the program.
            Do

                If Not myProcess.HasExited Then

                    ' Refresh the current process property values.
                    myProcess.Refresh()

                    Console.WriteLine()

                    ' Display current process statistics.

                    Console.WriteLine("{0} -", myProcess.ToString())
                    Console.WriteLine("-------------------------------------")

                    Console.WriteLine("  physical memory usage: {0}", _
                         myProcess.WorkingSet64)
                    Console.WriteLine("  base priority: {0}", _
                         myProcess.BasePriority)
                    Console.WriteLine("  priority class: {0}", _
                         myProcess.PriorityClass)
                    Console.WriteLine("  user processor time: {0}", _
                         myProcess.UserProcessorTime)
                    Console.WriteLine("  privileged processor time: {0}", _
                         myProcess.PrivilegedProcessorTime)
                    Console.WriteLine("  total processor time: {0}", _
                         myProcess.TotalProcessorTime)

                    ' Update the values for the overall peak memory statistics.
                    peakPagedMem = myProcess.PeakPagedMemorySize64
                    peakVirtualMem = myProcess.PeakVirtualMemorySize64
                    peakWorkingSet = myProcess.PeakWorkingSet64

                    If myProcess.Responding Then
                        Console.WriteLine("Status = Running")
                    Else
                        Console.WriteLine("Status = Not Responding")
                    End If
                End If
            Loop While Not myProcess.WaitForExit(1000)

            Console.WriteLine()
            Console.WriteLine("Process exit code: {0}", myProcess.ExitCode)

            ' Display peak memory statistics for the process.
            Console.WriteLine("Peak physical memory usage of the process: {0}", _
                peakWorkingSet)
            Console.WriteLine("Peak paged memory usage of the process: {0}", _
                peakPagedMem)
            Console.WriteLine("Peak virtual memory usage of the process: {0}", _
                peakVirtualMem)

         Finally
            If Not myProcess Is Nothing Then
                myProcess.Close
            End If
         End Try
      End Sub 'Main
   End Class 
End Namespace 

C#
using System;
using System.Diagnostics;

namespace ProcessSample
{
    class ProcessMonitorSample
    {
        public static void Main()
        {

            // Define variables to track the peak
            // memory usage of the process.
            long peakPagedMem = 0, 
                peakWorkingSet = 0, 
                peakVirtualMem = 0;

            Process myProcess = null;

            try 
            {
                // Start the process.
                myProcess = Process.Start("NotePad.exe");

                // Display the process statistics until
                // the user closes the program.
                do 
                {
                    if (!myProcess.HasExited)
                    {
                        // Refresh the current process property values.
                        myProcess.Refresh();

                        Console.WriteLine();

                        // Display current process statistics.

                        Console.WriteLine("{0} -", myProcess.ToString());
                        Console.WriteLine("-------------------------------------");

                        Console.WriteLine("  physical memory usage: {0}",
                            myProcess.WorkingSet64);
                        Console.WriteLine("  base priority: {0}",
                            myProcess.BasePriority);
                        Console.WriteLine("  priority class: {0}",
                            myProcess.PriorityClass);
                        Console.WriteLine("  user processor time: {0}",
                            myProcess.UserProcessorTime);
                        Console.WriteLine("  privileged processor time: {0}",
                            myProcess.PrivilegedProcessorTime);
                        Console.WriteLine("  total processor time: {0}",
                            myProcess.TotalProcessorTime);

                        // Update the values for the overall peak memory statistics.
                        peakPagedMem = myProcess.PeakPagedMemorySize64;
                        peakVirtualMem = myProcess.PeakVirtualMemorySize64;
                        peakWorkingSet = myProcess.PeakWorkingSet64;

                        if (myProcess.Responding)
                        {
                            Console.WriteLine("Status = Running");
                        }
                        else
                        {
                            Console.WriteLine("Status = Not Responding");
                        }
                    }
                }
                while (!myProcess.WaitForExit(1000));


                Console.WriteLine();
                Console.WriteLine("Process exit code: {0}", 
                    myProcess.ExitCode);

                // Display peak memory statistics for the process.
                Console.WriteLine("Peak physical memory usage of the process: {0}",
                    peakWorkingSet);
                Console.WriteLine("Peak paged memory usage of the process: {0}",
                    peakPagedMem);
                Console.WriteLine("Peak virtual memory usage of the process: {0}",
                    peakVirtualMem);

            } 
            finally
            {
                if (myProcess != null)
                {
                    myProcess.Close();
                }
            }
        }

    }
}

Visual C++
#using <system.dll>

using namespace System;
using namespace System::Diagnostics;
int main()
{

   // Define variables to track the peak
   // memory usage of the process.
   _int64 peakPagedMem = 0,peakWorkingSet = 0,peakVirtualMem = 0;
   Process^ myProcess = nullptr;
   try
   {

      // Start the process.
      myProcess = Process::Start( "NotePad.exe" );

      // Display the process statistics until
      // the user closes the program.
      do
      {
         if (  !myProcess->HasExited )
         {

            // Refresh the current process property values.
            myProcess->Refresh();
            Console::WriteLine();

            // Display current process statistics.
            Console::WriteLine( "{0} -", myProcess );
            Console::WriteLine( "-------------------------------------" );
            Console::WriteLine( "  physical memory usage: {0}", myProcess->WorkingSet64 );
            Console::WriteLine( "  base priority: {0}", myProcess->BasePriority );
            Console::WriteLine( "  priority class: {0}", myProcess->PriorityClass );
            Console::WriteLine( "  user processor time: {0}", myProcess->UserProcessorTime );
            Console::WriteLine( "  privileged processor time: {0}", myProcess->PrivilegedProcessorTime );
            Console::WriteLine( "  total processor time: {0}", myProcess->TotalProcessorTime );

            // Update the values for the overall peak memory statistics.
            peakPagedMem = myProcess->PeakPagedMemorySize64;
            peakVirtualMem = myProcess->PeakVirtualMemorySize64;
            peakWorkingSet = myProcess->PeakWorkingSet64;
            if ( myProcess->Responding )
            {
               Console::WriteLine( "Status = Running" );
            }
            else
            {
               Console::WriteLine( "Status = Not Responding" );
            }
         }
      }
      while (  !myProcess->WaitForExit( 1000 ) );
      Console::WriteLine();
      Console::WriteLine( "Process exit code: {0}", myProcess->ExitCode );

      // Display peak memory statistics for the process.
      Console::WriteLine( "Peak physical memory usage of the process: {0}", peakWorkingSet );
      Console::WriteLine( "Peak paged memory usage of the process: {0}", peakPagedMem );
      Console::WriteLine( "Peak virtual memory usage of the process: {0}", peakVirtualMem );
   }
   finally
   {
      if ( myProcess != nullptr )
      {
         myProcess->Close();
      }
   }

}


  • LinkDemand 

    for full trust for the immediate caller. This member cannot be used by partially trusted code.

Windows 7, Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2008 R2, Windows Server 2008, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98

The .NET Framework and .NET Compact Framework do not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

.NET Framework

Supported in: 3.5, 3.0, 2.0
Tags What's this?: Add a tag
Community Content   What is Community Content?
Add new content RSS  Annotations
Negative numbers      trailway   |   Edit   |   Show History
There is a bug where PrivateMemorySize64 will sometimes return negative numbers. This occurs when it is called from a 32 bit host program (via COM) which has the large address aware bit set -and- the private bytes exceeds 2 GB. In such cases you have to add 4 GB to the return value in order to get the correct result.
Tags What's this?: Add a tag
Flag as ContentBug
Processing
© 2009 Microsoft Corporation. All rights reserved. Terms of Use  |  Trademarks  |  Privacy Statement
Page view tracker