Process Sınıf

Tanım

Yerel ve uzak işlemlere erişim sağlar ve yerel sistem süreçlerini başlatıp durdurmanızı sağlar.Provides access to local and remote processes and enables you to start and stop local system processes.

public ref class Process : System::ComponentModel::Component
public class Process : System.ComponentModel.Component
type Process = class
    inherit Component
Public Class Process
Inherits Component
Devralma

Örnekler

Aşağıdaki örnek, bir işlemi başlatmak için Process sınıfının bir örneğini kullanır.The following example uses an instance of the Process class to start a process.

#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 is 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 is 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);
            }
        }
    }
}
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 is 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ın kendisini ve statik Start yöntemini kullanır.The following example uses the Process class itself and a static Start method to start a process.

#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()
{
    // 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 = 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();
        }
    }
}
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()
            ' 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")
        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# örnek, işlem başlatan bir runProc işlevi tanımlar, tüm çıkış ve hata bilgilerini yakalar ve işlemin çalıştırıldığı milisaniye sayısını kaydeder.The following F# example defines a runProc function that starts a process, captures all output and error information, and records the number of milliseconds that the process has run. runProc işlevi üç parametreye sahiptir: başlatılacak uygulamanın adı, uygulamaya vereceğiniz bağımsız değişkenler ve başlangıç dizini.The runProc function has three parameters: the name of application to launch, the arguments to supply to the application, and the starting directory.

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şlevin kodu, ImaginaryDevelopment tarafından yazılmıştır ve Microsoft genel lisansıaltında bulunabilir.The code for the runProc function was written by ImaginaryDevelopment and is available under the Microsoft Public License.

Açıklamalar

Process bileşeni, bir bilgisayarda çalışan bir işleme erişim sağlar.A Process component provides access to a process that is running on a computer. En basit koşullarda bir işlem, çalışan bir uygulamadır.A process, in the simplest terms, is a running app. İş parçacığı, işletim sisteminin işlemci zamanını ayırdığı temel birimdir.A thread is the basic unit to which the operating system allocates processor time. Bir iş parçacığı, şu anda başka bir iş parçacığı tarafından yürütülen parçalar dahil olmak üzere, işlem kodunun herhangi bir bölümünü yürütebilir.A thread can execute any part of the code of the process, including parts currently being executed by another thread.

Process bileşeni, uygulamaları başlatmak, durdurmak, denetlemek ve izlemek için kullanışlı bir araçtır.The Process component is a useful tool for starting, stopping, controlling, and monitoring apps. Çalıştıran işlemlerin listesini almak için Process bileşenini kullanabilir veya yeni bir işlem başlatabilirsiniz.You can use the Process component, to obtain a list of the processes that are running, or you can start a new process. Process bileşeni, sistem işlemlerine erişmek için kullanılır.A Process component is used to access system processes. Process bileşen başlatıldıktan sonra, çalışan işlem hakkında bilgi almak için kullanılabilir.After a Process component has been initialized, it can be used to obtain information about the running process. Bu tür bilgiler iş parçacığı kümesini, yüklenen modülleri (. dll ve. exe dosyaları) ve işlemin kullandığı bellek miktarı gibi performans bilgilerini içerir.Such information includes the set of threads, the loaded modules (.dll and .exe files), and performance information such as the amount of memory the process is using.

