Process Klasse

Definition

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

Object

MarshalByRefObject

Component

Process

Vererbung

Object

Process

Implementiert

IDisposable

Beispiele

Im folgenden Beispiel wird ein instance 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 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 verfügt über drei Parameter: den Namen der zu startenden Anwendung, die Argumente, die für die Anwendung bereitgestellt 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 runProc Funktion wurde von ImaginaryDevelopment geschrieben und steht unter der öffentlichen Microsoft-Lizenz zur Verfügung.

Hinweise

Eine Process Komponente ermöglicht den Zugriff auf einen Prozess, der auf einem Computer ausgeführt wird. Ein Prozess ist im einfachsten Sinne eine ausgeführte App. Ein Thread ist die grundlegende Einheit, der das Betriebssystem Prozessorzeit zuweist. Ein Thread kann jeden 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. 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. Diese Informationen umfassen den Satz von Threads, die geladenen Module (.dll- und .exe-Dateien) sowie Leistungsinformationen wie die Menge des vom Prozess verwendeten Arbeitsspeichers.

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" in der IDisposable Schnittstellendokumentation.

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, speichert sie die Werte für die anderen Eigenschaften in dieser Gruppe zwischen und erhält erst dann neue Informationen zu den anderen Mitgliedern der Gruppe, bis Sie die Refresh -Methode aufrufen. Daher ist nicht garantiert, dass ein Eigenschaftswert neuer als der letzte Aufruf der Refresh -Methode ist. Die Gruppenaufschlüsselung ist betriebssystemabhängig.

Wenn Sie eine Pfadvariable in Ihrem System mithilfe von Anführungszeichen deklariert haben, müssen Sie diesen Pfad beim Starten eines Prozesses, der an diesem Speicherort gefunden wurde, vollständig qualifizieren. Andernfalls findet das System den Pfad nicht. Wenn c:\mypath sie sich beispielsweise nicht in Ihrem Pfad befindet und Sie ihn mithilfe von Anführungszeichen hinzufügen: path = %path%;"c:\mypath", müssen Sie jeden Prozess vollständig c:\mypath qualifizieren, wenn Sie ihn starten.

Ein Systemprozess wird auf dem System durch seinen Prozessbezeichner eindeutig identifiziert. Wie viele Windows-Ressourcen wird auch ein Prozess durch sein Handle identifiziert, das auf dem Computer möglicherweise nicht eindeutig 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. Daher können Sie die administrativen Informationen des Prozesses abrufen, z. B. den ExitCode (normalerweise entweder null für den Erfolg oder einen nichtzero-Fehlercode) und den ExitTime. Handles sind eine äußerst wertvolle Ressource, daher ist das Auslaufen von Handles virulenter als das Auslaufen von Speicher.

.NET Core-Hinweise

In .NET Framework verwendet Console die Process Klasse standardmäßig Codierungen, die in der Regel Codepagecodierungen sind, für die Eingabe-, Ausgabe- und Fehlerströme. Beispielcode auf Systemen, deren Kultur englisch (USA) ist, ist die Codepage 437 die Standardcodierung für die Console Klasse. .NET Core stellt jedoch möglicherweise nur eine begrenzte Teilmenge dieser Codierungen zur Verfügung. Wenn dies der Fall ist, wird als Standardcodierung verwendet Encoding.UTF8 .

Wenn ein Process Objekt von bestimmten Codepagecodierungen abhängig ist, können Sie sie trotzdem verfügbar machen, indem Sie vor dem Aufrufen von Process Methoden wie folgt vorgehen:

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

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

Die Process -Klasse verwendet dann automatisch die Standardsystemcodierung anstelle von UTF8, vorausgesetzt, Sie haben den Codierungsanbieter vor dem Aufrufen von Process Methoden registriert.

Konstruktoren

Eigenschaften

Methoden

Ereignisse

Gilt für:

Weitere Informationen

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