Process Klasse

Definition

Ermöglicht den Zugriff auf lokale Prozesse und Remoteprozesse und das Starten und Anhalten lokaler Systemprozesse.

public ref class Process : System::ComponentModel::Component, IDisposable
public ref class Process : IDisposable
public ref class Process : System::ComponentModel::Component
public class Process : System.ComponentModel.Component, IDisposable
public class Process : IDisposable
public class Process : System.ComponentModel.Component
type Process = class
    inherit Component
    interface IDisposable
type Process = class
    interface IDisposable
type Process = class
    inherit Component
Public Class Process
Inherits Component
Implements IDisposable
Public Class Process
Implements IDisposable
Public Class Process
Inherits Component
Vererbung
Vererbung
Process
Implementiert

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);
            }
        }
    }
}
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();
        }
    }
}
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 Funktion definiert, die einen runProc Prozess startet, alle Ausgabe- und Fehlerinformationen erfasst und die Anzahl der Millisekunden erfasst, die der Prozess ausgeführt hat. Die runProc Funktion verfügt über drei Parameter: der Name der Anwendung zum Starten, die Argumente zum Bereitstellen der Anwendung und des Startverzeichniss.

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 runProc Funktion wurde von Imaginary Development geschrieben und ist unter der Microsoft Public License verfügbar.

Hinweise

Eine Process Komponente bietet Zugriff auf einen Prozess, der auf einem Computer ausgeführt wird. Ein Prozess, in den einfachsten Ausdrücken, ist eine ausgeführte App. Ein Thread ist die grundlegende Einheit, für die das Betriebssystem die Prozessorzeit zuordnet. Ein Thread kann einen beliebigen Teil des Codes des Prozesses ausführen, einschließlich 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. Sie können die Process Komponente verwenden, um eine Liste der ausgeführten Prozesse abzurufen, oder Sie können einen neuen Prozess starten. Eine Process Komponente wird verwendet, um auf Systemprozesse zuzugreifen. 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) und Leistungsinformationen wie die Menge des Arbeitsspeichers, den der Prozess verwendet.

Dieser Typ implementiert die IDisposable-Schnittstelle. Nach Abschluss der Verwendung sollten Sie den Typ entweder direkt oder indirekt löschen. Zum direkten Löschen des Typs rufen Sie seine Dispose-Methode in einem try/finally-Block auf. Zum indirekten Löschen verwenden Sie ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt „Verwenden eines Objekts, das IDisposable implementiert“ des Themas „Die IDisposable-Schnittstelle“.

Hinweis

32-Bit-Prozesse können nicht auf die Module eines 64-Bit-Prozesses zugreifen. Wenn Sie versuchen, Informationen zu einem 64-Bit-Prozess aus einem 32-Bit-Prozess abzurufen, erhalten Sie eine Win32Exception Ausnahme. Ein 64-Bit-Prozess kann andererseits 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, zwischengespeichert sie die Werte für die anderen Eigenschaften in dieser Gruppe und erhalten keine neuen Informationen zu den anderen Mitgliedern der Gruppe, bis Sie die Refresh Methode aufrufen. Daher ist kein Eigenschaftswert 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 findet das System den Pfad nicht. Wenn c:\mypath Sie sich beispielsweise nicht im Pfad befinden, und Sie sie mithilfe von Anführungszeichen hinzufügen: path = %path%;"c:\mypath", müssen Sie beim Starten vollständig einen Prozess c:\mypath qualifizieren.

Ein Systemprozess wird durch seinen Prozessbezeichner 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 speichert den Prozesshandpunkt, der über die Handle Eigenschaft der Process Komponente zugegriffen wird, auch wenn der Prozess beendet wurde. Daher können Sie die administrativen Informationen des Prozesses abrufen, z. B. die ExitCode (normalerweise null für Erfolg oder einen Nichtzero-Fehlercode) und den ExitTime. Handle sind eine äußerst wertvolle Ressource, sodass verleckende Ziehpunkte virulenter sind als das Verlecken des Arbeitsspeichers.

Hinweis

Diese Klasse enthält eine Linkanforderungen und eine Vererbungsanforderungen auf Klassenebene, die für alle Mitglieder gelten. Eine SecurityException wird ausgelöst, wenn entweder der sofortige Anrufer oder die abgeleitete Klasse keine voll vertrauenswürdige Berechtigung hat. Ausführliche Informationen zu Sicherheitsanforderungen finden Sie unter Linkanforderungen.

.NET Core-Notizen

