Process Klasse

Definition

Namespace:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Quelle:

Process.cs

Bietet Zugriff auf lokale und Remoteprozesse und ermöglicht es Ihnen, lokale Systemprozesse zu starten und zu beenden.

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

Vererbung

Object

MarshalByRefObject

Component

Process

Implementiert

IDisposable

Beispiele

Im folgenden Beispiel wird eine Instanz der Process Klasse verwendet, um einen Prozess zu starten.

#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

Im folgenden Beispiel wird die Process Klasse selbst und eine statische Start Methode verwendet, um einen Prozess zu starten.

#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

Im folgenden F#-Beispiel wird eine runProc-Funktion definiert, die einen Prozess startet, alle Ausgabe- und Fehlerinformationen erfasst und die Anzahl von Millisekunden erfasst, die der Prozess ausgeführt hat. Die runProc-Funktion weist drei Parameter auf: den Namen der zu startenden Anwendung, die Argumente, die für die Anwendung angegeben werden sollen, und das Startverzeichnis.

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

Der Code für die funktion runProc wurde von ImaginaryDevelopment geschrieben und ist unter dem Microsoft Public Licenseverfügbar.

Hinweise

Eine Process Komponente bietet Zugriff auf einen Prozess, der auf einem Computer ausgeführt wird. Ein Prozess ist in den einfachsten Worten eine ausgeführte App. Ein Thread ist die Basiseinheit, der das Betriebssystem Prozessorzeit zuweist. Ein Thread kann einen beliebigen Teil des Codes des Prozesses ausführen, einschließlich der Teile, die derzeit von einem anderen Thread ausgeführt werden.

Die Process-Komponente ist ein nützliches Tool zum Starten, Beenden, Steuern und Überwachen von Apps. Mit der Process-Komponente können Sie eine Liste der ausgeführten Prozesse abrufen oder einen neuen Prozess starten. Eine Process Komponente wird für den Zugriff auf Systemprozesse verwendet. Nachdem eine Process Komponente initialisiert wurde, kann sie verwendet werden, um Informationen zum ausgeführten Prozess abzurufen. Solche Informationen umfassen den Satz von Threads, die geladenen Module (.dll und .exe Dateien) sowie Leistungsinformationen wie die Menge des Arbeitsspeichers, den der Prozess verwendet.

Dieser Typ implementiert die IDisposable Schnittstelle. Wenn Sie die Verwendung des Typs abgeschlossen haben, sollten Sie ihn entweder direkt oder indirekt verwerfen. Rufen Sie zum direkten Löschen des Typs die Dispose-Methode in einem try/finally-Block auf. Verwenden Sie zum indirekten Löschen ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Using an Object that Implements IDisposable" in the IDisposable interface documentation.

Wichtig

Das Aufrufen von Methoden aus dieser Klasse mit nicht vertrauenswürdigen Daten ist ein Sicherheitsrisiko. Rufen Sie die Methoden aus dieser Klasse nur mit vertrauenswürdigen Daten auf. Weitere Informationen finden Sie unter Überprüfen aller Eingaben.

Anmerkung

32-Bit-Prozesse können nicht auf die Module eines 64-Bit-Prozesses zugreifen. Wenn Sie versuchen, Informationen über einen 64-Bit-Prozess aus einem 32-Bit-Prozess abzurufen, erhalten Sie eine Win32Exception Ausnahme. Ein 64-Bit-Prozess hingegen kann auf die Module eines 32-Bit-Prozesses zugreifen.

Die Prozesskomponente ruft Informationen zu einer Gruppe von Eigenschaften auf einmal ab. Nachdem die Process Komponente Informationen zu einem Mitglied einer beliebigen Gruppe erhalten hat, werden die Werte für die anderen Eigenschaften in dieser Gruppe zwischengespeichert und erst neue Informationen zu den anderen Mitgliedern der Gruppe abgerufen, bis Sie die Refresh-Methode aufrufen. Daher ist ein Eigenschaftswert nicht garantiert neuer als der letzte Aufruf der Refresh-Methode. Die Gruppenaufschlüsselungen sind vom Betriebssystem abhängig.

Wenn Sie eine Pfadvariable in Ihrem System mithilfe von Anführungszeichen deklariert haben, müssen Sie diesen Pfad vollständig qualifizieren, wenn ein Prozess gestartet wird, der an diesem Speicherort gefunden wurde. Andernfalls wird der Pfad vom System nicht gefunden. Wenn c:\mypath sich beispielsweise nicht in Ihrem Pfad befindet und Sie ihn mit Anführungszeichen hinzufügen: path = %path%;"c:\mypath", müssen Sie alle Prozesse in c:\mypath vollständig qualifizieren, wenn Sie es starten.

