Как узнать RAM Usage (использование оперативки) какого-нибудь процесса в .NET?

#include <windows.h>

#include <psapi.h>
#pragma comment (lib, "psapi.lib")

#include <iostream>




int main (void)
{  
    // берем хэндл на процесс
    HANDLE hProcess = GetCurrentProcess();
    // инициализируем структуру
    PROCESS_MEMORY_COUNTERS pmc;
    ZeroMemory(&pmc, sizeof(PROCESS_MEMORY_COUNTERS));
   
    // заполняем структуру инфой о нужном нам процессе
    GetProcessMemoryInfo(hProcess, &pmc, sizeof(PROCESS_MEMORY_COUNTERS));

    std::cout << "Peak usage: " << pmc.PeakWorkingSetSize / 1024 << "kb" << std::endl;
    std::cout << "Current usage: " << pmc.WorkingSetSize / 1024 << "kb" << std::endl;

    return 0;
}

#include <windows.h>
#include <string.h>

// подключаем toolhelp32 и PSAPI
#include <tlhelp32.h>
#include <psapi.h>
#pragma comment (lib, "psapi.lib")

// не бум заморачиваться с окнами, в данном контексте нам это не нужно
#include <iostream>


// используя toolhelp32 напишем функцию которая будет нам возвращать идентификатор
// процесса по имени, если функция завершилась удачно, возвращаем идентификатор процесса
// в противном случае возвращаем -1 и устанавливаем коды ошибок
#define A_SUCCES                    0x0     // все нормально
#define A_PROCESS_NOT_FOUND         0x1     // процесс с заданным именем не существует
#define A_FUNCTION_INTERNAL_ERROR   0x2     // внутренняя ошибка функции(невозможно сделать снимок и т.д.)
       
DWORD GetProcessByName(const char* proc_name)
{
    // делаем снимок процессов
    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
   
    // проверяем что все нормально
    if (hSnapshot == INVALID_HANDLE_VALUE) {
        // если не удалось создать снимок, устанавливаем код ошибки (внутренняя ошибка)
        SetLastError(A_FUNCTION_INTERNAL_ERROR);
        // и выходим
        return -1;
    }

    // со снимком все нормально идем дальше

    // инициализируем структуру PROCESSENTRY32
    PROCESSENTRY32 pe32;
    ZeroMemory(&pe32, sizeof(PROCESSENTRY32));
    pe32.dwSize = sizeof(PROCESSENTRY32);

   
   
    // прыгаем на первый процесс
    BOOL bError;
    bError = Process32First(hSnapshot, &pe32);
    if (bError == FALSE) {
        SetLastError(A_FUNCTION_INTERNAL_ERROR);
        return -1;
    }


    // сравниваем
    if ((::strcmp(pe32.szExeFile, proc_name))== 0) {
        CloseHandle(hSnapshot);
        SetLastError(A_SUCCES);
        return pe32.th32ProcessID;
    }


    // перебираем процессы дальше

    while (bError!= FALSE) {
       
        bError = Process32Next(hSnapshot, &pe32);

        if ((::strcmp(pe32.szExeFile, proc_name)) == 0) {
            CloseHandle(hSnapshot);
            SetLastError(A_SUCCES);
            return pe32.th32ProcessID;
        }
    }
    // процесс с заданным именем не найден
    SetLastError(A_PROCESS_NOT_FOUND);
    return -1;
}






int main (void)
{  


    char *proc_n = "calc.exe";
    char *spy_mod = "D:\\Development\\spymod.dll";
    char *spy_info_file = "D:\\spyinfo.spy";
    int length_spy_mod = ::strlen(spy_mod) + 1;


    // ищем нужный процесс и обрабатываем ошибки
    DWORD pid = GetProcessByName(proc_n);
    if (pid == -1) {
        if (GetLastError() == A_PROCESS_NOT_FOUND) {
            std::cout << "Process " << proc_n << " not found" << std::endl;
            return 0;
        } else {
            std::cout << "Error in function GetProcessByName. Need to Debug" << std::endl;
            return 0;
        }
    }
   
    // нужно же что-то сообщить
    std::cout << "Process " << proc_n << " found with ID = " << pid << std::endl;

    // подготавливаемся к внедрению нашего шпиона в адресное пространство изучаемого процесса
   

   
    // оттолкнемся от того, что скорее всего kernel32.dll расположен в адресном пространство изучаемого
    // процеса по тому же базовому адресу что и в нашем
    PVOID pfLoadLibraryA = GetProcAddress(GetModuleHandle("kernel32"), "LoadLibraryA");

    // пытаемся открыть нужный нам процес с правами на создание потоков и блоков памяти,
    // а также записи в память и синхронизации
    HANDLE hProcess = OpenProcess(PROCESS_CREATE_THREAD | PROCESS_VM_OPERATION | PROCESS_VM_WRITE | SYNCHRONIZE,
        FALSE, pid);
    // здесь стоит проверить, получили ли мы дескриптор, потому что для некоторых
    // процессов система нам может отказать в открытии с такими правами
    // пока забьем на это, ибо не думаю что калькулятор представляет особую ценность для безопасности системы


    // теперь воспользуясь тем что прототип функции процесса и прототип LoadLibraryA выглядят очень и очень схоже
    // заставим исследуемый процесс загрузить нашего шпиона в свое адресное пространство, для этого:
    // 1) создадим в его адресном пространстве блок памяти и запишем туда строку с именем нашего шпиона
    char* remote_buf =(char*) VirtualAllocEx(hProcess, NULL, length_spy_mod, MEM_COMMIT, PAGE_READWRITE);
    WriteProcessMemory(hProcess, remote_buf, spy_mod, length_spy_mod, NULL);

    // 2) создадим в нем поток, подсунув адрес LoadLibraryA, вместо функции потока
    HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0,(LPTHREAD_START_ROUTINE) pfLoadLibraryA, remote_buf, 0, NULL);

    //3) ожидаем завершения работы потока
    WaitForSingleObject(hThread, INFINITE);
   
    //4) освобождаем выделенную память
    VirtualFreeEx(hProcess, remote_buf, 0, MEM_RELEASE);

    //5) все наш шпион успешно внедрен, сообщим об этом
    std::cout << "spymod.dll successfuly injected in " << proc_n << std::endl;
    std::cout << "Waiting process" << std::endl;

    // теперь нам осталось дождаться завершения процесса и прочесть данные собранные шпионом
    WaitForSingleObject(hProcess, INFINITE);

    std::cout << proc_n << " terminated" << std::endl;

    // прочтем данные собранные нашим шпионом
    PROCESS_MEMORY_COUNTERS pmc;
    ZeroMemory(&pmc, sizeof(PROCESS_MEMORY_COUNTERS));
    DWORD nb;
    HANDLE hSpyFile = CreateFile(spy_info_file, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    ReadFile(hSpyFile, &pmc, sizeof(pmc), &nb, NULL);
    CloseHandle(hSpyFile);

    // и выведем нужные нам
    std::cout << "Max process memory usage: " << pmc.PeakWorkingSetSize / 1024 << std::endl;
   

    return 0;
}