Bu tür, IDisposable arabirimini uygular.This type implements the IDisposable interface. Türü kullanmayı bitirdiğinizde, bunu doğrudan veya dolaylı olarak atabilirsiniz.When you have finished using the type, you should dispose of it either directly or indirectly. Türü doğrudan atmak için Dispose yöntemini bir try/finally bloğunda çağırın.To dispose of the type directly, call its Dispose method in a try/finally block. Bunu dolaylı olarak atmak için using (içinde C#) veya Using (Visual Basic) gibi bir dil yapısı kullanın.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Daha fazla bilgi için, IDisposable arabirimi konusunun "IDisposable uygulayan bir nesne kullanma" bölümüne bakın.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Not

32-bit işlemler 64-bit bir işlemin modüllerine erişemez.32-bit processes cannot access the modules of a 64-bit process. 32-bit işlemden 64 bitlik bir işlem hakkında bilgi almaya çalışırsanız, Win32Exception bir özel durum alırsınız.If you try to get information about a 64-bit process from a 32-bit process, you will get a Win32Exception exception. Diğer yandan 64 bitlik bir işlem, 32 bitlik bir işlemin modüllerine erişebilir.A 64-bit process, on the other hand, can access the modules of a 32-bit process.

İşlem bileşeni her seferinde bir özellik grubu hakkında bilgi edinir.The process component obtains information about a group of properties all at once. Process bileşeni, herhangi bir grubun bir üyesi hakkında bilgi aldıktan sonra, bu gruptaki diğer özelliklerin değerlerini önbelleğe alarak, Refresh yöntemini çağırana kadar grubun diğer üyeleri hakkında yeni bilgiler almaz.After the Process component has obtained information about one member of any group, it will cache the values for the other properties in that group and not obtain new information about the other members of the group until you call the Refresh method. Bu nedenle, bir özellik değerinin Refresh metoduna yapılan son çağrıdan daha yeni olması garanti edilmez.Therefore, a property value is not guaranteed to be any newer than the last call to the Refresh method. Grup dökümleri, işletim sistemine bağımlıdır.The group breakdowns are operating-system dependent.

Tırnak işaretleri kullanılarak sisteminizde tanımlanmış bir yol değişkenine sahipseniz, bu konumda bulunan herhangi bir işlemi başlatırken bu yolu tam olarak nitelemeniz gerekir.If you have a path variable declared in your system using quotes, you must fully qualify that path when starting any process found in that location. Aksi takdirde, sistem yolu bulamaz.Otherwise, the system will not find the path. Örneğin, c:\mypath yolunuzda yoksa ve tırnak path = %path%;"c:\mypath"işaretleri kullanarak eklerseniz, bu işlem başlatıldığında c:\mypath herhangi bir işlemi tamamen nitelemeniz gerekir.For example, if c:\mypath is not in your path, and you add it using quotation marks: path = %path%;"c:\mypath", you must fully qualify any process in c:\mypath when starting it.

Bir sistem işlemi sistemde işlem tanımlayıcısı tarafından benzersiz şekilde tanımlanır.A system process is uniquely identified on the system by its process identifier. Birçok Windows kaynağı gibi, bir işlem de tanıtıcı tarafından tanımlanır ve bu da bilgisayarda benzersiz olmayabilir.Like many Windows resources, a process is also identified by its handle, which might not be unique on the computer. Tanıtıcı, bir kaynağın tanımlayıcısı için genel bir terimdir.A handle is the generic term for an identifier of a resource. İşletim sistemi, işlemden çıkılsa bile, Process bileşeninin Handle özelliğinden erişilen işlem tanıtıcısını sürdürür.The operating system persists the process handle, which is accessed through the Handle property of the Process component, even when the process has exited. Bu nedenle, ExitCode (genellikle başarılı veya sıfır olmayan bir hata kodu için sıfır) ve ExitTimegibi yönetim bilgilerini alabilirsiniz.Thus, you can get the process's administrative information, such as the ExitCode (usually either zero for success or a nonzero error code) and the ExitTime. Tutamaçlar son derece değerli bir kaynaktır; bu nedenle, sızan tanıtıcılar bellek sızıntısına kıyasla daha fazla viruödündir.Handles are an extremely valuable resource, so leaking handles is more virulent than leaking memory.

Not

Bu sınıf, bir bağlantı talebi ve tüm üyeler için geçerli olan sınıf düzeyinde devralma talebi içerir.This class contains a link demand and an inheritance demand at the class level that applies to all members. Hemen çağıran ya da türetilmiş sınıfın tam güven izni olmadığında SecurityException oluşur.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Güvenlik talepleri hakkında daha fazla bilgi için bkz. bağlantı talepleri.For details about security demands, see Link Demands.

.NET Core.NET Core notlarıNotes

.NET Framework, varsayılan olarak Process sınıfı, giriş, çıkış ve hata akışları için genellikle kod sayfası kodlamaları olan Console kodlamaları kullanır.In the .NET Framework, the Process class by default uses Console encodings, which are typically code page encodings, for the input, output, and error streams. Örneğin, kültürü Ingilizce (Birleşik Devletler) olan sistemlerde, kod sayfası 437 Console sınıfının varsayılan kodlamasıdır.For example code, on systems whose culture is English (United States), code page 437 is the default encoding for the Console class. Ancak .NET Core.NET Core, bu kodlamaları yalnızca sınırlı bir alt kümesini kullanılabilir hale gelebilir.However, .NET Core.NET Core may make only a limited subset of these encodings available. Bu durumda, varsayılan kodlama olarak Encoding.UTF8 kullanır.If this is the case, it uses Encoding.UTF8 as the default encoding.

Bir Process nesnesi belirli kod sayfası kodlarına bağımlıysa, herhangi bir Process yöntemini çağırmadan önce aşağıdakileri yaparak bunları kullanılabilir hale getirebilirsiniz:If a Process object depends on specific code page encodings, you can still make them available by doing the following before you call any Process methods:

  1. Projenize System. Text. Encoding. CodePages. dll derlemesine bir başvuru ekleyin.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. CodePagesEncodingProvider.Instance özelliğinden EncodingProvider nesnesini alın.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Kullanılabilir kodlama sağlayıcısı tarafından desteklenen ek kodlamaları yapmak için EncodingProvider nesnesini Encoding.RegisterProvider yöntemine geçirin.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Process sınıfı, herhangi bir Process yöntemini çağırmadan önce kodlama sağlayıcısını kaydettirdiğiniz için, UTF8 yerine varsayılan sistem kodlamasını otomatik olarak kullanacaktır.The Process class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any Process methods.

Oluşturucular

Process()

Process sınıfının yeni bir örneğini başlatır.Initializes a new instance of the Process class.

Özellikler

BasePriority

İlişkili işlemin temel önceliğini alır.Gets the base priority of the associated process.

CanRaiseEvents

Bileşenin bir olay yapıp yapamayacağını gösteren bir değer alır.Gets a value indicating whether the component can raise an event.

(Devralındığı yer: Component)
Container

Öğesini içeren öğesini alır. Component IContainerGets the IContainer that contains the Component.

(Devralındığı yer: Component)
DesignMode

Şu anda Tasarım modunda olup olmadığını Component gösteren bir değer alır.Gets a value that indicates whether the Component is currently in design mode.

(Devralındığı yer: Component)
EnableRaisingEvents

İşlem sonlandırıldığında Exited olayının oluşturulup oluşturulmayacağını alır veya ayarlar.Gets or sets whether the Exited event should be raised when the process terminates.

Events

Bu Componentöğesine eklenen olay işleyicilerinin listesini alır.Gets the list of event handlers that are attached to this Component.

(Devralındığı yer: Component)
ExitCode

Bir ilişkili işlemin sonlandırıldığında belirtilen değeri alır.Gets the value that the associated process specified when it terminated.

ExitTime

İlişkili işlemin çıkış süresini alır.Gets the time that the associated process exited.

Handle

İlişkili işlemin yerel tanıtıcısını alır.Gets the native handle of the associated process.

HandleCount

İşlem tarafından açılan tanıtıcı sayısını alır.Gets the number of handles opened by the process.

HasExited

İlişkili işlemin sonlandırılıp sonlandırılmadığını gösteren bir değer alır.Gets a value indicating whether the associated process has been terminated.

Id

İlişkili işlemin benzersiz tanımlayıcısını alır.Gets the unique identifier for the associated process.

MachineName

İlişkili işlemin üzerinde çalıştığı bilgisayarın adını alır.Gets the name of the computer the associated process is running on.

MainModule

İlişkili işlemin ana modülünü alır.Gets the main module for the associated process.

MainWindowHandle

İlişkili işlemin ana penceresinin pencere tanıtıcısını alır.Gets the window handle of the main window of the associated process.

MainWindowTitle

İşlemin ana penceresinin başlığını alır.Gets the caption of the main window of the process.

MaxWorkingSet

İlişkili işlem için izin verilen en fazla çalışma kümesi boyutunu bayt cinsinden alır veya ayarlar.Gets or sets the maximum allowable working set size, in bytes, for the associated process.

MinWorkingSet

İlişkili işlem için izin verilen en düşük çalışma kümesi boyutunu bayt cinsinden alır veya ayarlar.Gets or sets the minimum allowable working set size, in bytes, for the associated process.

Modules

İlişkili işlem tarafından yüklenen modülleri alır.Gets the modules that have been loaded by the associated process.

NonpagedSystemMemorySize

İlişkili işlem için ayrılan, disk belleğine alınamayan sistem belleği miktarını bayt cinsinden alır.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

NonpagedSystemMemorySize64

İlişkili işlem için ayrılan, disk belleğine alınamayan sistem belleği miktarını bayt cinsinden alır.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

PagedMemorySize

İlişkili işlem için ayrılan, bayt cinsinden disk belleğine alınan bellek miktarını alır.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedMemorySize64

İlişkili işlem için ayrılan, bayt cinsinden disk belleğine alınan bellek miktarını alır.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedSystemMemorySize

İlişkili işlem için ayrılan disk belleğine alınabilen sistem belleği miktarını bayt cinsinden alır.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PagedSystemMemorySize64

İlişkili işlem için ayrılan disk belleğine alınabilen sistem belleği miktarını bayt cinsinden alır.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PeakPagedMemorySize

Sanal bellek disk belleği dosyasında, ilişkili işlem tarafından kullanılan bayt cinsinden en fazla bellek miktarını alır.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakPagedMemorySize64

Sanal bellek disk belleği dosyasında, ilişkili işlem tarafından kullanılan bayt cinsinden en fazla bellek miktarını alır.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakVirtualMemorySize

İlişkili işlem tarafından kullanılan, bayt cinsinden maksimum sanal bellek miktarını alır.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakVirtualMemorySize64

İlişkili işlem tarafından kullanılan, bayt cinsinden maksimum sanal bellek miktarını alır.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakWorkingSet

İlişkili işlem için bayt cinsinden en yüksek çalışma kümesi boyutunu alır.Gets the peak working set size for the associated process, in bytes.

PeakWorkingSet64

İlişkili işlem tarafından kullanılan, bayt cinsinden en büyük fiziksel bellek miktarını alır.Gets the maximum amount of physical memory, in bytes, used by the associated process.

PriorityBoostEnabled

Ana pencere odağa sahip olduğunda, ilişkili işlem önceliğinin, işletim sistemi tarafından geçici olarak başlatılıp başlatılmayacağını belirten bir değer alır veya ayarlar.Gets or sets a value indicating whether the associated process priority should temporarily be boosted by the operating system when the main window has the focus.

PriorityClass

İlişkili işlem için genel öncelik kategorisini alır veya ayarlar.Gets or sets the overall priority category for the associated process.

PrivateMemorySize

İlişkili işlem için ayrılan özel bellek miktarını bayt cinsinden alır.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivateMemorySize64

İlişkili işlem için ayrılan özel bellek miktarını bayt cinsinden alır.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivilegedProcessorTime

Bu işlem için ayrıcalıklı işlemci zamanını alır.Gets the privileged processor time for this process.

ProcessName

İşlemin adını alır.Gets the name of the process.

ProcessorAffinity

Bu işlemdeki iş parçacıklarının çalışmak üzere zamanlanabileceği işlemcileri alır veya ayarlar.Gets or sets the processors on which the threads in this process can be scheduled to run.

Responding

İşlemin Kullanıcı arabiriminin yanıt verip vermediğini gösteren bir değer alır.Gets a value indicating whether the user interface of the process is responding.

SafeHandle

Bu işleme yönelik yerel tanıtıcıyı alır.Gets the native handle to this process.

SessionId

İlişkili işlem için Terminal Hizmetleri oturum tanımlayıcısını alır.Gets the Terminal Services session identifier for the associated process.

Site

Öğesini alır veya ayarlar ISite. ComponentGets or sets the ISite of the Component.

(Devralındığı yer: Component)
StandardError

Uygulamanın hata çıkışını okumak için kullanılan bir akış alır.Gets a stream used to read the error output of the application.

StandardInput

Uygulamanın girişini yazmak için kullanılan bir akış alır.Gets a stream used to write the input of the application.

StandardOutput

Uygulamanın metinsel çıkışını okumak için kullanılan bir akış alır.Gets a stream used to read the textual output of the application.

StartInfo

ProcessStart() metoduna geçirilecek özellikleri alır veya ayarlar.Gets or sets the properties to pass to the Start() method of the Process.

StartTime

İlişkili işlemin başlatıldığı saati alır.Gets the time that the associated process was started.

SynchronizingObject

Bir işlem çıkış olayının sonucu olarak yayınlanan olay işleyicisi çağrılarını sıralamak için kullanılan nesneyi alır veya ayarlar.Gets or sets the object used to marshal the event handler calls that are issued as a result of a process exit event.

Threads

İlişkili işlemde çalışan iş parçacığı kümesini alır.Gets the set of threads that are running in the associated process.

TotalProcessorTime

Bu işlemin toplam işlemci süresini alır.Gets the total processor time for this process.

UserProcessorTime

Bu işlem için Kullanıcı işlemci zamanını alır.Gets the user processor time for this process.

VirtualMemorySize

İşlemin sanal belleğinin boyutunu bayt cinsinden alır.Gets the size of the process's virtual memory, in bytes.

VirtualMemorySize64

İlişkili işlem için ayrılan sanal bellek miktarını bayt cinsinden alır.Gets the amount of the virtual memory, in bytes, allocated for the associated process.

WorkingSet

İlişkili işlemin fiziksel bellek kullanımını bayt cinsinden alır.Gets the associated process's physical memory usage, in bytes.

WorkingSet64

İlişkili işlem için ayrılan fiziksel bellek miktarını bayt cinsinden alır.Gets the amount of physical memory, in bytes, allocated for the associated process.

Yöntemler

BeginErrorReadLine()

Uygulamanın yeniden yönlendirilen StandardError akışında zaman uyumsuz okuma işlemleri başlatır.Begins asynchronous read operations on the redirected StandardError stream of the application.

BeginOutputReadLine()

Uygulamanın yeniden yönlendirilen StandardOutput akışında zaman uyumsuz okuma işlemleri başlatır.Begins asynchronous read operations on the redirected StandardOutput stream of the application.

CancelErrorRead()

Bir uygulamanın yeniden yönlendirilen StandardError akışında zaman uyumsuz okuma işlemini iptal eder.Cancels the asynchronous read operation on the redirected StandardError stream of an application.

CancelOutputRead()

Bir uygulamanın yeniden yönlendirilen StandardOutput akışında zaman uyumsuz okuma işlemini iptal eder.Cancels the asynchronous read operation on the redirected StandardOutput stream of an application.

Close()

Bu bileşenle ilişkili tüm kaynakları serbest bırakır.Frees all the resources that are associated with this component.

CloseMainWindow()

Ana penceresine bir Close iletisi göndererek Kullanıcı arabirimine sahip bir işlemi kapatır.Closes a process that has a user interface by sending a close message to its main window.

CreateObjRef(Type)

Uzak bir nesneyle iletişim kurmak için kullanılan bir ara sunucu oluşturmak için gereken tüm bilgileri içeren bir nesne oluşturur.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Devralındığı yer: MarshalByRefObject)
Dispose()
Dispose(Boolean)

