Process Classe

Definizione

Spazio dei nomi:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Origine:

Process.cs

Fornisce l'accesso ai processi locali e remoti e permette di avviare e arrestare i processi locali del sistema.

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

Ereditarietà

Object

MarshalByRefObject

Component

Process

Implementazioni

IDisposable

Esempio

Nell'esempio seguente viene utilizzata un'istanza della Process classe per avviare un processo.

#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

Nell'esempio seguente viene utilizzata la Process classe stessa e un metodo statico Start per avviare un processo.

#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

L'esempio F# seguente definisce una runProc funzione che avvia un processo, acquisisce tutte le informazioni di output e di errore e registra il numero di millisecondi eseguiti dal processo. La runProc funzione ha tre parametri: il nome dell'applicazione da avviare, gli argomenti da fornire all'applicazione e la directory iniziale.

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

Il codice per la runProc funzione è stato scritto da ImaginaryDevelopment ed è disponibile in Microsoft Public License.

Commenti

Un Process componente fornisce l'accesso a un processo in esecuzione in un computer. Un processo, in termini più semplici, è un'app in esecuzione. Un thread è l'unità di base a cui il sistema operativo alloca il tempo del processore. Un thread può eseguire qualsiasi parte del codice del processo, incluse le parti attualmente eseguite da un altro thread.

Il Process componente è uno strumento utile per avviare, arrestare, controllare e monitorare le app. È possibile usare il Process componente per ottenere un elenco dei processi in esecuzione oppure avviare un nuovo processo. Un Process componente viene usato per accedere ai processi di sistema. Dopo l'inizializzazione di un Process componente, è possibile usarlo per ottenere informazioni sul processo in esecuzione. Tali informazioni includono il set di thread, i moduli caricati (.dll e .exe file) e le informazioni sulle prestazioni, ad esempio la quantità di memoria usata dal processo.

Il tipo implementa l'interfaccia IDisposable. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/finally. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic. Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nella documentazione dell'interfaccia IDisposable .

Importante

La chiamata a metodi da questa classe con dati non attendibili costituisce un rischio per la sicurezza. Chiamare i metodi da questa classe solo con dati attendibili. Per altre informazioni, vedere Convalidare tutti gli input.

Nota

I processi a 32 bit non possono accedere ai moduli di un processo a 64 bit. Se si tenta di ottenere informazioni su un processo a 64 bit da un processo a 32 bit, si otterrà un'eccezione Win32Exception . Un processo a 64 bit, d'altra parte, può accedere ai moduli di un processo a 32 bit.

Il componente di processo ottiene informazioni su un gruppo di proprietà contemporaneamente. Dopo aver Process ottenuto informazioni su un membro di un gruppo, il componente memorizza nella cache i valori per le altre proprietà del gruppo e non ottiene nuove informazioni sugli altri membri del gruppo finché non si chiama il Refresh metodo . Pertanto, non è garantito che un valore della proprietà sia più recente dell'ultima chiamata al Refresh metodo . Le suddivisioni dei gruppi dipendono dal sistema operativo.

Se nel sistema è stata dichiarata una variabile di percorso usando le virgolette, è necessario qualificare completamente tale percorso all'avvio di qualsiasi processo trovato in tale posizione. In caso contrario, il sistema non troverà il percorso. Ad esempio, se c:\mypath non si trova nel percorso e lo si aggiunge usando virgolette: path = %path%;"c:\mypath", è necessario qualificare completamente qualsiasi processo in c:\mypath al momento dell'avvio.

Un processo di sistema viene identificato in modo univoco nel sistema in base al relativo identificatore di processo. Come molte risorse di Windows, un processo viene identificato anche dal relativo handle, che potrebbe non essere univoco nel computer. Un handle è il termine generico per un identificatore di una risorsa. Il sistema operativo mantiene l'handle del processo, accessibile tramite la Handle proprietà del Process componente, anche quando il processo è terminato. È quindi possibile ottenere le informazioni amministrative del processo, ad esempio (ExitCodein genere zero per l'esito positivo o un codice di errore diverso da zero) e .ExitTime Gli handle sono una risorsa estremamente preziosa, quindi gli handle di perdita sono più virulenti rispetto alla perdita di memoria.

Nota