In der .NET Framework verwendet Console die Process Klasse standardmäßig Codierungen, die in der Regel Codeseitencodierungen sind, für die Eingabe, Ausgabe und Fehlerströme. Code auf Systemen, deren Kultur Englisch (USA) ist, ist die Codeseite 437 die Standardcodierung für die Console Klasse. .NET Core kann jedoch nur eine begrenzte Teilmenge dieser Codierungen zur Verfügung stellen. Wenn dies der Fall ist, wird es als Standardcodierung verwendet Encoding.UTF8 .

Wenn ein Process Objekt von bestimmten Codeseitencodierungen abhängt, können Sie sie weiterhin verfügbar machen, indem Sie folgendes ausführen, bevor Sie Methoden aufrufen Process :

  1. Fügen Sie dem Projekt einen Verweis auf die System.Text.Encoding.CodePages.dll-Assembly hinzu.

  2. Rufen Sie das EncodingProvider Objekt aus der CodePagesEncodingProvider.Instance Eigenschaft ab.

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

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

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 in der Component enthalten ist.

(Geerbt von Component)
DesignMode

Ruft einen Wert ab, der angibt, ob sich Component gegenwärtig im Entwurfsmodus befindet.

(Geerbt von Component)
EnableRaisingEvents

Ruft ab oder legt fest, ob beim Beenden des Prozesses das Exited-Ereignis ausgelöst werden soll.

Events

Ruft die Liste der Ereignishandler ab, die dieser Component angefügt sind.

(Geerbt von Component)
ExitCode

Ruft den Wert ab, der vom zugeordneten Prozess beim Beenden angegeben wurde.

ExitTime

Ruft den Zeitpunkt ab, zu dem der zugeordnete Prozess beendet wurde.

Handle

Ruft das systemeigene Handle des zugeordneten Prozesses ab.

HandleCount

Ruft die Anzahl der vom Prozess geöffneten Handles ab.

HasExited

Ruft einen Wert ab, der angibt, ob der zugehörige 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, in Bytes, die maximal zulässige Workingsetgröße für den zugeordneten Prozess ab oder legt diese fest.

MinWorkingSet

Ruft, in Bytes, die Workingsetmindestgröße für den zugeordneten Prozess ab oder legt diese fest.

Modules

Ruft die Module ab, die vom zugeordneten Prozess geladen wurden.

NonpagedSystemMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die Menge des für den zugeordneten Prozess belegten nicht ausgelagerten Systemspeichers in Bytes ab.

NonpagedSystemMemorySize64

Ruft die Menge des für den zugeordneten Prozess belegten nicht ausgelagerten Systemspeichers in Bytes ab.

PagedMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die Größe des Auslagerungsspeichers in Bytes ab, der für den zugeordneten Prozess belegt wird.

PagedMemorySize64

Ruft die Größe des Auslagerungsspeichers in Bytes ab, der für den zugeordneten Prozess belegt wird.

PagedSystemMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die Menge des für den zugeordneten Prozess belegten auslagerbaren Systemspeichers in Bytes ab.

PagedSystemMemorySize64

Ruft die Menge des für den zugeordneten Prozess belegten auslagerbaren Systemspeichers in Bytes ab.

PeakPagedMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft den vom zugeordneten Prozess verwendeten maximalen Arbeitsspeicher in der Auslagerungsdatei des virtuellen Arbeitsspeichers in Bytes ab.

PeakPagedMemorySize64

Ruft den vom zugeordneten Prozess verwendeten maximalen Arbeitsspeicher in der Auslagerungsdatei des virtuellen Arbeitsspeichers in Bytes ab.

PeakVirtualMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die maximale Größe des virtuellen Speichers (in Bytes) ab, der vom zugeordneten Prozess verwendet wird.

PeakVirtualMemorySize64

Ruft die maximale Größe des virtuellen Speichers (in Bytes) ab, der vom zugeordneten Prozess verwendet wird.

PeakWorkingSet
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die maximale Größe des Workingsets für den zugeordneten Prozess in Bytes ab.

PeakWorkingSet64

Ruft die maximale Größe des physischen Speichers (in Bytes) ab, der vom zugeordneten Prozess verwendet wird.

PriorityBoostEnabled

Ruft einen Wert ab, der angibt, ob die zugeordnete Prozesspriorität durch das Betriebssystem vorübergehend erhöht werden soll, wenn das Hauptfenster den Fokus besitzt, oder legt diesen fest.

PriorityClass

Ruft die allgemeine Prioritätskategorie für den zugeordneten Prozess ab oder legt diese fest.

PrivateMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die Größe des privaten Speichers in Bytes ab, der für den zugeordneten Prozess belegt wird.

PrivateMemorySize64