Bu işlem tarafından kullanılan tüm kaynakları serbest bırakın.Release all resources used by this process.

EnterDebugMode()

Geçerli iş parçacığında yerel özellik SeDebugPrivilege etkinleştirerek özel bir modda çalışan işletim sistemi işlemleriyle etkileşimde bulunmak için bir Process bileşeni duruma geçirir.Puts a Process component in state to interact with operating system processes that run in a special mode by enabling the native property SeDebugPrivilege on the current thread.

Equals(Object)

Belirtilen nesnenin geçerli nesneyle eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetCurrentProcess()

Yeni bir Process bileşeni alır ve şu anda etkin olan işlemle ilişkilendirir.Gets a new Process component and associates it with the currently active process.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetLifetimeService()

Bu örnek için ömür ilkesini denetleyen geçerli ömür hizmeti nesnesini alır.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
GetProcessById(Int32)

Yerel bilgisayardaki bir işlemin tanımlayıcısı verildiğinde yeni bir Process bileşeni döndürür.Returns a new Process component, given the identifier of a process on the local computer.

GetProcessById(Int32, String)

Bir işlem tanımlayıcısı ve ağdaki bir bilgisayarın adı verildiğinde yeni bir Process bileşeni döndürür.Returns a new Process component, given a process identifier and the name of a computer on the network.