Ein Systemprozess wird anhand seiner Prozess-ID eindeutig auf dem System identifiziert. Wie viele Windows-Ressourcen wird ein Prozess auch durch seinen Handle identifiziert, der möglicherweise nicht eindeutig auf dem Computer ist. Ein Handle ist der generische Begriff für einen Bezeichner einer Ressource. Das Betriebssystem behält das Prozesshandle bei, auf das über die Handle Eigenschaft der Process Komponente zugegriffen wird, auch wenn der Prozess beendet wurde. So können Sie die administrativen Informationen des Prozesses abrufen, z. B. die ExitCode (in der Regel entweder Null für Erfolg oder einen Fehlercode ohne Abweichung) und die ExitTime. Handles sind eine äußerst wertvolle Ressource, sodass Leckziehpunkte virulenter sind als speicherlässiger.

Anmerkung

Diese Klasse enthält eine Linknachfrage und eine Vererbungsnachfrage auf Klassenebene, die für alle Member gilt. Ein SecurityException wird ausgelöst, wenn der direkte Aufrufer oder die abgeleitete Klasse nicht über voll vertrauenswürdige Berechtigungen verfügt. Ausführliche Informationen zu Sicherheitsanforderungen finden Sie unter Linkanforderungen.

.NET Core Notes

In .NET Framework verwendet die Process-Klasse standardmäßig Console Codierungen, die in der Regel Codeseitencodierungen sind, für die Eingabe-, Ausgabe- und Fehlerdatenströme. Beispielcode für Systeme, deren Kultur Englisch (USA) ist, die Codepage 437 ist die Standardcodierung für die Console-Klasse. .NET Core kann jedoch nur eine begrenzte Teilmenge dieser Codierungen verfügbar machen. Wenn dies der Fall ist, wird Encoding.UTF8 als Standardcodierung verwendet.

Wenn ein Process-Objekt von bestimmten Codeseitencodierungen abhängt, können Sie diese weiterhin verfügbar machen, indem Sie die folgenden ausführen, bevor Sie alle Process Methoden aufrufen:

1. Rufen Sie das EncodingProvider-Objekt aus der eigenschaft CodePagesEncodingProvider.Instance ab.

2. Übergeben Sie das EncodingProvider-Objekt an die Encoding.RegisterProvider-Methode, um die zusätzlichen Codierungen verfügbar zu machen, die vom Codierungsanbieter unterstützt werden.

Die Process Klasse verwendet dann automatisch die Standardsystemcodierung anstelle von UTF8, vorausgesetzt, Sie haben den Codierungsanbieter registriert, bevor Sie Process Methoden aufrufen.

Konstruktoren

Process()

Initialisiert eine neue Instanz der Process Klasse.

Eigenschaften

