Process Sınıf

Tanım

Ad Alanı:

System.Diagnostics

Bütünleştirilmiş Kod:

System.Diagnostics.Process.dll

Kaynak:

Process.cs

Yerel ve uzak işlemlere erişim sağlar ve yerel sistem işlemlerini başlatmanızı ve durdurmanızı sağlar.

public ref class Process : System::ComponentModel::Component, IDisposable

public class Process : System.ComponentModel.Component, IDisposable

type Process = class
    inherit Component
    interface IDisposable

Public Class Process
Inherits Component
Implements IDisposable

Devralma

Object

MarshalByRefObject

Component

Process

Uygulamalar

IDisposable

Örnekler

Aşağıdaki örnek, bir işlemi başlatmak için Process sınıfının bir örneğini kullanır.

#using <System.dll>
using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

int main()
{
    Process^ myProcess = gcnew Process;

    try
    {
        myProcess->StartInfo->UseShellExecute = false;
        // You can start any process, HelloWorld is a do-nothing example.
        myProcess->StartInfo->FileName = "C:\\HelloWorld.exe";
        myProcess->StartInfo->CreateNoWindow = true;
        myProcess->Start();
        // This code assumes the process you are starting will terminate itself. 
        // Given that it is started without a window so you cannot terminate it 
        // on the desktop, it must terminate itself or you can do it programmatically
        // from this application using the Kill method.
    }
    catch ( Exception^ e ) 
    {
        Console::WriteLine( e->Message );
    }
}

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        public static void Main()
        {
            try
            {
                using (Process myProcess = new Process())
                {
                    myProcess.StartInfo.UseShellExecute = false;
                    // You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe";
                    myProcess.StartInfo.CreateNoWindow = true;
                    myProcess.Start();
                    // This code assumes the process you are starting will terminate itself.
                    // Given that it is started without a window so you cannot terminate it
                    // on the desktop, it must terminate itself or you can do it programmatically
                    // from this application using the Kill method.
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

open System.Diagnostics

try
    use myProcess = new Process()
    myProcess.StartInfo.UseShellExecute <- false
    // You can start any process, HelloWorld is a do-nothing example.
    myProcess.StartInfo.FileName <- @"C:\HelloWorld.exe"
    myProcess.StartInfo.CreateNoWindow <- true
    myProcess.Start() |> ignore
// This code assumes the process you are starting will terminate itself.
// Given that it is started without a window so you cannot terminate it
// on the desktop, it must terminate itself or you can do it programmatically
// from this application using the Kill method.
with e ->
    printfn $"{e.Message}"

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        Public Shared Sub Main()
            Try
                Using myProcess As New Process()

                    myProcess.StartInfo.UseShellExecute = False
                    ' You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe"
                    myProcess.StartInfo.CreateNoWindow = True
                    myProcess.Start()
                    ' This code assumes the process you are starting will terminate itself. 
                    ' Given that it is started without a window so you cannot terminate it 
                    ' on the desktop, it must terminate itself or you can do it programmatically
                    ' from this application using the Kill method.
                End Using
            Catch e As Exception
                Console.WriteLine((e.Message))
            End Try
        End Sub
    End Class
End Namespace

Aşağıdaki örnek, bir işlemi başlatmak için Process sınıfını ve statik bir Start yöntemini kullanır.

#using <System.dll>

using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

// Opens the Internet Explorer application.
void OpenApplication(String^ myFavoritesPath)
{
    // Start Internet Explorer. Defaults to the home page.
    Process::Start("IExplore.exe");

    // Display the contents of the favorites folder in the browser.
    Process::Start(myFavoritesPath);
}

// Opens urls and .html documents using Internet Explorer.
void OpenWithArguments()
{
    // URLs are not considered documents. They can only be opened
    // by passing them as arguments.
    Process::Start("IExplore.exe", "www.northwindtraders.com");

    // Start a Web page using a browser associated with .html and .asp files.
    Process::Start("IExplore.exe", "C:\\myPath\\myFile.htm");
    Process::Start("IExplore.exe", "C:\\myPath\\myFile.asp");
}

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
void OpenWithStartInfo()
{
    ProcessStartInfo^ startInfo = gcnew ProcessStartInfo("IExplore.exe");
    startInfo->WindowStyle = ProcessWindowStyle::Minimized;
    Process::Start(startInfo);
    startInfo->Arguments = "www.northwindtraders.com";
    Process::Start(startInfo);
}

int main()
{
    // Get the path that stores favorite links.
    String^ myFavoritesPath = Environment::GetFolderPath(Environment::SpecialFolder::Favorites);
    OpenApplication(myFavoritesPath);
    OpenWithArguments();
    OpenWithStartInfo();
}

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
        {
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");

            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        }

        // Opens urls and .html documents using Internet Explorer.
        void OpenWithArguments()
        {
            // url's are not considered documents. They can only be opened
            // by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com");

            // Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.htm");
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.asp");
        }

        // Uses the ProcessStartInfo class to start new processes,
        // both in a minimized mode.
        void OpenWithStartInfo()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;

            Process.Start(startInfo);

            startInfo.Arguments = "www.northwindtraders.com";

            Process.Start(startInfo);
        }

        static void Main()
        {
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);

            MyProcess myProcess = new MyProcess();

            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
        }
    }
}

