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 consente di avviare e arrestare i processi del sistema locale.

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 usata un'istanza della classe Process 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);
            }
        }
    }
}

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

Nell'esempio seguente viene utilizzata la classe Process stessa e un metodo Start statico 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();
        }
    }
}

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

L'esempio F# seguente definisce una funzione runProc che avvia un processo, acquisisce tutte le informazioni di output e di errore e registra il numero di millisecondi in cui è stato eseguito il processo. La funzione runProc 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 funzione runProc è stato scritto da ImaginaryDevelopment ed è disponibile nella Microsoft Public License.

Commenti

Un componente Process consente di accedere 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 componente Process è uno strumento utile per avviare, arrestare, controllare e monitorare le app. È possibile usare il componente Process per ottenere un elenco dei processi in esecuzione oppure avviare un nuovo processo. Un componente Process viene usato per accedere ai processi di sistema. Dopo l'inizializzazione di un componente Process, può essere usato 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.

Questo tipo implementa l'interfaccia IDisposable. Al termine dell'uso del tipo, è necessario eliminarlo direttamente o indirettamente. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/finally. Per eliminarlo indirettamente, usare un costrutto del linguaggio, 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 di metodi da questa classe con dati non attendibili è 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 che il componente Process ha ottenuto informazioni su un membro di qualsiasi gruppo, 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 metodo Refresh. Pertanto, non è garantito che un valore della proprietà sia più recente dell'ultima chiamata al metodo Refresh. Le suddivisioni del gruppo 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 all'avvio.

Un processo di sistema viene identificato in modo univoco nel sistema dall'identificatore del 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 proprietà Handle del componente Process, anche quando il processo è terminato. È quindi possibile ottenere le informazioni amministrative del processo, ad esempio il ExitCode (in genere zero per l'esito positivo o un codice di errore diverso da zero) e il 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 generata una SecurityException 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 classe Process usa per impostazione predefinita Console codifiche, che sono in genere codifiche della tabella codici, per i flussi di input, output e errore. Ad esempio, nei sistemi le cui impostazioni cultura sono inglese (Stati Uniti), la tabella codici 437 è la codifica predefinita per la classe Console. Tuttavia, .NET Core può rendere disponibile solo un subset limitato di queste codifiche. In questo caso, usa Encoding.UTF8 come codifica predefinita.

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

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

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

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

Costruttori

Process()

Inizializza una nuova istanza della classe Process.

Proprietà

BasePriority	Ottiene la priorità di base del processo associato.
CanRaiseEvents	Ottiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Container	Ottiene il IContainer che contiene il Component. (Ereditato da Component)
DesignMode	Ottiene un valore che indica se la Component è attualmente in modalità progettazione. (Ereditato da Component)
EnableRaisingEvents	Ottiene o imposta un valore che indica se l'evento Exited deve essere generato al termine del processo.
Events	Ottiene l'elenco dei gestori eventi associati a questo Component. (Ereditato da Component)
ExitCode	Ottiene il valore specificato dal processo associato al termine.
ExitTime	Ottiene l'ora di uscita del processo associato.
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 in cui è in esecuzione il processo associato.
MainModule	Ottiene il modulo principale per il 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 le dimensioni massime consentite del working set, in byte, per il processo associato.
MinWorkingSet	Ottiene o imposta la dimensione minima consentita del working set, espressa in byte, per il processo associato.
Modules	Ottiene i moduli 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 pageable, in byte, allocata per il processo associato.
PagedSystemMemorySize64	Ottiene la quantità di memoria di sistema pageable, in byte, allocata per il processo associato.
PeakPagedMemorySize	Obsoleti. Ottiene la quantità massima di memoria nel file di paging della memoria virtuale, in byte, utilizzata dal processo associato.
PeakPagedMemorySize64	Ottiene la quantità massima di memoria nel file di paging della memoria virtuale, in byte, utilizzata dal processo associato.
PeakVirtualMemorySize	Obsoleti. Ottiene la quantità massima di memoria virtuale, in byte, utilizzata dal processo associato.
PeakVirtualMemorySize64	Ottiene la quantità massima di memoria virtuale, in byte, utilizzata dal processo associato.
PeakWorkingSet	Obsoleti. Ottiene le dimensioni massime del working set per il processo associato, in byte.
PeakWorkingSet64	Ottiene la quantità massima di memoria fisica, in byte, utilizzata dal processo associato.
PriorityBoostEnabled	Ottiene o imposta un valore che indica se la priorità del processo associata deve essere temporaneamente incrementata dal sistema operativo quando la finestra principale ha lo stato attivo.
PriorityClass	Ottiene o imposta la categoria di priorità complessiva 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 del processore con privilegi per questo processo.
ProcessName	Ottiene il nome del processo.
ProcessorAffinity	Ottiene o imposta i processori in cui è possibile pianificare l'esecuzione dei thread in questo processo.
Responding	Ottiene un valore che indica se l'interfaccia utente del processo risponde.
SafeHandle	Ottiene l'handle nativo per questo processo.
SessionId	Ottiene l'identificatore di sessione di Servizi terminal per il processo associato.
Site	Ottiene o imposta il ISite del Component. (Ereditato da Component)
StandardError	Ottiene un flusso utilizzato per leggere l'output degli errori dell'applicazione.
StandardInput	Ottiene un flusso utilizzato per scrivere l'input dell'applicazione.
StandardOutput	Ottiene un flusso utilizzato per leggere l'output testuale dell'applicazione.
StartInfo	Ottiene o imposta le proprietà da passare al metodo Start() del Process.
StartTime	Ottiene l'ora di avvio del processo associato.
SynchronizingObject	Ottiene o imposta l'oggetto utilizzato per effettuare il marshalling delle chiamate del gestore eventi rilasciate come risultato di un evento di uscita del processo.
Threads	Ottiene il set di thread in esecuzione nel processo associato.
TotalProcessorTime	Ottiene il tempo totale del processore per questo processo.
UserProcessorTime	Ottiene il tempo del processore utente per questo processo.
VirtualMemorySize	Obsoleti. Ottiene le dimensioni della memoria virtuale del processo, in byte.
VirtualMemorySize64	Ottiene la quantità di memoria virtuale, in byte, allocata per il processo associato.
WorkingSet	Obsoleti. Ottiene l'utilizzo della memoria fisica del processo associato, in byte.
WorkingSet64	Ottiene la quantità di memoria fisica, in byte, allocata per il processo associato.