BasePriority	Ruft die Basispriorität des zugeordneten Prozesses ab.
CanRaiseEvents	Ruft einen Wert ab, der angibt, ob die Komponente ein Ereignis auslösen kann. (Geerbt von Component)
Container	Ruft die IContainer ab, die den Componententhält. (Geerbt von Component)
DesignMode	Ruft einen Wert ab, der angibt, ob sich die Component derzeit im Entwurfsmodus befindet. (Geerbt von Component)
EnableRaisingEvents	Ruft ab oder legt fest, ob das Exited-Ereignis ausgelöst werden soll, wenn der Prozess beendet wird.
Events	Ruft die Liste der Ereignishandler ab, die an diese Componentangefügt sind. (Geerbt von Component)
ExitCode	Ruft den Wert ab, den der zugeordnete Prozess beim Beenden angegeben hat.
ExitTime	Ruft die Zeit ab, zu der der zugeordnete Prozess beendet wurde.
Handle	Ruft das systemeigene Handle des zugeordneten Prozesses ab.
HandleCount	Ruft die Anzahl der Handles ab, die vom Prozess geöffnet werden.
HasExited	Ruft einen Wert ab, der angibt, ob der zugeordnete Prozess beendet wurde.
Id	Ruft den eindeutigen Bezeichner für den zugeordneten Prozess ab.
MachineName	Ruft den Namen des Computers ab, auf dem der zugeordnete Prozess ausgeführt wird.
MainModule	Ruft das Hauptmodul für den zugeordneten Prozess ab.
MainWindowHandle	Ruft das Fensterhandle des Hauptfensters des zugeordneten Prozesses ab.
MainWindowTitle	Ruft die Beschriftung des Hauptfensters des Prozesses ab.
MaxWorkingSet	Ruft die maximal zulässige Arbeitssatzgröße für den zugeordneten Prozess in Bytes ab oder legt diese fest.
MinWorkingSet	Ruft die minimale zulässige Arbeitssatzgröße für den zugeordneten Prozess in Byte ab, oder legt diese fest.
Modules	Ruft die Module ab, die vom zugeordneten Prozess geladen wurden.
NonpagedSystemMemorySize	Veraltet. Ruft die Menge des nicht seitengebundenen Systemspeichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
NonpagedSystemMemorySize64	Ruft die Menge des nicht seitengebundenen Systemspeichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
PagedMemorySize	Veraltet. Ruft die Menge des ausgelagerten Arbeitsspeichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
PagedMemorySize64	Ruft die Menge des ausgelagerten Arbeitsspeichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
PagedSystemMemorySize	Veraltet. Ruft die Menge des ausgelagerten Systemspeichers in Bytes ab, die dem zugeordneten Prozess zugeordnet sind.
PagedSystemMemorySize64	Ruft die Menge des ausgelagerten Systemspeichers in Bytes ab, die dem zugeordneten Prozess zugeordnet sind.
PeakPagedMemorySize	Veraltet. Ruft die maximale Arbeitsspeichermenge in der Datei für die auslagerung des virtuellen Speichers in Bytes ab, die vom zugeordneten Prozess verwendet wird.
PeakPagedMemorySize64	Ruft die maximale Arbeitsspeichermenge in der Datei für die auslagerung des virtuellen Speichers in Bytes ab, die vom zugeordneten Prozess verwendet wird.
PeakVirtualMemorySize	Veraltet. Ruft die maximale Menge an virtuellem Arbeitsspeicher in Byte ab, die vom zugeordneten Prozess verwendet wird.
PeakVirtualMemorySize64	Ruft die maximale Menge an virtuellem Arbeitsspeicher in Byte ab, die vom zugeordneten Prozess verwendet wird.
PeakWorkingSet	Veraltet. Ruft die Maximale Arbeitssatzgröße für den zugeordneten Prozess in Byte ab.
PeakWorkingSet64	Ruft die maximale Menge an physischem Arbeitsspeicher in Byte ab, die vom zugeordneten Prozess verwendet wird.
PriorityBoostEnabled	Dient zum Abrufen oder Festlegen eines Werts, der angibt, ob die zugeordnete Prozesspriorität vorübergehend vom Betriebssystem erhöht werden soll, wenn das Hauptfenster den Fokus hat.
PriorityClass	Dient zum Abrufen oder Festlegen der Allgemeinen Prioritätskategorie für den zugeordneten Prozess.
PrivateMemorySize	Veraltet. Ruft die Menge des privaten Speichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
PrivateMemorySize64	Ruft die Menge des privaten Speichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
PrivilegedProcessorTime	Ruft die privilegierte Prozessorzeit für diesen Prozess ab.
ProcessName	Ruft den Namen des Prozesses ab.
ProcessorAffinity	Ruft die Prozessoren ab, auf denen die Threads in diesem Prozess ausgeführt werden können, oder legt sie fest.
Responding	Ruft einen Wert ab, der angibt, ob die Benutzeroberfläche des Prozesses reagiert.
SafeHandle	Ruft das systemeigene Handle für diesen Prozess ab.
SessionId	Ruft den Sitzungsbezeichner der Terminaldienste für den zugeordneten Prozess ab.
Site	Dient zum Abrufen oder Festlegen des ISite des Component. (Geerbt von Component)
StandardError	Ruft einen Datenstrom ab, der zum Lesen der Fehlerausgabe der Anwendung verwendet wird.
StandardInput	Ruft einen Datenstrom ab, der zum Schreiben der Eingabe der Anwendung verwendet wird.
StandardOutput	Ruft einen Datenstrom ab, der zum Lesen der Textausgabe der Anwendung verwendet wird.
StartInfo	Dient zum Abrufen oder Festlegen der Eigenschaften, die an die Start() -Methode der Processübergeben werden sollen.
StartTime	Ruft die Zeit ab, zu der der zugeordnete Prozess gestartet wurde.
SynchronizingObject	Dient zum Abrufen oder Festlegen des Objekts, das zum Marshallen der Ereignishandleraufrufe verwendet wird, die als Ergebnis eines Prozessausgangsereignisses ausgegeben werden.
Threads	Ruft den Satz von Threads ab, die im zugeordneten Prozess ausgeführt werden.
TotalProcessorTime	Ruft die Gesamtprozessorzeit für diesen Prozess ab.
UserProcessorTime	Ruft die Benutzerprozessorzeit für diesen Prozess ab.
VirtualMemorySize	Veraltet. Ruft die Größe des virtuellen Speichers des Prozesses in Byte ab.
VirtualMemorySize64	Ruft die Menge des virtuellen Speichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.
WorkingSet	Veraltet. Ruft die physische Speicherauslastung des zugeordneten Prozesses in Bytes ab.
WorkingSet64	Ruft die Menge des physischen Arbeitsspeichers in Bytes ab, die für den zugeordneten Prozess zugeordnet sind.

