पिछले Section में हमने .NET Platform द्वारा Provide की जाने वाली Process Handling Capabilities के बारे में Discuss किया था। इस Section में हम System.Diagnostics Namespace द्वारा Provide की जाने वाली Functionalities को Use करते हुए कुछ Basic Programs Develop करने की कोशिश करेंगे।

File Name: RunningProcessList.cs
using System;
using System.Linq;
using System.Diagnostics;

namespace CSharpMultiThreading
{
    class MainMethodClass
    {
        static void Main()
        {
            ListAllRunningProcesses();
        }

        static void ListAllRunningProcesses()
        {
            // Get all the processes on the local machine, ordered by PID.
            var runningProcs = from proc in Process.GetProcesses(".") orderby proc.Id select proc;

            // Print out PID and name of each process.
            foreach (var p in runningProcs)
            {
                string info = string.Format("-> PID: {0}\tName: {1}", p.Id, p.ProcessName);
                Console.WriteLine(info);
            }
        }
    }
}

Output:
-> PID: 0	Name: Idle
-> PID: 4	Name: System
-> PID: 276	Name: smss
-> PID: 424	Name: avgrsa
-> PID: 476	Name: avgcsrva
. . .
. . .
-> PID: 9312	Name: chrome
-> PID: 9452	Name: dwm
-> PID: 9912	Name: AcroRd32
-> PID: 10048	Name: csrss

इस Program में हमने ListAllRunningProcesses नाम का एक Static Method Create किया है, जिसे Main() Method में Invoke किया गया है। जब ये Method Run होता है, तो सबसे पहले निम्नानुसार Statement Execute होता है:

var runningProcs = from proc in Process.GetProcesses(“.”) orderby proc.Id select proc;

इस Statement में हमने LINQ Query को Specify किया है, जहां Data Source के रूप में Process.GetProcesses(“.”) Expression को Specify किया है। ये Method Current Machine पर Run हो रहे सभी Process Objects की List को एक Array के रूप में Return करता है, जिसे अगले foreach Loop द्वारा One by One Enumerate करके एक-एक Process को Access किया है और हर Process Object के ID व Name को Id व ProcessName Properties को Use करते हुए Console पर Display कर दिया जाता है।

इस LINQ Query में हमने Process.GetProcesses() Method में एक Dot Specify किया है। जब हम इस Method में इस तरह से Dot Specify करते हैं, तो ये Dot Current Machine यानी Local Computer को Represent करता है।

इसी तरह से यदि हम किसी Specific Running Process को Access करना चाहें, तो हम Process.GetProcessById() नाम के Static Method को Use कर सकते हैं। ये Method हमें किसी Specify किए गए PID के माध्‍यम से किसी Single Process को Access करने की सुविधा Provide करता है।

जबकि यदि हम जो PID Specify कर रहे हैं, उस PID से Associated कोई Running Process न हो, तो ArgumentException नाम का एक Exception Throw होता है। इसलिए यदि हम किसी Specific PID वाले Process को Access करना चाहें, तो हमें try … catch Block का प्रयोग करते हुए अपना Code कुछ निम्नानुसार लिखना होता है:

File Name: AccessSpecificRunningProcessViaPID.cs
using System;
using System.Linq;
using System.Diagnostics;

namespace CSharpMultiThreading
{
    class MainMethodClass
    {
        static void Main()
        {
            GetSpecificProcess(1);
        }