Metodi

BeginErrorReadLine()	Avvia operazioni di lettura asincrone sul flusso di StandardError reindirizzato dell'applicazione.
BeginOutputReadLine()	Avvia operazioni di lettura asincrone sul flusso di StandardOutput reindirizzato dell'applicazione.
CancelErrorRead()	Annulla l'operazione di lettura asincrona sul flusso di StandardError reindirizzato di un'applicazione.
CancelOutputRead()	Annulla l'operazione di lettura asincrona sul flusso di StandardOutput reindirizzato di un'applicazione.
Close()	Libera tutte le risorse associate a questo componente.
CloseMainWindow()	Chiude un processo con un'interfaccia utente inviando un messaggio di chiusura alla finestra principale.
CreateObjRef(Type)	Crea un oggetto che contiene tutte le informazioni pertinenti necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto. (Ereditato da MarshalByRefObject)
Dispose()	Rilascia tutte le risorse usate dal Component. (Ereditato da Component)
Dispose(Boolean)	Rilasciare tutte le risorse usate da questo processo.
EnterDebugMode()	Inserisce un componente Process nello stato per interagire con i processi del sistema operativo eseguiti in una modalità speciale abilitando la proprietà nativa SeDebugPrivilege nel 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 attualmente attivo.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetLifetimeService()	Obsoleti. Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza. (Ereditato da MarshalByRefObject)
GetProcessById(Int32, String)	Restituisce un nuovo componente Process, in base a un identificatore di processo e al nome di un computer in rete.
GetProcessById(Int32)	Restituisce un nuovo componente Process, dato l'identificatore di un processo nel computer locale.
GetProcesses()	Crea un nuovo componente Process per ogni risorsa di processo nel computer locale.
GetProcesses(String)	Crea un nuovo componente Process per ogni risorsa di processo nel computer 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 del processo 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 del processo specificato.
GetService(Type)	Restituisce un oggetto che rappresenta un servizio fornito dal Component o dal relativo Container. (Ereditato da Component)
GetType()	Ottiene il 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()	Accetta un componente Process dallo stato che consente di interagire con i processi del sistema operativo eseguiti in una modalità speciale.
MemberwiseClone()	Crea una copia superficiale del Objectcorrente. (Ereditato da Object)
MemberwiseClone(Boolean)	Crea una copia superficiale dell'oggetto MarshalByRefObject corrente. (Ereditato da MarshalByRefObject)
OnExited()	Genera l'evento Exited.
Refresh()	Rimuove tutte le informazioni sul processo associato memorizzato nella cache all'interno del componente di 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 del file del processo da avviare) 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, 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, un set di argomenti della riga di comando, un nome utente, una password e un dominio e associa la risorsa a un nuovo componente Process.
Start(String, String)	Avvia una risorsa di processo specificando il nome di un'applicazione e un set di argomenti della riga di comando e associa la risorsa a un nuovo componente Process.
Start(String)	Avvia una risorsa di processo specificando il nome di un documento o di un file dell'applicazione e associa la risorsa a un nuovo componente Process.
ToString()	Formatta il nome del processo come stringa, combinato con il tipo di componente padre, se applicabile.
WaitForExit()	Indica al componente Process di attendere a tempo indeterminato per l'uscita del processo associato.
WaitForExit(Int32)	Indica al componente Process di attendere il numero specificato di millisecondi per l'uscita del processo associato.
WaitForExit(TimeSpan)	Indica al componente Processo di attendere l'intervallo di tempo specificato per l'uscita del processo associato.
WaitForExitAsync(CancellationToken)	Indica al componente di processo di attendere che il processo associato venga chiuso o che il cancellationToken venga annullato.
WaitForInputIdle()	Fa sì che il componente Process attenda a tempo indeterminato affinché il processo associato entri in uno stato di inattività. Questo overload si applica solo ai processi con un'interfaccia utente e quindi a un ciclo di messaggi.
WaitForInputIdle(Int32)	Fa sì che il componente Process attenda il numero specificato di millisecondi affinché il processo associato immetta uno stato di inattività. Questo overload si applica solo ai processi con un'interfaccia utente e quindi a un ciclo di messaggi.
WaitForInputIdle(TimeSpan)	Fa sì che il componente Process attenda il timeout specificato affinché il processo associato immetta uno stato di inattività. Questo overload si applica solo ai processi con un'interfaccia utente e quindi a 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 flusso StandardError reindirizzato.
Exited	Si verifica quando un processo viene chiuso.
OutputDataReceived	Si verifica ogni volta che un'applicazione scrive una riga nel flusso StandardOutput reindirizzato.

Vedi anche

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