Questa classe contiene una richiesta di collegamento e una richiesta di ereditarietà a livello di classe che si applica a tutti i membri. Viene SecurityException generata un'eccezione quando il chiamante immediato o la classe derivata non dispone dell'autorizzazione di attendibilità totale. Per informazioni dettagliate sulle richieste di sicurezza, vedere Richieste di collegamento.

Note su .NET Core

In .NET Framework la Process classe per impostazione predefinita usa Console codifiche, che in genere sono codifiche della tabella codici, per i flussi di input, output ed errore. Ad esempio, nel sistema le cui impostazioni cultura sono inglese (Stati Uniti), la tabella codici 437 è la codifica predefinita per la Console classe . Tuttavia, .NET Core può rendere disponibile solo un subset limitato di queste codifiche. In questo caso, usa Encoding.UTF8 come codifica predefinita.

Se un Process oggetto dipende da codifiche specifiche della tabella codici, è comunque possibile renderli disponibili eseguendo le operazioni seguenti prima di chiamare qualsiasi Process metodo:

1. Recuperare l'oggetto EncodingProvider dalla CodePagesEncodingProvider.Instance proprietà .

2. Passare l'oggetto EncodingProvider al Encoding.RegisterProvider metodo per rendere disponibili le codifiche aggiuntive supportate dal provider di codifica.

La Process classe userà quindi automaticamente la codifica di sistema predefinita anziché UTF8, purché sia stato registrato il provider di codifica prima di chiamare qualsiasi Process metodo.

Costruttori

Process()

Inizializza una nuova istanza della classe Process.

Proprietà