Ruft die Größe des privaten Speichers in Bytes ab, der für den zugeordneten Prozess belegt wird.

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 Ausführung der Threads in diesem Prozess geplant werden kann, oder legt diese fest.

Responding

Ruft einen Wert ab, der angibt, ob die Benutzeroberfläche des Prozesses reagiert.

SafeHandle

Ruft das systemeigene Handle dieses Prozesses ab.

SessionId

Ruft die Terminaldienste-Sitzungs-ID für den zugeordneten Prozess ab.

Site

Ruft den ISite von Component ab oder legt ihn fest.

(Geerbt von Component)
StandardError

Ruft einen Stream ab, mit dem die Fehlerausgabe der Anwendung gelesen wird.

StandardInput

Ruft einen Stream ab, in den die Eingaben der Anwendung geschrieben werden.

StandardOutput

Ruft einen Stream ab, der dazu verwendet wird, die Textausgabe der Anwendung zu lesen.

StartInfo

Ruft die Eigenschaften ab, die an die Start()-Methode von Process übergeben werden sollen, oder legt diese fest.

StartTime

Ruft die Zeit ab, zu der der zugeordnete Prozess gestartet wurde.

SynchronizingObject

Ruft das Objekt ab, das zum Marshallen der Ereignishandleraufrufe verwendet wird, die als Ergebnis eines Prozessbeendigungsereignisses ausgegeben werden, oder legt dieses fest.

Threads

Ruft die Gruppe von Threads ab, die im zugeordneten Prozess ausgeführt werden.

TotalProcessorTime

Ruft die gesamte Prozessorzeit für diesen Prozess ab.

UserProcessorTime

Ruft die Benutzerprozessorzeit für diesen Prozess ab.

VirtualMemorySize
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die Größe des virtuellen Speichers für diesen Prozess in Bytes ab.

VirtualMemorySize64

Ruft die Größe des virtuellen Speichers, der für den zugeordneten Prozess belegt wird, in Bytes ab.

WorkingSet
Veraltet.
Veraltet.
Veraltet.
Veraltet.

Ruft die Belegung des physischen Speichers durch den zugeordneten Prozess in Bytes ab.

WorkingSet64

Ruft die Größe des physischen Speichers in Bytes ab, der für den zugeordneten Prozess belegt wird.

Methoden

BeginErrorReadLine()

Startet asynchrone Lesevorgänge im umgeleiteten StandardError-Stream der Anwendung.

BeginOutputReadLine()

Startet asynchrone Lesevorgänge im umgeleiteten StandardOutput-Stream der Anwendung.

CancelErrorRead()

Bricht den asynchronen Lesevorgang im umgeleiteten StandardError-Stream einer Anwendung ab.

CancelOutputRead()

Bricht den asynchronen Lesevorgang im umgeleiteten StandardOutput-Stream einer Anwendung ab.

Close()

Gibt alle dieser Komponente zugeordneten Ressourcen frei.

CloseMainWindow()

Schließt einen Prozess mit einer Benutzeroberfläche, indem eine Meldung zum Schließen an das Hauptfenster gesendet wird.

CreateObjRef(Type)

Erstellt ein Objekt mit allen relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt erforderlich sind.

(Geerbt von MarshalByRefObject)
Dispose()

Führt anwendungsspezifische Aufgaben durch, die mit der Freigabe, der Zurückgabe oder dem Zurücksetzen von nicht verwalteten Ressourcen zusammenhängen.

Dispose()

Gibt alle vom Component verwendeten Ressourcen frei.

(Geerbt von Component)
Dispose(Boolean)

Gibt alle von diesem Prozess verwendeten Ressourcen frei.

EnterDebugMode()

Versetzt durch Aktivieren der systemeigenen Process-Eigenschaft für den aktuellen Thread eine SeDebugPrivilege-Komponente in einen Zustand, in dem sie mit Betriebssystemprozessen interagieren kann, die in einem speziellen Modus ausgeführt werden.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetCurrentProcess()

Ruft eine neue Process -Komponente ab und ordnet diese dem gegenwärtig aktiven Prozess zu.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetLifetimeService()
Veraltet.

Ruft das aktuelle Lebensdauerdienstobjekt ab, das die Lebensdauerrichtlinien für diese Instanz steuert.

(Geerbt von MarshalByRefObject)
GetProcessById(Int32)

Gibt eine neue Process-Komponente zurück, wenn der Bezeichner eines Prozesses auf dem lokalen Computer angegeben ist.

GetProcessById(Int32, String)

Gibt eine neue Process-Komponente zurück, wenn die Prozess-ID und der Name des Computers im Netzwerk angegeben sind.

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 lokalen Computer.