GetProcesses()

Yerel bilgisayardaki her işlem kaynağı için yeni bir Process bileşeni oluşturur.Creates a new Process component for each process resource on the local computer.

GetProcesses(String)

Belirtilen bilgisayardaki her işlem kaynağı için yeni bir Process bileşeni oluşturur.Creates a new Process component for each process resource on the specified computer.

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.Creates an array of new Process components and associates them with all the process resources on the local computer that share the specified process name.

GetProcessesByName(String, String)

Yeni Process bileşenlerinden oluşan bir dizi oluşturur ve bunları belirtilen işlem adını paylaşan uzak bilgisayardaki tüm işlem kaynaklarıyla ilişkilendirir.Creates an array of new Process components and associates them with all the process resources on a remote computer that share the specified process name.

GetService(Type)

Component VeyaContainertarafından belirtilen bir hizmeti temsil eden bir nesne döndürür.Returns an object that represents a service provided by the Component or by its Container.

(Devralındığı yer: Component)
GetType()

Geçerli örneğin Type alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
InitializeLifetimeService()

Bu örnek için ömür ilkesini denetlemek üzere bir ömür hizmeti nesnesi alır.Obtains a lifetime service object to control the lifetime policy for this instance.

(Devralındığı yer: MarshalByRefObject)
Kill()