Methoden

BeginErrorReadLine()	Beginnt asynchrone Lesevorgänge für den umgeleiteten StandardError Datenstrom der Anwendung.
BeginOutputReadLine()	Beginnt asynchrone Lesevorgänge für den umgeleiteten StandardOutput Datenstrom der Anwendung.
CancelErrorRead()	Bricht den asynchronen Lesevorgang für den umgeleiteten StandardError Stream einer Anwendung ab.
CancelOutputRead()	Bricht den asynchronen Lesevorgang für den umgeleiteten StandardOutput Stream einer Anwendung ab.
Close()	Gibt alle Ressourcen frei, die dieser Komponente zugeordnet sind.
CloseMainWindow()	Schließt einen Prozess, der über eine Benutzeroberfläche verfügt, indem eine close message an das Hauptfenster gesendet wird.
CreateObjRef(Type)	Erstellt ein Objekt, das alle relevanten Informationen enthält, die zum Generieren eines Proxys erforderlich sind, der für die Kommunikation mit einem Remoteobjekt verwendet wird. (Geerbt von MarshalByRefObject)
Dispose()	Gibt alle vom Componentverwendeten Ressourcen frei. (Geerbt von Component)
Dispose(Boolean)	Geben Sie alle ressourcen frei, die von diesem Prozess verwendet werden.
EnterDebugMode()	Versetzt eine Process Komponente in den Zustand, um mit Betriebssystemprozessen zu interagieren, die in einem speziellen Modus ausgeführt werden, indem die systemeigene Eigenschaft SeDebugPrivilege im aktuellen Thread aktiviert wird.
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetCurrentProcess()	Ruft eine neue Process Komponente ab und ordnet sie dem derzeit aktiven Prozess zu.
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetLifetimeService()	Veraltet. Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinie für diese Instanz steuert. (Geerbt von MarshalByRefObject)
GetProcessById(Int32, String)	Gibt eine neue Process Komponente zurück, die einen Prozessbezeichner und den Namen eines Computers im Netzwerk erhält.
GetProcessById(Int32)	Gibt eine neue Process Komponente zurück, wobei der Bezeichner eines Prozesses auf dem lokalen Computer angegeben ist.
GetProcesses()	Erstellt eine neue Process Komponente für jede Prozessressource auf dem lokalen Computer.
GetProcesses(String)	Erstellt eine neue Process Komponente für jede Prozessressource auf dem angegebenen Computer.
GetProcessesByName(String, String)	Erstellt ein Array neuer Process Komponenten und ordnet sie allen Prozessressourcen auf einem Remotecomputer zu, der den angegebenen Prozessnamen gemeinsam verwendet.
GetProcessesByName(String)	Erstellt ein Array neuer Process Komponenten und ordnet sie allen Prozessressourcen auf dem lokalen Computer zu, die den angegebenen Prozessnamen gemeinsam verwenden.
GetService(Type)	Gibt ein Objekt zurück, das einen Dienst darstellt, der vom Component oder von seinem Containerbereitgestellt wird. (Geerbt von Component)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
InitializeLifetimeService()	Veraltet. Ruft ein Lebensdauerdienstobjekt ab, um die Lebensdauerrichtlinie für diese Instanz zu steuern. (Geerbt von MarshalByRefObject)
Kill()	Beendet sofort den zugeordneten Prozess.
Kill(Boolean)	Beendet den zugeordneten Prozess sofort und optional seine untergeordneten/untergeordneten Prozesse.
LeaveDebugMode()	Nimmt eine Process Komponente aus dem Zustand, mit der sie mit Betriebssystemprozessen interagieren kann, die in einem speziellen Modus ausgeführt werden.
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
MemberwiseClone(Boolean)	Erstellt eine flache Kopie des aktuellen MarshalByRefObject-Objekts. (Geerbt von MarshalByRefObject)
OnExited()	Löst das Exited-Ereignis aus.
Refresh()	Verwirft alle Informationen zum zugeordneten Prozess, der innerhalb der Prozesskomponente zwischengespeichert wurde.
Start()	Startet (oder verwendet) die Prozessressource, die durch die StartInfo-Eigenschaft dieser Process Komponente angegeben wird, und ordnet sie der Komponente zu.
Start(ProcessStartInfo)	Startet die Prozessressource, die durch den Parameter angegeben wird, der Prozessstartinformationen enthält (z. B. den Dateinamen des zu startenden Prozesses), und ordnet die Ressource einer neuen Process Komponente zu.
Start(String, IEnumerable<String>)	Startet eine Prozessressource durch Angeben des Namens einer Anwendung und einer Reihe von Befehlszeilenargumenten.
Start(String, String, SecureString, String)	Startet eine Prozessressource durch Angeben des Namens einer Anwendung, eines Benutzernamens, eines Kennworts und einer Domäne und ordnet die Ressource einer neuen Process Komponente zu.
Start(String, String, String, SecureString, String)	Startet eine Prozessressource durch Angeben des Namens einer Anwendung, einer Reihe von Befehlszeilenargumenten, eines Benutzernamens, eines Kennworts und einer Domäne und ordnet die Ressource einer neuen Process Komponente zu.
Start(String, String)	Startet eine Prozessressource durch Angeben des Namens einer Anwendung und einer Reihe von Befehlszeilenargumenten und ordnet die Ressource einer neuen Process Komponente zu.
Start(String)	Startet eine Prozessressource durch Angeben des Namens eines Dokuments oder einer Anwendungsdatei und ordnet die Ressource einer neuen Process Komponente zu.
ToString()	Formatiert den Namen des Prozesses als Zeichenfolge, kombiniert mit dem übergeordneten Komponententyp, falls zutreffend.
WaitForExit()	Weist die komponente Process an, auf unbestimmte Zeit zu warten, bis der zugeordnete Prozess beendet wird.
WaitForExit(Int32)	Weist die Process Komponente an, die angegebene Anzahl von Millisekunden zu warten, damit der zugeordnete Prozess beendet wird.
WaitForExit(TimeSpan)	Weist die Prozesskomponente an, die angegebene Zeitspanne zu warten, bis der zugeordnete Prozess beendet wird.
WaitForExitAsync(CancellationToken)	Weist die Prozesskomponente an, auf das Beenden des zugeordneten Prozesses zu warten oder die cancellationToken abgebrochen zu werden.
WaitForInputIdle()	Bewirkt, dass die Process Komponente auf unbestimmte Zeit wartet, bis der zugeordnete Prozess in den Leerlaufzustand wechselt. Diese Überladung gilt nur für Prozesse mit einer Benutzeroberfläche und daher eine Nachrichtenschleife.
WaitForInputIdle(Int32)	Bewirkt, dass die Process Komponente die angegebene Anzahl von Millisekunden wartet, damit der zugeordnete Prozess in den Leerlaufzustand wechselt. Diese Überladung gilt nur für Prozesse mit einer Benutzeroberfläche und daher eine Nachrichtenschleife.
WaitForInputIdle(TimeSpan)	Bewirkt, dass die Process Komponente auf den angegebenen timeout wartet, bis der zugeordnete Prozess in den Leerlaufzustand wechselt. Diese Überladung gilt nur für Prozesse mit einer Benutzeroberfläche und daher eine Nachrichtenschleife.

Ereignisse

Disposed	Tritt auf, wenn die Komponente durch einen Aufruf der Dispose() -Methode verworfen wird. (Geerbt von Component)
ErrorDataReceived	Tritt auf, wenn eine Anwendung in den umgeleiteten StandardError Stream schreibt.
Exited	Tritt auf, wenn ein Prozess beendet wird.
OutputDataReceived	Tritt jedes Mal auf, wenn eine Anwendung eine Zeile in den umgeleiteten StandardOutput Datenstrom schreibt.

Weitere Informationen

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