GetProcessesByName(String)

Erstellt ein Array neuer Process-Komponenten und ordnet diese allen Prozessressourcen auf dem lokalen Computer zu, die den angegebenen Prozessnamen gemeinsam verwenden.

GetProcessesByName(String, String)

Erstellt ein Array neuer Process-Komponenten und ordnet diese allen Prozessressourcen auf einem Remotecomputer zu, die den angegebenen Prozessnamen gemeinsam verwenden.

GetService(Type)

Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt.

(Geerbt von Component)
GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
InitializeLifetimeService()
Veraltet.

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.

(Geerbt von MarshalByRefObject)
Kill()

Hält den zugeordneten Prozess sofort an.

Kill(Boolean)

Beendet sofort den zugeordneten Prozess und optional seine untergeordneten Prozesse/Nachfolgerprozesse.

LeaveDebugMode()

Beendet den Zustand einer Process-Komponente, in dem sie mit Betriebssystemprozessen interagieren kann, die in einem speziellen Modus ausgeführt werden.

MemberwiseClone()

Erstellt eine flache Kopie des 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 über den zugeordneten Prozess, die in der Prozesskomponente zwischengespeichert waren.

Start()

Startet die von der StartInfo-Eigenschaft dieser Process-Komponente angegebene Prozessressource (oder verwendet sie erneut) und ordnet diese der Komponente zu.

Start(ProcessStartInfo)

Startet die Prozessressource, die durch den Parameter mit den Startinformationen für den Prozess angegeben wird (z. B. den Dateinamen des zu startenden Prozesses), und ordnet die Ressource einer neuen Process-Komponente zu.

Start(String)

Startet eine Prozessressource, indem der Name eines Dokuments oder einer Anwendungsdatei angegeben wird, und ordnet die Ressource einer neuen Process-Komponente zu.

Start(String, IEnumerable<String>)

Hiermit wird eine Prozessressource durch Angeben des Namens einer Anwendung und einer Reihe von Befehlszeilenargumenten gestartet.

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, String, SecureString, String)

Startet eine Prozessressource durch Angeben des Namens einer Anwendung, eines Benutzernamens 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 und einer Reihe von Befehlszeilenargumenten, eines Benutzernamens, eines Kennworts und einer Domäne und ordnet die Ressource einer neuen Process-Komponente zu.

ToString()

Formatiert den Prozessnamen als Zeichenfolge, ggf. kombiniert mit dem Typ der übergeordneten Komponente.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)
WaitForExit()

Weist die Process-Komponente an, unbestimmte Zeit zu warten, bis der zugeordnete Prozess beendet wird.

WaitForExit(Int32)

Weist die Process-Komponente an, für die Dauer von angegebenen Millisekunden zu warten, bis der zugeordnete Prozess beendet wird.

WaitForExit(TimeSpan)

Weist die Prozesskomponente an, die angegebene Zeit zu warten, bis der zugeordnete Prozess beendet wird.

WaitForExitAsync(CancellationToken)

Weist die Prozesskomponente an, zu warten, bis der zugeordnete Prozess beendet oder cancellationToken abgebrochen wird.

WaitForInputIdle()

Bewirkt, dass die Process-Komponente unbegrenzt wartet, bis der zugeordnete Prozess in den Leerlauf wechselt. Diese Überladung ist nur für Prozesse mit einer Benutzeroberfläche und einer Nachrichtenschleife gültig.

WaitForInputIdle(Int32)

Bewirkt, dass die Process-Komponente die Dauer von angegebenen Millisekunden wartet, bis der zugeordnete Prozess in den Leerlauf wechselt. Diese Überladung ist nur für Prozesse mit einer Benutzeroberfläche und einer Nachrichtenschleife gültig.

WaitForInputIdle(TimeSpan)

Verursacht, dass die Process Komponente auf den angegebenen timeout Prozess wartet, um einen Leerlaufstatus einzugeben. Diese Überladung ist nur für Prozesse mit einer Benutzeroberfläche und einer Nachrichtenschleife gültig.

Ereignisse

Disposed

Tritt auf, wenn die Komponente von einem Aufruf der Dispose()-Methode verworfen wird.

(Geerbt von Component)
ErrorDataReceived

Tritt auf, wenn eine Anwendung in ihren umgeleiteten StandardError-Stream schreibt.

Exited

Tritt beim Beenden eines Prozesses ein.

OutputDataReceived

Tritt jedes Mal auf, wenn eine Anwendung eine Zeile in ihren umgeleiteten StandardOutput-Stream schreibt.

Gilt für

Siehe auch