İlişkili işlemi hemen sonlandırır.Immediately stops the associated process.

Kill(Boolean)

İlişkili işlemi ve isteğe bağlı olarak alt/alt işlemlerini hemen sonlandırır.Immediately stops the associated process, and optionally its child/descendent processes.

LeaveDebugMode()

Bir Process bileşeni, özel bir modda çalışan işletim sistemi işlemleriyle etkileşime geçmesini sağlayan durumdan dışarı alır.Takes a Process component out of the state that lets it interact with operating system processes that run in a special mode.

MemberwiseClone()

Geçerli Objectbasit bir kopyasını oluşturur.Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
MemberwiseClone(Boolean)

Geçerli MarshalByRefObject nesnenin basit bir kopyasını oluşturur.Creates a shallow copy of the current MarshalByRefObject object.

(Devralındığı yer: MarshalByRefObject)
OnExited()

Exited olayını oluşturur.Raises the Exited event.

Refresh()

İşlem bileşeni içinde önbelleğe alınan ilişkili işlemle ilgili tüm bilgileri atar.Discards any information about the associated process that has been cached inside the process component.

Start()

Bu Process bileşenin StartInfo özelliği tarafından belirtilen işlem kaynağını başlatır (veya yeniden kullanır) ve bileşeniyle ilişkilendirir.Starts (or reuses) the process resource that is specified by the StartInfo property of this Process component and associates it with the component.