        static void GetSpecificProcess(int pid)
        {
            Process theProc = null;
            try
            {
                theProc = Process.GetProcessById(pid);
                Console.WriteLine("Process Name: {0}", theProc.ProcessName);
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Output:
	Process with an Id of 1 is not running.

जब ये Program Run होता है तो GetSpecificProcess() नाम का Static Method Execute होता है जो कि Parameter के रूप में PID Accept करता है और यदि Argument के रूप में Specified PID से Associated कोई भी Process Run न हो रहा हो, तो ये Method एक Exception Generate करता है। परिणामस्वरूप हमें उपरोक्तानुसार Output प्राप्त होता है।

जबकि यदि हम Argument के रूप में जो PID Specify करते हैं, वह किसी Running Process का PID होता है, तो ये Program उस Running Process के Main Application का नाम Return करता है।

किसी Process में Run हो रहे विभिन्न Threads के Set को Strongly Typed ProcessThreadCollection नाम के Collection द्वारा प्राप्त किया जा सकता है, जिसमें बहुत सारे Individual ProcessThread Objects होते हैं। जैसे:

File Name: ProcessThreadSet.cs
using System;
using System.Linq;
using System.Diagnostics;

namespace CSharpMultiThreading
{
    class MainMethodClass
    {
        static void Main()
        {
            EnumThreadsForPid(9912);
        }

        static void EnumThreadsForPid(int pID)
        {
            Process theProc = null;
            try
            {
                theProc = Process.GetProcessById(pID);
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }

            // List out stats for each thread in the specified process.
            Console.WriteLine("Here are the threads used by: {0}", theProc.ProcessName);
            ProcessThreadCollection theThreads = theProc.Threads;

            foreach (ProcessThread pt in theThreads)
            {
                string info =
                string.Format("-> Thread ID: {0}\tStart Time: {1}\tPriority: {2}",
                pt.Id, pt.StartTime.ToShortTimeString(), pt.PriorityLevel);
                Console.WriteLine(info);
            }
        }
    }
}

Output:
Here are the threads used by: AcroRd32
-> Thread ID: 6688	Start Time: 7:55 AM	Priority: Normal
-> Thread ID: 9524	Start Time: 7:55 AM	Priority: Normal
-> Thread ID: 4904	Start Time: 7:55 AM	Priority: Normal
-> Thread ID: 6172	Start Time: 7:55 AM	Priority: Normal
-> Thread ID: 8076	Start Time: 7:55 AM	Priority: Normal
-> Thread ID: 6436	Start Time: 8:01 AM	Priority: Normal

जैसाकि हम देख सकते हैं कि System.Diagnostics.Process Type की Thread Property हमें ProcessThreadCollection Class को Access करने की सुविधा Provide करता है। इसलिए उपरोक्त Program में हमने Specified Process के सभी Threads के ID, Starting Time व Priority को Console में Output की तरह Display किया है।

ProcessThread Type में और भी कई Members हैं, जिन्हें हम उपयोग में ले सकते हैं और Particular Process के विभिन्न Threads के बारे में जानकारी प्राप्त कर सकते हैं। जिनमें से कुछ निम्नानुसार हैं:

CurrentPriority

ये Thread की Current Priority Return करता है।

Id

ये Thread का ID Return करता है।

IdealProcessor

ये Thread के Run होने के लिए लिए Preferred Processor Set करता है।

PriorityLevel

इसका प्रयोग करके हम किसी Thread का Priority Level Get या Set कर सकते हैं।

ProcessorAffinity

इसके माध्‍यम से उन Processes को Set कर सकते हैं जिस पर Associated Thread Run हो सकता है।

StartAddress

उस Function का Memory Address इसमें होता है, जिसने Invoke होकर Current Thread के लिए Operating System को Trigger किया है।

StartTime

इसके माध्‍यम से हम Thread के Running State में आने के समय का पता लगा सकते हैं।

ThreadState

इसके माध्‍यम से हम Thread की Current State का पता लगा सकते हैं।

TotalProcessorTime

इसके माध्‍यम से हम इस बात का पता लगा सकते हैं कि Current Thread ने Processor पर Execute होने के लिए कितना समय व्‍यतीत किया है।

WaitReason

इसके माध्‍यम से हम Thread के Wait करने के कारण को जान सकते हैं।

इससे पहले कि हम आगे बढें, यहां ध्‍यान रखने वाली एक बात ये है कि हम ProcessThread Type वह Entity नहीं है जिसका प्रयोग Threads को Create, Suspend या Kill करने के लिए किया जाए। बल्कि इसका प्रयोग मूल रूप से किसी Process के अन्दर Running Active Windows Threads से सम्बंधित Information Retrieve करने के लिए ही किया जाना चाहिए।

जबकि Thread Create करते हुए Multi-Threading Applications Develop करने के लिए .NET Framework हमें System.Threading नाम का एक दूसरा Namespace Provide करता है, जिसके बारे में हम आगे चर्चा करेंगे।

हम किसी Process के अन्दर Load होने वाले विभिन्न Loaded Modules के बारे में भी विभिन्न प्रकार की जानकारियां प्राप्त करने के लिए System.Diagnostics Namespace की Classes को Use कर सकते हैं। जब हम Processes की बात करते हैं, तो Module को General Terms में *.dll या *.exe के रूप में Identify किया जाता है, जो कि किसी Specific Process में Hosted होते हैं।

इसलिए जब हम ProcessModuleCollection को Process.Modules Property के माध्‍यम से Access करते हैं, तो हम किसी Process में Hosted विभिन्न Module को Enumerate कर सकते हैं, फिर भले ही वह Module .NET Based, COM Based या Traditional C-Based Library, किसी भी तरह का क्यों न हो। इसे समझने के लिए हम निम्नानुसार एक Example Program Create कर सकते हैं:

File Name: ProcessModuleSet.cs
using System;
using System.Linq;
using System.Diagnostics;

namespace CSharpMultiThreading
{
    class MainMethodClass
    {
        static void Main()
        {
            EnumModsForPid(9912);
        }

        static void EnumModsForPid(int pID)
        {
            Process theProc = null;

            try
            {
                theProc = Process.GetProcessById(pID);
            }
            catch (ArgumentException ex)
            {
                Console.WriteLine(ex.Message);
                return;
            }
            Console.WriteLine("Here are the loaded modules for: {0}", theProc.ProcessName);
            ProcessModuleCollection theMods = theProc.Modules;

            foreach (ProcessModule pm in theMods)
            {
                string info = string.Format("-> Module Name: {0}", pm.ModuleName);
                Console.WriteLine(info);
            }
        }
    }
}

Output:
Here are the loaded modules for: AcroRd32
-> Module Name: AcroRd32.exe
-> Module Name: ntdll.dll
-> Module Name: wow64.dll
-> Module Name: wow64win.dll
-> Module Name: wow64cpu.dll

जैसाकि हम इस Output द्वारा समझ सकते हैं इस Computer पर Run हो रहे Adobe Reader Process के लिए कुल पांच .dll Files यानी कुल पांच Modules Loaded हैं। इसी तरह से हम किसी भी Process का ID इस Program में Use करके उस Process द्वारा Load किए गए सभी Modules की List प्राप्त कर सकते हैं।

System.Diagnostics.Process Class हमें Start() और Kill() नाम के दो Methods Provide करता है, जिनका प्रयोग करके हम Programmatically किसी Process को Start या Stop कर सकते हैं। इसे समझने के लिए हम निम्नानुसार एक Program Create कर सकते हैं:

File Name: StartStopProcessProgramatically.cs
using System;
using System.Linq;
using System.Diagnostics;

namespace CSharpMultiThreading
{
    class MainMethodClass
    {
        static void Main()
        {
            StartAndKillProcess();
        }

        static void StartAndKillProcess()
        {
            Process ieProc = null;

            // Launch Internet Explorer, and go to facebook!
            try
            {
                ieProc = Process.Start("IExplore.exe", "www.bccfalna.com");
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }

            Console.Write("--> Hit enter to kill {0}...", ieProc.ProcessName);
            Console.ReadLine();

            // Kill the iexplore.exe process.
            try
            {
                ieProc.Kill();
            }
            catch (InvalidOperationException ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}

Output:
--> Hit enter to kill iexplore...

जैसे ही हम इस program को Run करते हैं, StartAndKillProcess() नाम का Method Invoke होता है और try Block में Enter करके निम्न Statement Run करता है:

ieProc = Process.Start(“IExplore.exe”, “www.bccfalna.com”);

इस Statement में Specified Process.Start() Method Automatically पहले Parameter के रूप में Specified Process यानी Internet Explorer Application को Run करता है और उसमें www.bccfalna.com नाम की Website को Load कर देता है। साथ ही Console में निम्नानुसार Statement द्वारा एक Message दिखाई देता है:

Console.Write(“–> Hit enter to kill {0}…”, ieProc.ProcessName);

जो इस बात को Indicate करता है कि Internet Explorer Process को Close करने के लिए Enter Key Press करना है। जैसे ही हम Enter Key Press करते हैं, हमारा Current Program ही निम्न Statement के माध्‍यम से Internet Explorer के ID को Use करते हुए उसे Close कर देता है:

ieProc.Kill();

क्योंकि जब Process.Start() Method Execute हुआ था, तब Internet Explorer का Reference ieProc नाम के Reference Variable में Store हो गया था, जिसे हमने उपरोक्त Statement द्वारा Close करने के लिए Kill() Method के साथ Use कर लिया है।

इस Program में हमने Process को Start व Stop करने के लिए Process.Start() व ieProc.Kill() Method दोनों को ही एक try Block में Specify किया है। क्योंकि यदि वह Process Exist न हो जिसे Start करना है या जिस Process को Programmatically Stop करना है, उसे पहले ही Manually Stop कर दिया गया हो, तो ये दोनों Methods InvalidOperationException नाम का Exception Generate करते हैं, जिसे catch Block में Handle कर लिया जाता है।

ProcessStartInfo Class का प्रयोग करके हम Start होने वाले Process को कई प्रकार की Predefined Settings के साथ Start कर सकते हैं। उदाहरण के लिए हम ऐसे Parameters Specify कर सकते हैं, जिससे Start होने वाला Process Maximized Window में ही Start हो।

Process Startup से सम्बंधित इन सभी Settings करने के लिए .NET Framework हमें ProcessStartInfo नाम की Class Provide करता है, जिसके विभिन्न Members की Detailed जानकारी प्राप्त करने के लिए हम .NET Framework 4.5 SDK Documentation देख सकते हैं और Visual Studio के Object Browser Utility का प्रयोग कर सकते हैं। (System.Diagnostics.Process.Start)