#include <windows.h>


// подключаем PSAPI
#include <psapi.h>
#pragma comment (lib, "psapi.lib")

BOOL WINAPI
DllMain (HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
{
    char *spy_info_file = "D:\\spyinfo.spy";
    HANDLE hSpyInfo;

    // при завершении процесса система вызовет DllMain с причиной DLL_PROCESS_DETACH
    if (fdwReason == DLL_PROCESS_DETACH)
    {
       
        // проинициализируем структуру PROCESS_MEMORY_COUNTERS
        PROCESS_MEMORY_COUNTERS pmc;
        ZeroMemory(&pmc, sizeof(PROCESS_MEMORY_COUNTERS));

        // заполним ее данными о текущем процессе
        GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(PROCESS_MEMORY_COUNTERS));

           
        // запишем данные о процессе в наш файлик
        DWORD nb;
        hSpyInfo = CreateFile(spy_info_file, FILE_ALL_ACCESS, 0, NULL, CREATE_ALWAYS, NULL, NULL);
        WriteFile(hSpyInfo, &pmc, sizeof(pmc), &nb, NULL);
        CloseHandle(hSpyInfo);

    }
   

    return TRUE;
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace ConsoleApplication11 {
    class Program {
        static void Main(string[] args) {
            List<Process> processes = new List<Process>(Process.GetProcesses());
            foreach (Process process in processes) {
                process.Exited += delegate(object sender, EventArgs e) {
                    Process exited_process = (Process)sender;
                    Console.WriteLine("Exited: {0}", exited_process);
                    Console.WriteLine("Peak virtual memory usage: {0}", exited_process.PeakVirtualMemorySize64);
                    Console.WriteLine("Peak working set size: {0}", exited_process.PeakWorkingSet64);
                };

                Console.WriteLine(process);
                try {
                    process.EnableRaisingEvents = true;
                } catch {
                    Console.WriteLine("Failed to subscribe 'Exited' event: {0}", process);
                }                
            }
            Console.ReadLine();
        }
    }
}

private string[] ExecuteCompiledFile(string login, int max_exec_time_limit, int max_ram_usage_limit)
        {
            string[] ReturnValues = new string[3];
            bool delegate_executed = false;
                System.Diagnostics.ProcessStartInfo si = new System.Diagnostics.ProcessStartInfo();

                si.FileName = System.IO.Path.GetFullPath(cnfgtn.WorkFolder + "\\" + login + "\\testFile.exe");
                si.WorkingDirectory = cnfgtn.WorkFolder + "\\" + login;
                si.CreateNoWindow = true;
                si.UseShellExecute = false;

                System.Diagnostics.Process p = System.Diagnostics.Process.Start(si);
                p.Exited += delegate(object sender, System.EventArgs e)
                {
                    ReturnValues[2] = ((System.Diagnostics.Process)sender).PeakWorkingSet64.ToString(); //здесь вылетает исключение
                    delegate_executed = true;
                };
                p.EnableRaisingEvents = true;

                p.WaitForExit(max_exec_time_limit * 1000);

                if (!p.HasExited)
                {
                    ReturnValues[0] = "Test file has overused time limit (" + max_exec_time_limit + " seconds) and was terminated";
                    if (!p.HasExited)
                        p.Kill();
                }

                while (!delegate_executed) //это уже от безысходности, чтоб исключить случай когда следующий код выполнится до завершения работы делегата
                    continue;

                if (System.Convert.ToInt32(ReturnValues[2]) > max_ram_usage_limit)
                    ReturnValues[0] = "Test file has overused RAM limit (" + max_ram_usage_limit + " bytes) and was terminated";
                ReturnValues[1] = (p.ExitTime - p.StartTime).TotalSeconds.ToString();

                p.Close();

            return ReturnValues;
        }