Start(ProcessStartInfo)

İşlem başlangıç bilgilerini içeren parametre tarafından belirtilen işlem kaynağını başlatır (örneğin, başlatılacak işlemin dosya adı) ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.Starts the process resource that is specified by the parameter containing process start information (for example, the file name of the process to start) and associates the resource with a new Process component.

Start(String)

Bir belge veya uygulama dosyası adını belirterek işlem kaynağını başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.Starts a process resource by specifying the name of a document or application file and associates the resource with a new Process component.

Start(String, String)

Bir uygulamanın adını ve bir dizi komut satırı bağımsız değişkenini belirterek işlem kaynağını başlatır ve kaynağı yeni bir Process bileşeniyle ilişkilendirir.Starts a process resource by specifying the name of an application and a set of command-line arguments, and associates the resource with a new Process component.

Start(String, String, SecureString, String)

Bir uygulama adı, Kullanıcı adı, parola ve etki alanı belirterek ve kaynağı yeni bir Process bileşeniyle ilişkilenerek bir işlem kaynağı başlatır.Starts a process resource by specifying the name of an application, a user name, a password, and a domain and associates the resource with a new Process component.

Start(String, String, String, SecureString, String)

Bir uygulamanın adını, komut satırı bağımsız değişkenleri kümesini, bir kullanıcı adını, parolayı ve etki alanını belirterek ve kaynağı yeni bir Process bileşeniyle ilişkilenerek bir işlem kaynağı başlatır.Starts a process resource by specifying the name of an application, a set of command-line arguments, a user name, a password, and a domain and associates the resource with a new Process component.

