Process Třída

Definice

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

Dědičnost

Object

MarshalByRefObject

Component

Process

Dědičnost

Object

Process

Implementuje

IDisposable

Příklady

Následující příklad používá instanci třídy Process ke spuštění procesu.

#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

Následující příklad používá samotnou třídu Process a statickou metodu Start ke spuštění procesu.

#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

Následující příklad jazyka F# definuje funkci runProc, která spouští proces, zachycuje všechny informace o výstupu a chybě a zaznamenává počet milisekund, které proces spustil. Funkce runProc má tři parametry: název aplikace ke spuštění, argumenty pro zadání aplikace a počáteční adresář.

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

Kód funkce runProc napsal ImaginaryDevelopment a je k dispozici v rámci veřejné licence společnosti Microsoft.

Poznámky

Komponenta Process poskytuje přístup k procesu, který běží na počítači. Proces je v nejjednodušších termínech spuštěná aplikace. Vlákno je základní jednotka, pro kterou operační systém přiděluje čas procesoru. Vlákno může spustit jakoukoli část kódu procesu, včetně částí, které právě provádí jiné vlákno.

Komponenta Process je užitečný nástroj pro spouštění, zastavování, řízení a monitorování aplikací. Komponentu Process můžete použít k získání seznamu spuštěných procesů nebo můžete zahájit nový proces. Komponenta Process slouží k přístupu k procesům systému. Po inicializaci komponenty Process je možné ji použít k získání informací o spuštěném procesu. Tyto informace zahrnují sadu vláken, načtené moduly (.dll a .exe soubory) a informace o výkonu, jako je množství paměti, kterou proces používá.

Tento typ implementuje rozhraní IDisposable. Jakmile typ dokončíte, měli byste ho odstranit buď přímo, nebo nepřímo. Chcete-li typ odstranit přímo, zavolejte jeho Dispose metodu v bloku try/finally. Pokud ho chcete zlikvidovat nepřímo, použijte konstruktor jazyka, jako je using (v jazyce C#) nebo Using (v jazyce Visual Basic). Další informace najdete v části Použití objektu, který implementuje IDisposable v dokumentaci k rozhraní IDisposable.

Komponenta procesu získá informace o skupině vlastností najednou. Jakmile komponenta Process získá informace o jednom členu jakékoli skupiny, uloží hodnoty ostatních vlastností této skupiny do mezipaměti a nebude získávat nové informace o ostatních členech skupiny, dokud nezavoláte metodu Refresh. Proto není zaručena žádná novější hodnota vlastnosti než poslední volání metody Refresh. Rozpisy skupin jsou závislé na operačním systému.

Pokud máte v systému deklarovanou proměnnou cesty pomocí uvozovek, musíte tuto cestu při spuštění jakéhokoli procesu nalezeného v tomto umístění plně kvalifikovat. Jinak systém nenajde cestu. Pokud například c:\mypath není ve vaší cestě a přidáte ji pomocí uvozovek: path = %path%;"c:\mypath", musíte při spuštění plně kvalifikovat jakýkoli proces v c:\mypath.

Systémový proces je v systému jednoznačně identifikován jeho identifikátorem procesu. Stejně jako mnoho prostředků Systému Windows je proces také identifikován jeho popisovačem, který nemusí být v počítači jedinečný. Popisovač je obecný termín pro identifikátor prostředku. Operační systém zachovává popisovač procesu, ke kterému se přistupuje prostřednictvím vlastnosti Handle komponenty Process, i když proces ukončil. Můžete tak získat informace o správě procesu, například ExitCode (obvykle nula pro úspěch nebo nenulový kód chyby) a ExitTime. Popisovače jsou mimořádně cenným prostředkem, takže nevracení popisovačů je více virulentnější než nevrácení paměti.

Poznámky k .NET Core

V rozhraní .NET Framework používá třída Process ve výchozím nastavení pro vstupní, výstupní a chybové proudy kódování Console, což jsou obvykle kódování znakových stránek. Například v systémech, jejichž jazyková verze je angličtina (Spojené státy), kódová stránka 437 je výchozím kódováním pro třídu Console. .NET Core však může zpřístupnit pouze omezenou podmnožinu těchto kódování. V takovém případě se jako výchozí kódování používá Encoding.UTF8.

Pokud objekt závisí na konkrétním kódování znakové stránky, můžete je ještě před voláním libovolných metod zpřístupnit následujícím :

1. Načtěte objekt EncodingProvider z vlastnosti CodePagesEncodingProvider.Instance.

2. Předejte objekt EncodingProvider metodě Encoding.RegisterProvider, aby bylo možné zpřístupnit další kódování podporované poskytovatelem kódování.

Třída Process pak automaticky použije výchozí systémové kódování místo UTF8 za předpokladu, že jste před voláním jakékoli metody Process zaregistrovali zprostředkovatele kódování.

Konstruktory

Vlastnosti

Metody

Událost

Platí pro

Viz také

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