BasePriority	Ottiene la priorità base del processo associato.
CanRaiseEvents	Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Container	Ottiene l'oggetto IContainer che contiene Component. (Ereditato da Component)
DesignMode	Ottiene un valore che indica se il Component si trova in modalità progettazione. (Ereditato da Component)
EnableRaisingEvents	Ottiene o imposta la generazione dell'evento Exited quando il processo viene terminato.
Events	Ottiene l'elenco dei gestori eventi allegati a questo Component. (Ereditato da Component)
ExitCode	Ottiene il valore specificato dal processo associato quando è stato terminato.
ExitTime	Ottiene l'ora in cui il processo associato è stato terminato.
Handle	Ottiene l'handle nativo del processo associato.
HandleCount	Ottiene il numero di handle aperti dal processo.
HasExited	Ottiene un valore che indica se il processo associato è stato terminato.
Id	Ottiene l'identificatore univoco per il processo associato.
MachineName	Ottiene il nome del computer sul quale è in esecuzione il processo associato.
MainModule	Ottiene il modulo principale del processo associato.
MainWindowHandle	Ottiene l'handle della finestra principale del processo associato.
MainWindowTitle	Ottiene la didascalia della finestra principale del processo.
MaxWorkingSet	Ottiene o imposta la dimensione massima del working set, in byte, consentita per il processo associato.
MinWorkingSet	Ottiene o imposta la dimensione minima del working set, in byte, consentita per il processo associato.
Modules	Ottiene i moduli che sono stati caricati dal processo associato.
NonpagedSystemMemorySize	Obsoleti. Ottiene la quantità di memoria di sistema non di paging, in byte, allocata per il processo associato.
NonpagedSystemMemorySize64	Ottiene la quantità di memoria di sistema non di paging, in byte, allocata per il processo associato.
PagedMemorySize	Obsoleti. Ottiene la quantità di memoria di paging, in byte, allocata per il processo associato.
PagedMemorySize64	Ottiene la quantità di memoria di paging, in byte, allocata per il processo associato.
PagedSystemMemorySize	Obsoleti. Ottiene la quantità di memoria di sistema paginabile, in byte, allocata per il processo associato.
PagedSystemMemorySize64	Ottiene la quantità di memoria di sistema paginabile, in byte, allocata per il processo associato.
PeakPagedMemorySize	Obsoleti. Ottiene la quantità massima di memoria, in byte, nel file di paging della memoria virtuale usata dal processo associato.
PeakPagedMemorySize64	Ottiene la quantità massima di memoria, in byte, nel file di paging della memoria virtuale usata dal processo associato.
PeakVirtualMemorySize	Obsoleti. Ottiene la quantità massima di memoria virtuale in byte usata dal processo associato.
PeakVirtualMemorySize64	Ottiene la quantità massima di memoria virtuale in byte usata dal processo associato.
PeakWorkingSet	Obsoleti. Ottiene le dimensioni di picco del working set per il processo associato in byte.
PeakWorkingSet64	Ottiene la quantità massima di memoria fisica in byte usata dal processo associato.
PriorityBoostEnabled	Ottiene o imposta un valore che indica se la priorità del processo associato deve essere incrementata temporaneamente dal sistema operativo quando la finestra principale è attiva.
PriorityClass	Ottiene o imposta la categoria di priorità globale per il processo associato.
PrivateMemorySize	Obsoleti. Ottiene la quantità di memoria privata, in byte, allocata per il processo associato.
PrivateMemorySize64	Ottiene la quantità di memoria privata, in byte, allocata per il processo associato.
PrivilegedProcessorTime	Ottiene il tempo privilegiato del processore per questo processo.
ProcessName	Ottiene il nome del processo.
ProcessorAffinity	Ottiene o imposta i processori nei quali è pianificata l'esecuzione dei thread di questo processo.
Responding	Ottiene un valore che indica se l'interfaccia utente del processo sta rispondendo.
SafeHandle	Ottiene l'handle nativo di questo processo.
SessionId	Ottiene l'identificatore della sessione di Servizi terminal per il processo associato.
Site	Ottiene o imposta l'oggetto ISite di Component. (Ereditato da Component)
StandardError	Ottiene un flusso usato per leggere l'output di errore dell'applicazione.
StandardInput	Ottiene un flusso usato per scrivere l'input dell'applicazione.
StandardOutput	Ottiene un flusso usato per leggere l'output dell'applicazione.
StartInfo	Ottiene o imposta le proprietà da passare al metodo Start() del componente Process.
StartTime	Ottiene l'ora in cui è stato avviato il processo associato.
SynchronizingObject	Ottiene o imposta l'oggetto usato per effettuare il marshalling delle chiamate del gestore dell'evento generate in seguito a un evento di terminazione di un processo.
Threads	Ottiene il gruppo di thread in esecuzione nel processo associato.
TotalProcessorTime	Ottiene il tempo totale del processore per questo processo.
UserProcessorTime	Ottiene il tempo utente del processore per questo processo.
VirtualMemorySize	Obsoleti. Ottiene la dimensione in byte della memoria virtuale del processo.
VirtualMemorySize64	Ottiene la quantità di memoria virtuale, in byte, allocata per il processo associato.
WorkingSet	Obsoleti. Ottiene l'utilizzo di memoria fisica del processo associato, espresso in byte.
WorkingSet64	Ottiene la quantità di memoria fisica, in byte, allocata per il processo associato.

Metodi