ToString()

İşlem adını, varsa üst bileşen türüyle birlikte bir dize olarak biçimlendirir.Formats the process's name as a string, combined with the parent component type, if applicable.

WaitForExit()

Process bileşeni, ilişkili işlemin çıkması için süresiz olarak beklemesini söyler.Instructs the Process component to wait indefinitely for the associated process to exit.

WaitForExit(Int32)

Process bileşeni, ilişkili işlemin çıkması için belirtilen milisaniye sayısını beklemesini söyler.Instructs the Process component to wait the specified number of milliseconds for the associated process to exit.

WaitForInputIdle()

Process bileşenin ilişkili işlemin boşta bir durum girmesi için süresiz olarak beklemesini sağlar.Causes the Process component to wait indefinitely for the associated process to enter an idle state. Bu aşırı yükleme yalnızca Kullanıcı arabirimine sahip süreçler ve bu nedenle bir ileti döngüsü için geçerlidir.This overload applies only to processes with a user interface and, therefore, a message loop.

WaitForInputIdle(Int32)

Process bileşeni, ilişkili işlemin boşta durumunu girmesi için belirtilen milisaniye sayısını beklemesine neden olur.Causes the Process component to wait the specified number of milliseconds for the associated process to enter an idle state. Bu aşırı yükleme yalnızca Kullanıcı arabirimine sahip süreçler ve bu nedenle bir ileti döngüsü için geçerlidir.This overload applies only to processes with a user interface and, therefore, a message loop.

Ekinlikler

Disposed

Bileşen Dispose() yönteme bir çağrı tarafından bırakıldığında gerçekleşir.Occurs when the component is disposed by a call to the Dispose() method.

(Devralındığı yer: Component)
ErrorDataReceived

Bir uygulama yeniden yönlendirilen StandardError akışına yazdığında gerçekleşir.Occurs when an application writes to its redirected StandardError stream.

Exited

Bir işlemden çıkıldığında gerçekleşir.Occurs when a process exits.

OutputDataReceived

Bir uygulama yeniden yönlendirilen StandardOutput akışına bir satır yazdığında her zaman gerçekleşir.Occurs each time an application writes a line to its redirected StandardOutput stream.

Güvenlik

LinkDemand
şu anki çağırana ilişkin tam güven için.for full trust for the immediate caller. Bu sınıf, kısmen güvenilen kodla kullanılamaz.This class cannot be used by partially trusted code.

InheritanceDemand
devralanlara ilişkin tam güven için.for full trust for inheritors. Bu sınıf, kısmen güvenilen kod tarafından devralınamaz.This class cannot be inherited by partially trusted code.

Şunlara uygulanır

Ayrıca bkz.