module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

    // Start a Web page using a browser associated with .html and .asp files.
    Process.Start("IExplore.exe", @"C:\myPath\myFile.htm") |> ignore
    Process.Start("IExplore.exe", @"C:\myPath\myFile.asp") |> ignore

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
openWithStartInfo ()

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")

            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub

        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")

            ' Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\myPath\myFile.htm")
            Process.Start("IExplore.exe", "C:\myPath\myFile.asp")
        End Sub

        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized

            Process.Start(startInfo)

            startInfo.Arguments = "www.northwindtraders.com"

            Process.Start(startInfo)
        End Sub

        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)

            Dim myProcess As New MyProcess()

            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample

Aşağıdaki F# örneği, bir işlemi başlatan, tüm çıkış ve hata bilgilerini yakalayan ve işlemin çalıştırdığı milisaniye sayısını kaydeden bir runProc işlevi tanımlar. runProc işlevinin üç parametresi vardır: başlatacak uygulamanın adı, uygulamaya sağlamak için bağımsız değişkenler ve başlangıç dizini.

open System
open System.Diagnostics

let runProc filename args startDir : seq<string> * seq<string> = 
    let timer = Stopwatch.StartNew()
    let procStartInfo = 
        ProcessStartInfo(
            RedirectStandardOutput = true,
            RedirectStandardError = true,
            UseShellExecute = false,
            FileName = filename,
            Arguments = args
        )
    match startDir with | Some d -> procStartInfo.WorkingDirectory <- d | _ -> ()

    let outputs = System.Collections.Generic.List<string>()
    let errors = System.Collections.Generic.List<string>()
    let outputHandler f (_sender:obj) (args:DataReceivedEventArgs) = f args.Data
    use p = new Process(StartInfo = procStartInfo)
    p.OutputDataReceived.AddHandler(DataReceivedEventHandler (outputHandler outputs.Add))
    p.ErrorDataReceived.AddHandler(DataReceivedEventHandler (outputHandler errors.Add))
    let started = 
        try
            p.Start()
        with | ex ->
            ex.Data.Add("filename", filename)
            reraise()
    if not started then
        failwithf "Failed to start process %s" filename
    printfn "Started %s with pid %i" p.ProcessName p.Id
    p.BeginOutputReadLine()
    p.BeginErrorReadLine()
    p.WaitForExit()
    timer.Stop()
    printfn "Finished %s after %A milliseconds" filename timer.ElapsedMilliseconds
    let cleanOut l = l |> Seq.filter (fun o -> String.IsNullOrEmpty o |> not)
    cleanOut outputs,cleanOut errors