BeginErrorReadLine()	Inizia le operazioni di lettura asincrona sul flusso StandardError reindirizzato dell'applicazione.
BeginOutputReadLine()	Inizia le operazioni di lettura asincrona sul flusso StandardOutput reindirizzato dell'applicazione.
CancelErrorRead()	Annulla l'operazione di lettura asincrona sul flusso StandardError reindirizzato di un'applicazione.
CancelOutputRead()	Annulla l'operazione di lettura asincrona sul flusso StandardOutput reindirizzato di un'applicazione.
Close()	Libera tutte le risorse associate a questo componente.
CloseMainWindow()	Chiude un processo che dispone di un'interfaccia utente inviando un messaggio di chiusura alla corrispondente finestra principale.
CreateObjRef(Type)	Consente di creare un oggetto che contiene tutte le informazioni rilevanti necessarie per la generazione del proxy utilizzato per effettuare la comunicazione con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate da Component. (Ereditato da Component)
Dispose(Boolean)	Rilascia tutte le risorse usate dal processo.
EnterDebugMode()	Imposta un componente Process nello stato che gli permette di interagire con i processi del sistema operativo eseguiti in modalità speciale attivando la proprietà nativa SeDebugPrivilege sul thread corrente.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetCurrentProcess()	Ottiene un nuovo componente Process e lo associa al processo attivo.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza. (Ereditato da MarshalByRefObject)
GetProcessById(Int32)	Restituisce un nuovo componente Process, dato l'identificatore di un processo nel computer locale.
GetProcessById(Int32, String)	Restituisce un nuovo componente Process, dato un identificatore di processo e il nome di un computer sulla rete.
GetProcesses()	Crea un nuovo componente Process per ciascuna risorsa di processo del computer locale.
GetProcesses(String)	Crea un nuovo componente Process per ciascuna risorsa di processo nel computer specificato.
GetProcessesByName(String)	Crea una matrice di nuovi componenti Process e li associa a tutte le risorse di processo nel computer locale che condividono il nome di processo specificato.
GetProcessesByName(String, String)	Crea una matrice di nuovi componenti Process e li associa a tutte le risorse di processo in un computer remoto che condividono il nome di processo specificato.
GetService(Type)	Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container. (Ereditato da Component)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
InitializeLifetimeService()	Obsoleti. Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
Kill()	Arresta immediatamente il processo associato.
Kill(Boolean)	Arresta immediatamente il processo associato e, facoltativamente, i processi figlio/discendenti.
LeaveDebugMode()	Fa uscire un componente Process dallo stato che permette di interagire con i processi del sistema operativo eseguiti in modalità speciale.
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OnExited()	Genera l'evento Exited.
Refresh()	Elimina le informazioni relative al processo associato memorizzate nella cache all'interno del componente del processo.
Start()	Avvia (o riutilizza) la risorsa di processo specificata dalla proprietà StartInfo di questo componente Process e la associa al componente.
Start(ProcessStartInfo)	Avvia la risorsa di processo specificata dal parametro contenente le informazioni di avvio del processo (ad esempio, il nome file del processo da avviare) e associa la risorsa a un nuovo componente Process.
Start(String)	Avvia una risorsa di processo specificando il nome di un documento o un file di applicazione e associa la risorsa a un nuovo componente Process.
Start(String, IEnumerable<String>)	Avvia una risorsa di processo specificando il nome di un'applicazione e un set di argomenti della riga di comando.
Start(String, String)	Avvia una risorsa di processo specificando il nome di un'applicazione e un insieme di argomenti della riga di comando e associa la risorsa a un nuovo componente Process.
Start(String, String, SecureString, String)	Avvia una risorsa di processo specificando il nome di un'applicazione, un nome utente, una password e un dominio e associa la risorsa a un nuovo componente Process.
Start(String, String, String, SecureString, String)	Avvia una risorsa di processo specificando il nome di un'applicazione e un insieme di argomenti della riga di comando, un nome utente, una password e un dominio, e associa la risorsa a un nuovo componente Process.
ToString()	Converte il nome del processo in una stringa, combinandola al tipo di componente padre, se disponibile.
WaitForExit()	Indica al componente Process di attendere in modo indefinito la terminazione del processo associato.
WaitForExit(Int32)	Indica al componente Process di attendere per il numero specificato di millisecondi che il processo venga terminato.
WaitForExit(TimeSpan)	Indica al componente Process di attendere il tempo specificato per uscire dal processo associato.
WaitForExitAsync(CancellationToken)	Indica al componente del processo di attendere il termine del processo associato o che il cancellationToken venga annullato.
WaitForInputIdle()	Il componente Process attenderà in modo indefinito che il processo associato entri in uno stato inattivo. Questo overload viene applicato soltanto ai processi dotati di interfaccia utente e, quindi, di un ciclo di messaggi.
WaitForInputIdle(Int32)	Il componente Process attenderà per un numero specificato di millisecondi che il processo associato entri in uno stato inattivo. Questo overload viene applicato soltanto ai processi dotati di interfaccia utente e, quindi, di un ciclo di messaggi.
WaitForInputIdle(TimeSpan)	Fa sì che il Process componente attenda l'oggetto specificato timeout affinché il processo associato entri in uno stato di inattività. Questo overload viene applicato soltanto ai processi dotati di interfaccia utente e, quindi, di un ciclo di messaggi.

Eventi

Disposed	Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose(). (Ereditato da Component)
ErrorDataReceived	Si verifica quando un'applicazione scrive nel proprio flusso StandardError reindirizzato.
Exited	Si verifica al termine di un processo.
OutputDataReceived	Si verifica quando un'applicazione scrive nel proprio flusso StandardOutput reindirizzato.

Vedi anche

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