[C#] Process

Process 클래스

Process 클래스 (System.Diagnostics)

namespace System.Diagnostics
{
    public class Process : Component
    {
        // 속성, 주석 처리된 속성은 구버전에서 쓰던 것
        public ProcessPriorityClass PriorityClass { get; set; }
        public bool PriorityBoostEnabled { get; set; }
        public int BasePriority { get; }
 
        public long PeakVirtualMemorySize64 { get; }
        // public int PeakVirtualMemorySize { get; }
        public long PeakWorkingSet64 { get; }
        // public int PeakWorkingSet { get; }
        public long PeakPagedMemorySize64 { get; }
        // public int PeakPagedMemorySize { get; }
        public long PrivateMemorySize64 { get; }
        // public int PrivateMemorySize { get; }
        public long PagedSystemMemorySize64 { get; }
        // public int PagedSystemMemorySize { get; }
        public long PagedMemorySize64 { get; }
        // public int PagedMemorySize { get; }
        public long NonpagedSystemMemorySize64 { get; }
        // public int NonpagedSystemMemorySize { get; }
        public long WorkingSet64 { get; }
        // public int WorkingSet { get; }
        public long VirtualMemorySize64 { get; }
        // public int VirtualMemorySize { get; }
 
        public IntPtr MinWorkingSet { get; set; }
        public IntPtr MaxWorkingSet { get; set; }
 
        public ProcessModule MainModule { get; }
 
        public ProcessModuleCollection Modules { get; }
        public ProcessThreadCollection Threads { get; }
       
        public TimeSpan PrivilegedProcessorTime { get; }
        public TimeSpan UserProcessorTime { get; }
        public TimeSpan TotalProcessorTime { get; }
 
        public DateTime StartTime { get; }
        public DateTime ExitTime { get; }
 
        public bool HasExited { get; }
        public int ExitCode { get; }
        public bool EnableRaisingEvents { get; set; }
       
        public string MachineName { get; }
 
        public int Id { get; }
        public string ProcessName { get; }
        public int SessionId { get; }
        public string MainWindowTitle { get; }
 
        public int HandleCount { get; }
        public SafeProcessHandle SafeHandle { get; }
        public IntPtr Handle { get; }
        public IntPtr MainWindowHandle { get; }
 
        public bool Responding { get; }
 
        public StreamReader StandardError { get; }
        public StreamReader StandardOutput { get; }
        public StreamWriter StandardInput { get; }
 
        public IntPtr ProcessorAffinity { get; set; }        
 
        public ISynchronizeInvoke SynchronizingObject { get; set; }
 
        public ProcessStartInfo StartInfo { get; set; }
 
 
        // 이벤트
        public event EventHandler Exited;
        public event DataReceivedEventHandler ErrorDataReceived;
        public event DataReceivedEventHandler OutputDataReceived;
 
       
        // 정적 메서드
        public static void EnterDebugMode();
        public static void LeaveDebugMode();
 
        public static Process GetCurrentProcess();
        public static Process GetProcessById(int processId);
        public static Process GetProcessById(int processId, string machineName);
        public static Process[] GetProcesses();
        public static Process[] GetProcesses(string machineName);
        public static Process[] GetProcessesByName(string processName);
        public static Process[] GetProcessesByName(string processName, string machineName);
 
        public static Process Start(string fileName);
        public static Process Start(string fileName, string arguments);
        public static Process Start(string fileName, string userName, SecureString password, string domain);
        public static Process Start(string fileName, string arguments, string userName, SecureString password, string domain);
        public static Process Start(ProcessStartInfo startInfo);
 
 
        // 메서드
        public Process();
 
        public override string ToString();
 
        public void BeginErrorReadLine();
        public void CancelErrorRead();
        public void BeginOutputReadLine();
        public void CancelOutputRead();
       
        public bool Start();
        public void Refresh();
        public void Close();
        public bool CloseMainWindow();
        public void Kill();
        protected override void Dispose(bool disposing);
 
        public void WaitForExit();
        public bool WaitForExit(int milliseconds);
 
        public bool WaitForInputIdle();
        public bool WaitForInputIdle(int milliseconds);
 
        protected void OnExited();
    }
}


namespace System.Diagnostics
{
    public enum ProcessPriorityClass
    {
        Normal = 32,
        Idle = 64,
        High = 128,
        RealTime = 256,
        BelowNormal = 16384,
        AboveNormal = 32768
    }
}

ProcessModuleCollection 클래스

ProcessModuleCollection 클래스 (System.Diagnostics)

namespace System.Diagnostics
{
    public class ProcessModuleCollection : ReadOnlyCollectionBase
    {
        public ProcessModuleCollection(ProcessModule[] processModules);
        protected ProcessModuleCollection();
 
        public ProcessModule this[int index] { get; }
 
        public bool Contains(ProcessModule module);
        public void CopyTo(ProcessModule[] array, int index);
        public int IndexOf(ProcessModule module);
    }
}

ProcessModule 클래스

ProcessModule 클래스 (System.Diagnostics)

namespace System.Diagnostics
{
    public class ProcessModule : Component
    {
        public string ModuleName { get; }
        public string FileName { get; }
        public IntPtr BaseAddress { get; }
        public int ModuleMemorySize { get; }
        public IntPtr EntryPointAddress { get; }
        public FileVersionInfo FileVersionInfo { get; }
 
        public override string ToString();
    }
}

FileVersionInfo 클래스

FileVersionInfo 클래스 (System.Diagnostics)

namespace System.Diagnostics
{
    public sealed class FileVersionInfo
    {                
        public string FileVersion { get; }
        public int FileMajorPart { get; }
        public int FileMinorPart { get; }
        public int FileBuildPart { get; }
        public int FilePrivatePart { get; }
        public string FileName { get; }
        public string OriginalFilename { get; }
 
        public string ProductVersion { get; }
        public int ProductMinorPart { get; }
        public int ProductMajorPart { get; }
        public int ProductBuildPart { get; }
        public int ProductPrivatePart { get; }        
        public string ProductName { get; }
 
        public string SpecialBuild { get; }
        public bool IsSpecialBuild { get; }
 
        public string PrivateBuild { get; }
        public bool IsPrivateBuild { get; }
 
        public bool IsPreRelease { get; }
        public bool IsPatched { get; }
        public bool IsDebug { get; }
       
        public string InternalName { get; }
        public string Language { get; }
 
        public string CompanyName { get; }
        public string FileDescription { get; }
        public string Comments { get; }
 
        public string LegalTrademarks { get; }
        public string LegalCopyright { get; }
       
        public static FileVersionInfo GetVersionInfo(string fileName);
        public override string ToString();
    }
}

ProcessThreadCollection 클래스

ProcessThreadCollection 클래스 (System.Diagnostics)

namespace System.Diagnostics
{
    public class ProcessThreadCollection : ReadOnlyCollectionBase
    {
        protected ProcessThreadCollection();
        public ProcessThreadCollection(ProcessThread[] processThreads);
 
        public ProcessThread this[int index] { get; }
 
        public int Add(ProcessThread thread);
        public bool Contains(ProcessThread thread);
        public void CopyTo(ProcessThread[] array, int index);
        public int IndexOf(ProcessThread thread);
        public void Insert(int index, ProcessThread thread);
        public void Remove(ProcessThread thread);
    }
}

ProcessThread 클래스

namespace System.Diagnostics
{
    public class ProcessThread : Component
    {
        public int BasePriority { get; }
        public int CurrentPriority { get; }
        public bool PriorityBoostEnabled { get; set; }
        public ThreadPriorityLevel PriorityLevel { get; set; }
       
        public IntPtr StartAddress { get; }
 
        public int Id { get; }
 
        public DateTime StartTime { get; }
        public TimeSpan TotalProcessorTime { get; }
        public TimeSpan UserProcessorTime { get; }
        public TimeSpan PrivilegedProcessorTime { get; }
       
        public ThreadState ThreadState { get; }
        public ThreadWaitReason WaitReason { get; }
 
        public int IdealProcessor { set; }
        public IntPtr ProcessorAffinity { set; }
       
        public void ResetIdealProcessor();
    }
}

namespace System.Diagnostics
{
    public enum ThreadPriorityLevel
    {
        Idle = -15,
        Lowest = -2,
        BelowNormal = -1,
        Normal = 0,
        AboveNormal = 1,
        Highest = 2,
        TimeCritical = 15
    }
}

namespace System.Diagnostics
{
    public enum ThreadState
    {
        Initialized = 0,
        Ready = 1,
        Running = 2,
        Standby = 3,
        Terminated = 4,
        Wait = 5,
        Transition = 6,
        Unknown = 7
    }
}

namespace System.Diagnostics
{
    public enum ThreadWaitReason
    {
        Executive = 0,
        FreePage = 1,
        PageIn = 2,
        SystemAllocation = 3,
        ExecutionDelay = 4,
        Suspended = 5,
        UserRequest = 6,
        EventPairHigh = 7,
        EventPairLow = 8,
        LpcReceive = 9,
        LpcReply = 10,
        VirtualMemory = 11,
        PageOut = 12,
        Unknown = 13
    }
}

반응형

ProcessStartInfo 클래스

ProcessStartInfo 클래스 (System.Diagnostics)

namespace System.Diagnostics
{
    public sealed class ProcessStartInfo
    {
        public ProcessStartInfo();
        public ProcessStartInfo(string fileName);
        public ProcessStartInfo(string fileName, string arguments);
       
        public bool UseShellExecute { get; set; }
        public string WorkingDirectory { get; set; }
        public bool CreateNoWindow { get; set; }
        public ProcessWindowStyle WindowStyle { get; set; }
 
        public string FileName { get; set; }
        public string Verb { get; set; }
        public string[] Verbs { get; }
 
        public string Arguments { get; set; }
 
        public string Domain { get; set; }
        public string UserName { get; set; }
        public string PasswordInClearText { get; set; }
        public SecureString Password { get; set; }
               
        public bool ErrorDialog { get; set; }
        public IntPtr ErrorDialogParentHandle { get; set; }
 
        public bool LoadUserProfile { get; set; }
 
        public Encoding StandardOutputEncoding { get; set; }
        public Encoding StandardErrorEncoding { get; set; }
        public bool RedirectStandardError { get; set; }
        public bool RedirectStandardOutput { get; set; }
        public bool RedirectStandardInput { get; set; }
 
        public IDictionary<string, string> Environment { get; }
        public StringDictionary EnvironmentVariables { get; }    
    }
}


namespace System.Diagnostics
{
    public enum ProcessWindowStyle
    {
        Normal = 0,
        Hidden = 1,
        Minimized = 2,
        Maximized = 3
    }
}

---

Process 

- 새 프로세스를 띄우는 기능 제공

- 같은 컴퓨터, 원격 컴퓨터에서 실행되는 프로세스를 조사하거나 상호작용하는 수단도 제공

프로세스 시작과 대기

- Start

 * 파일 이름 하나(실행된 파일이 아닐 경우 확장자에 해당하는 등록된 파일이 실행 됨)

 * 파일 이름, 선택적 인수

 * ProcessStartInfo 인스턴스를 받는 버전

  : 프로세스의 입력, 출력, 오류 출력을 갈무리 및 재지정 가능

  : 출력을 재지정하지 않으면 주어진 프로그램을 호출자와 병렬로 실행

 

- WaitForExit

 * 프로세스의 종료 대기

 * 선택적 인수로 만료 대기 시간을 지정 가능

using System;
using System.Diagnostics;
 
namespace Practice
{
    class Program
    {
        static void Main(string[] args)
        {
            // 파일 열기, 파일이 없다면 예외 발생                      
            try
            {
                Process.Start("d:\\seo\\output_.txt");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
            // 실행 파일 지정
            try
            {
                Process.Start("notepad.exe", "d:\\seo\\output.txt");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
 
            // ProcessStartInfo
            ProcessStartInfo psi = new ProcessStartInfo
            {
                FileName = "cmd.exe",           // 실행 파일명
                Arguments = "/c ipconfig /all", // 명령 인자
                RedirectStandardOutput = true,  // 리다이렉션을 StandardOutput으로 설정
                UseShellExecute = false         // OS 쉘을 사용할지의 여부
            };
 
            Process p = Process.Start(psi);
            string result = p.StandardOutput.ReadToEnd();
            Console.WriteLine(result);
        }
    }
}

실행중인 프로세스 조사

- GetProcess... 

 1. 주어진 이름, 또는 프로세스 ID에 해당하는 프로세스를 나타내는 Process 인스턴스의 반환

 2. 현재 컴퓨터 또는 지정된 컴퓨터에서 실행되는 모든 프로세스(비관리 포함)에 관한 정보를 담은 Process 컬렉션

 * 각 Process 인스턴스에는 프로세스 이름, ID, 우선순위, 메모리, CPU 사용량, 창 핸들 같은 여러 속성이 있음

 

- GetCurrentProcess

 * 현재 프로세스를 돌려줌

 * 또 다른 응용 프로그램 도메인을 생성한 경우, 모든 도메인은 같은 프로세스를 공유

 

- Kill

 * 주어진 메소드에 대해서 Kill을 호출하면 해당 프로세스가 종료됨

 

프로세스 안의 스레드 조사

- Threads

 * 프로세스의 스레드들을 열거

 * System.Threading.Thread 객체 말고, 스레드 관리 작업을 위해 만들어진 ProcessThread를 돌려 줌

 * 바탕 스레드에 대한 진단 정보 제공, 우선순위나 친화도 같은 특정 측면을 변경할 수 있음

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
 
namespace Practice
{
    class Program
    {
        // 튜플 리스트
        public class PairList<TKey, TValue> : List<Tuple<TKey, TValue>>
        {
            public void Add(TKey key, TValue value)
            {
                Add(new Tuple<TKey, TValue>(key, value));
            }
        }
 
        // str를 받아와서 length 이상이면 뒤를 자르고, postfix를 붙힌 것을 돌려줌
        static string CutString(string str, int length, string postfix = "...")
        {
            if (str.Length > length)
            {
                str = str.Substring(0, length) + postfix;
            }
 
            return str;
        }
 
        // 제목부 출력
        static void PrintTitle(PairList<string, int> pairList, string titleName)
        {            
            Console.WriteLine(titleName);
 
            var lastItem = pairList.Last();
            foreach (var item in pairList)
            {
                Console.Write(item.Item1.PadLeft(item.Item2));
 
                if (lastItem != item)
                {
                    Console.Write(" | ");
                }
            }
            Console.WriteLine();
        }
 
        public static void Main(string[] arg)
        {
            // List<Tuple<Tkey, TValue>>
            var pairList = new PairList<string, int>();
 
 
            // 제목부 내용 입력
            pairList.Add("Process Name", 30);
            pairList.Add("PID", 5);
            pairList.Add("SID", 3);
            pairList.Add("P", 2);
            pairList.Add("Thread", 6);
            pairList.Add("WorkingSet", 10);
 
 
            // 제목부 출력
            PrintTitle(pairList, "----- Processes -----");
 
 
            // 모든 프로세스와 현재 프로세스 내용을 받아옴
            Process[] pcs = Process.GetProcesses();
            Process pcscur = Process.GetCurrentProcess();
 
 
            // 프로세스 내용 정렬
            // 1순위: 이름
            // 2순위: Process ID
            Array.Sort(pcs, (x, y) => (x.ProcessName == y.ProcessName ?
                                        x.Id.CompareTo(y.Id) :
                                        x.ProcessName.CompareTo(y.ProcessName)));
 
 
            // 각 항목 출력
            foreach (Process item in pcs)
            {
                using (item)
                {
                    // 현재 프로세스를 출력할 차례라면 색상을 변경해서 출력함
                    if (item.Id == pcscur.Id)
                    {
                        Console.ForegroundColor = ConsoleColor.Green;
                    }
 
                    Console.Write(CutString(item.ProcessName, pairList[0].Item2 - 3).PadLeft(pairList[0].Item2) + " | "); ;
                    Console.Write(item.Id.ToString().PadLeft(pairList[1].Item2) + " | ");
                    Console.Write(item.SessionId.ToString().PadLeft(pairList[2].Item2) + " | ");
                    Console.Write(item.BasePriority.ToString().PadLeft(pairList[3].Item2) + " | ");
                    Console.Write(item.Threads.Count.ToString().PadLeft(pairList[4].Item2) + " | ");
                    Console.Write(item.WorkingSet64.ToString().PadLeft(pairList[5].Item2));
 
                    if (item.Id == pcscur.Id)
                    {
                        Console.ForegroundColor = ConsoleColor.Gray;
                    }
                }
                Console.WriteLine();
            }
            Console.WriteLine();
 
 
            ////////////////////////////////////////////////////////////
            pairList.Clear();
 
 
            // 제목부 내용 기입
            pairList.Add("TID", 6);
            pairList.Add("State", 11);
            pairList.Add("WaitReason", 16);
            pairList.Add("PriorityLevel", 13);
            pairList.Add("StartTime", 9);
            pairList.Add("Total CPU Time", 14);
 
 
            // 제목부 출력
            PrintTitle(pairList, "----- Threads -----");
 
 
            // 각 항목 출력
            string tempString = null;
 
            foreach (ProcessThread item in pcscur.Threads)
            {
                Console.Write(item.Id.ToString().PadLeft(pairList[0].Item2) + " | ");
                Console.Write(item.ThreadState.ToString().PadLeft(pairList[1].Item2) + " | ");
 
                // WaitReason은 ThreadState가 Wait이 아니라면 예외를 출력함
                if (item.ThreadState == ThreadState.Wait)
                {
                    tempString = item.WaitReason.ToString();
                }
                else
                {
                    tempString = "-";
                }
                Console.Write(tempString.PadLeft(pairList[2].Item2) + " | ");
 
                Console.Write(item.PriorityLevel.ToString().PadLeft(pairList[3].Item2) + " | ");
                Console.Write(item.StartTime.ToString("HH:mm:ss").PadLeft(pairList[4].Item2) + " | ");
                Console.Write(item.TotalProcessorTime.ToString(@"hh\:mm\:ss\.ffff").PadLeft(pairList[5].Item2));
                Console.WriteLine();
            }
            Console.WriteLine();
 
 
            ////////////////////////////////////////////////////////////
            pairList.Clear();
 
            // 제목부 내용 기입
            pairList.Add("ModuleName", 30);
            pairList.Add("Base &", 10);
            pairList.Add(" EP  &", 10);
            pairList.Add("MemorySize", 10);
            pairList.Add("FileVersion", 40);
 
 
            // 제목부 출력
            PrintTitle(pairList, "----- Modules -----");
 
 
            // 각 항목 출력
            foreach (ProcessModule item in pcscur.Modules)
            {
                Console.Write(CutString(item.ModuleName, pairList[0].Item2 - 3).PadLeft(pairList[0].Item2) + " | ");
                Console.Write(item.BaseAddress.ToString("X").PadLeft(pairList[1].Item2) + " | ");
                Console.Write(item.EntryPointAddress.ToString("X").PadLeft(pairList[2].Item2) + " | ");
                Console.Write(item.ModuleMemorySize.ToString().PadLeft(pairList[3].Item2) + " | ");
                Console.Write(CutString(item.FileVersionInfo.FileVersion, pairList[4].Item2 - 3).PadLeft(pairList[4].Item2));
                Console.WriteLine();
            }
        }
    }
}