runProc işlevinin kodu ImaginaryDevelopment tarafından yazılmıştır ve Microsoft Genel Lisansaltında kullanılabilir.

Açıklamalar

Process bileşeni, bilgisayarda çalışan bir işleme erişim sağlar. En basit ifadeyle işlem, çalışan bir uygulamadır. İş parçacığı, işletim sisteminin işlemci süresini ayırdığı temel birimdir. İş parçacığı, şu anda başka bir iş parçacığı tarafından yürütülen parçalar da dahil olmak üzere işlemin kodunun herhangi bir bölümünü yürütebilir.

Process bileşeni uygulamaları başlatmak, durdurmak, denetlemek ve izlemek için kullanışlı bir araçtır. çalışan işlemlerin listesini almak için Process bileşenini kullanabilir veya yeni bir işlem başlatabilirsiniz. Sistem işlemlerine erişmek için bir Process bileşeni kullanılır. bir Process bileşeni başlatıldıktan sonra, çalışan işlem hakkında bilgi almak için kullanılabilir. Bu bilgiler iş parçacıkları kümesini, yüklenen modülleri (.dll ve .exe dosyaları) ve işlemin kullandığı bellek miktarı gibi performans bilgilerini içerir.

Bu tür IDisposable arabirimini uygular. Türünü kullanmayı bitirdiğinizde, doğrudan veya dolaylı olarak atmalısınız. Türü doğrudan atmak için Dispose yöntemini bir try/finally bloğunda çağırın. Bunu dolaylı olarak atmak için using (C#'de) veya Using (Visual Basic'te) gibi bir dil yapısı kullanın. Daha fazla bilgi için IDisposable arabirimi belgelerindeki "IDisposable Uygulayan Bir Nesne Kullanma" bölümüne bakın.

Önemli

Güvenilmeyen verilerle bu sınıftan yöntemleri çağırmak bir güvenlik riskidir. Bu sınıftaki yöntemleri yalnızca güvenilen verilerle çağırın. Daha fazla bilgi için bkz. Tüm Girişleri Doğrulama.

Not

32 bit işlemler 64 bitlik bir işlemin modüllerine erişemez. 32 bit işlemden 64 bit işlem hakkında bilgi almaya çalışırsanız, Win32Exception özel durumu alırsınız. Öte yandan 64 bitlik bir işlem, 32 bit işlemin modüllerine erişebilir.

İşlem bileşeni, bir grup özellik hakkındaki bilgileri bir kerede alır. Process bileşeni herhangi bir grubun üyesi hakkında bilgi aldıktan sonra, bu gruptaki diğer özelliklerin değerlerini önbelleğe alır ve siz Refresh yöntemini çağırana kadar grubun diğer üyeleri hakkında yeni bilgiler almaz. Bu nedenle, bir özellik değerinin Refresh yöntemine yapılan son çağrıdan daha yeni olması garanti edilmemektedir. Grup dökümleri işletim sistemine bağımlıdır.

Sisteminizde tırnak işaretleri kullanılarak bildirilen bir yol değişkeniniz varsa, bu konumda bulunan herhangi bir işlemi başlatırken bu yolu tam olarak nitelemeniz gerekir. Aksi takdirde sistem yolu bulamaz. Örneğin, c:\mypath yolunuz içinde değilse ve tırnak işaretlerini kullanarak eklerseniz: path = %path%;"c:\mypath", c:\mypath'da başlatırken tüm işlemleri tam olarak nitelemeniz gerekir.

Sistem işlemi, işlem tanımlayıcısı tarafından sistemde benzersiz olarak tanımlanır. Birçok Windows kaynağında olduğu gibi, bir işlem de tanıtıcısı tarafından tanımlanır ve bu işlem bilgisayarda benzersiz olmayabilir. Tanıtıcı, bir kaynağın tanımlayıcısı için genel terimdir. İşletim sistemi, işlemden çıkıldığında bile Process bileşeninin Handle özelliği aracılığıyla erişilen işlem tutamacını kalıcı hale gelir. Böylece, ExitCode (genellikle başarı için sıfır veya sıfır olmayan bir hata kodu) ve ExitTimegibi işlemin yönetim bilgilerini alabilirsiniz. Tanıtıcılar son derece değerli bir kaynaktır, bu nedenle tutamaçların sızması bellek sızıntısından daha verimlidir.

Not

Bu sınıf, tüm üyeler için geçerli olan sınıf düzeyinde bir bağlantı talebi ve devralma talebi içerir. Hemen çağıranın veya türetilen sınıfın tam güven izni olmadığında bir SecurityException oluşturulur. Güvenlik talepleri hakkında ayrıntılı bilgi için bkz. Bağlantı Talepleri.

.NET Core Notları

.NET Framework'te, Process sınıfı giriş, çıkış ve hata akışları için genellikle kod sayfası kodlamaları olan Console kodlamalarını varsayılan olarak kullanır. Örneğin kod, kültürü İngilizce (ABD) olan sistemlerde kod sayfası 437, Console sınıfı için varsayılan kodlamadır. Ancak.NET Core, bu kodlamaların yalnızca sınırlı bir alt kümesini kullanılabilir hale getirebilir. Bu durumda, varsayılan kodlama olarak Encoding.UTF8 kullanır.

nesnesi belirli kod sayfası kodlamalarına bağlıysa, yöntemlerini çağırmadan önce aşağıdaki yaparak bunları kullanıma sunabilirsiniz:

1. CodePagesEncodingProvider.Instance özelliğinden EncodingProvider nesnesini alın.

2. Kodlama sağlayıcısı tarafından desteklenen ek kodlamaları kullanılabilir hale getirmek için EncodingProvider nesnesini Encoding.RegisterProvider yöntemine geçirin.

Process sınıfı, herhangi bir Process yöntemini çağırmadan önce kodlama sağlayıcısını kaydettiyseniz UTF8 yerine varsayılan sistem kodlamasını otomatik olarak kullanır.

Oluşturucular

Process()

Process sınıfının yeni bir örneğini başlatır.

Özellikler

BasePriority	İlişkili işlemin temel önceliğini alır.
CanRaiseEvents	Bileşenin olay oluşturup oluşturamayacağını belirten bir değer alır. (Devralındığı yer: Component)
Container	Componentiçeren IContainer alır. (Devralındığı yer: Component)
DesignMode	Component şu anda tasarım modunda olup olmadığını gösteren bir değer alır. (Devralındığı yer: Component)
EnableRaisingEvents	İşlem sonlandırıldığında Exited olayının tetiklenip tetiklenmemesi gerektiğini alır veya ayarlar.
Events	Bu Componenteklenen olay işleyicilerinin listesini alır. (Devralındığı yer: Component)
ExitCode	İlişkili işlemin sonlandırıldığında belirttiği değeri alır.
ExitTime	İlişkili işlemin çıkış zamanını alır.
Handle	İlişkili işlemin yerel tanıtıcısını alır.
HandleCount	İşlem tarafından açılan tanıtıcı sayısını alır.
HasExited	İlişkili işlemin sonlandırılıp sonlandırılmadığını gösteren bir değer alır.
Id	İlişkili işlemin benzersiz tanımlayıcısını alır.
MachineName	İlişkili işlemin üzerinde çalıştığı bilgisayarın adını alır.
MainModule	İlişkili işlem için ana modülü alır.
MainWindowHandle	İlişkili işlemin ana penceresinin pencere tutamacını alır.
MainWindowTitle	İşlemin ana penceresinin resim yazısını alır.
MaxWorkingSet	İlişkili işlem için izin verilen en büyük çalışma kümesi boyutunu bayt cinsinden alır veya ayarlar.
MinWorkingSet	İlişkili işlem için izin verilen en düşük çalışma kümesi boyutunu bayt cinsinden alır veya ayarlar.
Modules	İlişkili işlem tarafından yüklenen modülleri alır.
NonpagedSystemMemorySize	Geçersiz. İlişkili işlem için ayrılan disk belleği olmayan sistem belleği miktarını bayt cinsinden alır.
NonpagedSystemMemorySize64	İlişkili işlem için ayrılan disk belleği olmayan sistem belleği miktarını bayt cinsinden alır.
PagedMemorySize	Geçersiz. İlişkili işlem için ayrılan disk belleği belleği miktarını bayt cinsinden alır.
PagedMemorySize64	İlişkili işlem için ayrılan disk belleği belleği miktarını bayt cinsinden alır.
PagedSystemMemorySize	Geçersiz. İlişkili işlem için ayrılan disk belleğine atanabilir sistem belleği miktarını bayt cinsinden alır.
PagedSystemMemorySize64	İlişkili işlem için ayrılan disk belleğine atanabilir sistem belleği miktarını bayt cinsinden alır.
PeakPagedMemorySize	Geçersiz. sanal bellek disk belleği dosyasındaki en fazla bellek miktarını, ilişkili işlem tarafından kullanılan bayt cinsinden alır.
PeakPagedMemorySize64	sanal bellek disk belleği dosyasındaki en fazla bellek miktarını, ilişkili işlem tarafından kullanılan bayt cinsinden alır.
PeakVirtualMemorySize	Geçersiz. İlişkili işlem tarafından kullanılan maksimum sanal bellek miktarını bayt cinsinden alır.
PeakVirtualMemorySize64	İlişkili işlem tarafından kullanılan maksimum sanal bellek miktarını bayt cinsinden alır.
PeakWorkingSet	Geçersiz. İlişkili işlemin en yüksek çalışma kümesi boyutunu bayt cinsinden alır.
PeakWorkingSet64	İlişkili işlem tarafından kullanılan maksimum fiziksel bellek miktarını bayt cinsinden alır.
PriorityBoostEnabled	Ana pencerede odak olduğunda ilişkili işlem önceliğinin işletim sistemi tarafından geçici olarak artırılması gerekip gerekmediğini belirten bir değer alır veya ayarlar.
PriorityClass	İlişkili işlem için genel öncelik kategorisini alır veya ayarlar.
PrivateMemorySize	Geçersiz. İlişkili işlem için ayrılan bayt cinsinden özel bellek miktarını alır.
PrivateMemorySize64	İlişkili işlem için ayrılan bayt cinsinden özel bellek miktarını alır.
PrivilegedProcessorTime	Bu işlem için ayrıcalıklı işlemci süresini alır.
ProcessName	İşlemin adını alır.
ProcessorAffinity	Bu işlemdeki iş parçacıklarının çalıştırılacak şekilde zamanlanabileceği işlemcileri alır veya ayarlar.
Responding	İşlemin kullanıcı arabiriminin yanıt verip vermediğini belirten bir değer alır.
SafeHandle	Bu işlemin yerel tanıtıcısını alır.
SessionId	İlişkili işlemin Terminal Hizmetleri oturum tanımlayıcısını alır.
Site	Component ISite alır veya ayarlar. (Devralındığı yer: Component)
StandardError	Uygulamanın hata çıkışını okumak için kullanılan bir akış alır.
StandardInput	Uygulamanın girişini yazmak için kullanılan bir akış alır.
StandardOutput	Uygulamanın metin çıkışını okumak için kullanılan bir akış alır.
StartInfo	Process Start() yöntemine geçirecek özellikleri alır veya ayarlar.
StartTime	İlişkili işlemin başlatıldığı zamanı alır.
SynchronizingObject	İşlem çıkış olayının sonucu olarak verilen olay işleyici çağrılarını sıralamak için kullanılan nesneyi alır veya ayarlar.
Threads	İlişkili işlemde çalışan iş parçacıkları kümesini alır.
TotalProcessorTime	Bu işlem için toplam işlemci süresini alır.
UserProcessorTime	Bu işlem için kullanıcı işlemci süresini alır.
VirtualMemorySize	Geçersiz. İşlemin sanal belleğinin boyutunu bayt cinsinden alır.
VirtualMemorySize64	İlişkili işlem için ayrılan bayt cinsinden sanal bellek miktarını alır.
WorkingSet	Geçersiz. İlişkili işlemin fiziksel bellek kullanımını bayt cinsinden alır.
WorkingSet64	İlişkili işlem için ayrılan fiziksel bellek miktarını bayt cinsinden alır.

Yöntemler

BeginErrorReadLine()	Uygulamanın yeniden yönlendirilen StandardError akışında zaman uyumsuz okuma işlemlerini başlatır.
BeginOutputReadLine()	Uygulamanın yeniden yönlendirilen StandardOutput akışında zaman uyumsuz okuma işlemlerini başlatır.
CancelErrorRead()	Bir uygulamanın yeniden yönlendirilen StandardError akışında zaman uyumsuz okuma işlemini iptal eder.
CancelOutputRead()	Bir uygulamanın yeniden yönlendirilen StandardOutput akışında zaman uyumsuz okuma işlemini iptal eder.
Close()	Bu bileşenle ilişkili tüm kaynakları serbesttir.
CloseMainWindow()	Ana penceresine yakın bir ileti göndererek kullanıcı arabirimine sahip bir işlemi kapatır.
CreateObjRef(Type)	Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm ilgili bilgileri içeren bir nesne oluşturur. (Devralındığı yer: MarshalByRefObject)
Dispose()	Componenttarafından kullanılan tüm kaynakları serbest bırakır. (Devralındığı yer: Component)
Dispose(Boolean)	Bu işlem tarafından kullanılan tüm kaynakları serbest bırakın.
EnterDebugMode()	Geçerli iş parçacığında yerel özellik SeDebugPrivilege etkinleştirerek özel modda çalışan işletim sistemi işlemleriyle etkileşime geçmek için bir Process bileşenini duruma getirir.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetCurrentProcess()	Yeni bir Process bileşeni alır ve o anda etkin olan işlemle ilişkilendirir.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetLifetimeService()	Geçersiz. Bu örnek için yaşam süresi ilkesini denetleen geçerli yaşam süresi hizmet nesnesini alır. (Devralındığı yer: MarshalByRefObject)
GetProcessById(Int32, String)	İşlem tanımlayıcısı ve ağdaki bir bilgisayarın adı verilip yeni bir Process bileşeni döndürür.
GetProcessById(Int32)	Yerel bilgisayardaki bir işlemin tanımlayıcısı göz önüne alındığında yeni bir Process bileşeni döndürür.
GetProcesses()	Yerel bilgisayardaki her işlem kaynağı için yeni bir Process bileşeni oluşturur.
GetProcesses(String)	Belirtilen bilgisayardaki her işlem kaynağı için yeni bir Process bileşeni oluşturur.
GetProcessesByName(String, String)	Yeni Process bileşenlerinden oluşan bir dizi oluşturur ve bunları belirtilen işlem adını paylaşan uzak bir bilgisayardaki tüm işlem kaynaklarıyla ilişkilendirir.
GetProcessesByName(String)	Yeni Process bileşenlerinden oluşan bir dizi oluşturur ve bunları belirtilen işlem adını paylaşan yerel bilgisayardaki tüm işlem kaynaklarıyla ilişkilendirir.
GetService(Type)	Component veya Containertarafından sağlanan bir hizmeti temsil eden bir nesnesi döndürür. (Devralındığı yer: Component)
GetType()	Geçerli örneğin Type alır. (Devralındığı yer: Object)
InitializeLifetimeService()	Geçersiz. Bu örneğin yaşam süresi ilkesini denetlemek için bir yaşam süresi hizmet nesnesi alır. (Devralındığı yer: MarshalByRefObject)
Kill()	İlişkili işlemi hemen durdurur.
Kill(Boolean)	İlişkili işlemi ve isteğe bağlı olarak alt/alt işlemlerini hemen durdurur.
LeaveDebugMode()	Özel modda çalışan işletim sistemi işlemleriyle etkileşim kurmasını sağlayan Process bileşeni durumundan çıkarır.
MemberwiseClone()	Geçerli Objectbasit bir kopyasını oluşturur. (Devralındığı yer: Object)
MemberwiseClone(Boolean)	Geçerli MarshalByRefObject nesnesinin sığ bir kopyasını oluşturur. (Devralındığı yer: MarshalByRefObject)
OnExited()	Exited olayını başlatır.
Refresh()	İşlem bileşeninde önbelleğe alınmış ilişkili işlem hakkındaki tüm bilgileri atar.
Start()	Bu Process bileşeninin StartInfo özelliği tarafından belirtilen işlem kaynağını başlatır (veya yeniden kullanabilir) ve bileşenle ilişkilendirir.
Start(ProcessStartInfo)	İşlem başlangıç bilgilerini (örneğin, başlatacak işlemin dosya adı) içeren parametresi tarafından belirtilen işlem kaynağını başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.
Start(String, IEnumerable<String>)	Bir uygulamanın adını ve bir dizi komut satırı bağımsız değişkenini belirterek bir işlem kaynağı başlatır.
Start(String, String, SecureString, String)	Bir uygulamanın adını, kullanıcı adını, parolayı ve etki alanını belirterek bir işlem kaynağı başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.
Start(String, String, String, SecureString, String)	Bir uygulamanın adını, bir dizi komut satırı bağımsız değişkenini, kullanıcı adını, parolayı ve etki alanını belirterek bir işlem kaynağı başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.
Start(String, String)	Bir uygulamanın adını ve bir dizi komut satırı bağımsız değişkenini belirterek bir işlem kaynağı başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.
Start(String)	Belgenin veya uygulama dosyasının adını belirterek bir işlem kaynağı başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.
ToString()	İşlem adını, varsa üst bileşen türüyle birlikte bir dize olarak biçimlendirin.
WaitForExit()	Process bileşenine, ilişkili işlemin çıkması için süresiz olarak beklemesini sağlar.
WaitForExit(Int32)	Process bileşenine, ilişkili işlemin çıkması için belirtilen sayıda milisaniye beklemesini sağlar.
WaitForExit(TimeSpan)	İşlem bileşenine, ilişkili işlemin çıkması için belirtilen süreyi beklemesini sağlar.
WaitForExitAsync(CancellationToken)	İşlem bileşenine, ilişkili işlemin çıkışını beklemesini veya cancellationToken iptal etmesini ister.
WaitForInputIdle()	Process bileşeninin, ilişkili işlemin boşta duruma girmesi için süresiz olarak beklemesine neden olur. Bu aşırı yükleme yalnızca kullanıcı arabirimine ve dolayısıyla ileti döngüsüne sahip işlemler için geçerlidir.
WaitForInputIdle(Int32)	Process bileşeninin, ilişkili işlemin boşta duruma girmesi için belirtilen sayıda milisaniye beklemesine neden olur. Bu aşırı yükleme yalnızca kullanıcı arabirimine ve dolayısıyla ileti döngüsüne sahip işlemler için geçerlidir.
WaitForInputIdle(TimeSpan)	Process bileşeninin, ilişkili işlemin boşta duruma girmesi için belirtilen timeout beklemesine neden olur. Bu aşırı yükleme yalnızca kullanıcı arabirimine ve dolayısıyla ileti döngüsüne sahip işlemler için geçerlidir.

Ekinlikler

Disposed	Bileşen Dispose() yöntemine yapılan bir çağrıyla atıldığında gerçekleşir. (Devralındığı yer: Component)
ErrorDataReceived	Bir uygulama yeniden yönlendirilen StandardError akışına yazdığında gerçekleşir.
Exited	İşlemden çıkıldığında gerçekleşir.
OutputDataReceived	Bir uygulama yeniden yönlendirilen StandardOutput akışına her satır yazdığında gerçekleşir.

Ayrıca bkz.

• Start()
• ProcessStartInfo
• CloseMainWindow()
• Kill()
• ProcessThread