Process Process Process Process Class

Definizione

Fornisce l'accesso ai processi locali e remoti e permette di avviare e arrestare i processi locali del sistema.Provides access to local and remote processes and enables you to start and stop local system processes.

public ref class Process : System::ComponentModel::Component
public class Process : System.ComponentModel.Component
type Process = class
    inherit Component
Public Class Process
Inherits Component
Ereditarietà

Esempi

Nell'esempio seguente viene utilizzata un'istanza della Process classe per avviare un processo.The following example uses an instance of the Process class to start a process.

#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 is 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 is 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 is 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 Process la classe stessa e un Start metodo statico per avviare un processo.The following example uses the Process class itself and a static Start method to start a process.

#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()
{
    // 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 = 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()
            ' 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")
        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 'MyProcess
End Namespace 'MyProcessSample

Nell'esempio F# seguente viene definita runProc una funzione che avvia un processo, acquisisce tutte le informazioni di output e di errore e registra il numero di millisecondi di esecuzione del processo.The following F# example defines a runProc function that starts a process, captures all output and error information, and records the number of milliseconds that the process has run. La runProc funzione presenta tre parametri: il nome dell'applicazione da avviare, gli argomenti da fornire all'applicazione e la directory iniziale.The runProc function has three parameters: the name of application to launch, the arguments to supply to the application, and the starting directory.

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 con la licenza pubblica Microsoft.The code for the runProc function was written by ImaginaryDevelopment and is available under the Microsoft Public License.

Commenti

Un Process componente fornisce l'accesso a un processo in esecuzione in un computer.A Process component provides access to a process that is running on a computer. Un processo, in termini più semplici, è un'app in esecuzione.A process, in the simplest terms, is a running app. Un thread è l'unità di base in cui il sistema operativo alloca il tempo del processore.A thread is the basic unit to which the operating system allocates processor time. Un thread può eseguire qualsiasi parte del codice del processo, incluse le parti attualmente eseguite da un altro thread.A thread can execute any part of the code of the process, including parts currently being executed by another thread.

Il Process componente è uno strumento utile per avviare, arrestare, controllare e monitorare le app.The Process component is a useful tool for starting, stopping, controlling, and monitoring apps. È possibile utilizzare il Process componente per ottenere un elenco dei processi in esecuzione oppure è possibile avviare un nuovo processo.You can use the Process component, to obtain a list of the processes that are running, or you can start a new process. Un Process componente viene utilizzato per accedere ai processi di sistema.A Process component is used to access system processes. Una volta Process inizializzato, un componente può essere utilizzato per ottenere informazioni sul processo in esecuzione.After a Process component has been initialized, it can be used to obtain information about the running process. Tali informazioni includono il set di thread, i moduli caricati (file con estensione dll e exe) e le informazioni sulle prestazioni, ad esempio la quantità di memoria utilizzata dal processo.Such information includes the set of threads, the loaded modules (.dll and .exe files), and performance information such as the amount of memory the process is using.

Il tipo implementa l'interfaccia IDisposable.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare direttamente il tipo, chiamare il metodo Dispose in un blocco try/finally.To dispose of the type directly, call its Dispose method in a try/finally block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Uso di un oggetto che implementa IDisposable" nell'argomento relativo all'interfaccia IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Nota

i processi a 32 bit non possono accedere ai moduli di un processo a 64 bit.32-bit processes cannot access the modules of a 64-bit process. Se si tenta di ottenere informazioni su un processo a 64 bit da un processo a 32 bit, si otterrà un' Win32Exception eccezione.If you try to get information about a 64-bit process from a 32-bit process, you will get a Win32Exception exception. Un processo a 64 bit, d'altra parte, può accedere ai moduli di un processo a 32 bit.A 64-bit process, on the other hand, can access the modules of a 32-bit process.

Il componente Process ottiene tutte le informazioni su un gruppo di proprietà in una sola volta.The process component obtains information about a group of properties all at once. Dopo che Process il componente ha ottenuto informazioni su un membro di un gruppo, memorizza nella cache i valori per le altre proprietà del gruppo e non ottiene le nuove informazioni sugli altri membri del gruppo fino a quando non viene Refresh chiamato il metodo.After the Process component has obtained information about one member of any group, it will cache the values for the other properties in that group and not obtain new information about the other members of the group until you call the Refresh method. Pertanto, un valore della proprietà non è garantito che sia più recente dell'ultima chiamata al Refresh metodo.Therefore, a property value is not guaranteed to be any newer than the last call to the Refresh method. Le suddivisione del gruppo sono dipendenti dal sistema operativo.The group breakdowns are operating-system dependent.

Se nel sistema è stata dichiarata una variabile Path con le virgolette, è necessario qualificare completamente il percorso all'avvio di qualsiasi processo trovato in tale percorso.If you have a path variable declared in your system using quotes, you must fully qualify that path when starting any process found in that location. In caso contrario, il sistema non troverà il percorso.Otherwise, the system will not find the path. Se c:\mypath , ad esempio, non è presente nel percorso e viene aggiunto utilizzando le virgolette: path = %path%;"c:\mypath", è necessario qualificare completamente tutti i c:\mypath processi in al momento dell'avvio.For example, if c:\mypath is not in your path, and you add it using quotation marks: path = %path%;"c:\mypath", you must fully qualify any process in c:\mypath when starting it.

Un processo di sistema viene identificato in modo univoco nel sistema tramite il relativo identificatore di processo.A system process is uniquely identified on the system by its process identifier. Analogamente a molte risorse di Windows, un processo viene identificato anche dal relativo handle, che potrebbe non essere univoco nel computer.Like many Windows resources, a process is also identified by its handle, which might not be unique on the computer. Un handle è il termine generico per un identificatore di una risorsa.A handle is the generic term for an identifier of a resource. Il sistema operativo rende permanente l'handle Handle Process di processo, a cui si accede tramite la proprietà del componente, anche quando il processo è stato terminato.The operating system persists the process handle, which is accessed through the Handle property of the Process component, even when the process has exited. È quindi possibile ottenere le informazioni amministrative del processo, ad esempio ExitCode (in genere zero per l'esito positivo o un codice di errore diverso da zero) ExitTimee.Thus, you can get the process's administrative information, such as the ExitCode (usually either zero for success or a nonzero error code) and the ExitTime. Gli handle sono una risorsa estremamente preziosa, quindi la perdita di handle è più virulenta rispetto alla perdita di memoria.Handles are an extremely valuable resource, so leaking handles is more virulent than leaking memory.

Nota

Questa classe contiene una richiesta di collegamento e una richiesta di ereditarietà a livello di classe che si applica a tutti i membri.This class contains a link demand and an inheritance demand at the class level that applies to all members. Viene SecurityException generata un'eccezione quando il chiamante immediato o la classe derivata non dispone dell'autorizzazione di attendibilità totale.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Per informazioni dettagliate sulle richieste di sicurezza, vedere richieste di collegamento.For details about security demands, see Link Demands.

.NET Core.NET CoreNoteNotes

Nel .NET Framework, per impostazione Process predefinita la classe utilizza Console codifiche, che sono in genere codifiche della tabella codici, per i flussi di input, output e di errore.In the .NET Framework, the Process class by default uses Console encodings, which are typically code page encodings, for the input, output, and error streams. Per il codice di esempio, nei sistemi le cui impostazioni cultura sono la lingua inglese (Stati Uniti), la tabella codici Console 437 è la codifica predefinita per la classe.For example code, on systems whose culture is English (United States), code page 437 is the default encoding for the Console class. Tuttavia, .NET Core.NET Core può rendere disponibile solo un subset limitato di queste codifiche.However, .NET Core.NET Core may make only a limited subset of these encodings available. In tal caso, viene utilizzata Encoding.UTF8 come codifica predefinita.If this is the case, it uses Encoding.UTF8 as the default encoding.

Se un Process oggetto dipende da codifiche della tabella codici specifiche, è comunque possibile renderle disponibili effettuando le operazioni seguenti prima di chiamare qualsiasi Process metodo:If a Process object depends on specific code page encodings, you can still make them available by doing the following before you call any Process methods:

  1. Aggiungere un riferimento all'assembly System. Text. Encoding. codepages. dll al progetto.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Recuperare l' EncodingProvider oggetto CodePagesEncodingProvider.Instance dalla proprietà.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Passare l' EncodingProvider oggetto Encoding.RegisterProvider al metodo per rendere disponibili le codifiche aggiuntive supportate dal provider di codifica.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

La Process classe utilizzerà quindi automaticamente la codifica di sistema predefinita anziché UTF8, a condizione che il provider di codifica sia stato registrato prima Process di chiamare qualsiasi metodo.The Process class will then automatically use the default system encoding rather than UTF8, provided that you have registered the encoding provider before calling any Process methods.

Costruttori

Process() Process() Process() Process()

Inizializza una nuova istanza della classe Process.Initializes a new instance of the Process class.

Proprietà

BasePriority BasePriority BasePriority BasePriority

Ottiene la priorità base del processo associato.Gets the base priority of the associated process.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
Container Container Container Container

Ottiene il IContainer che contiene il Component.Gets the IContainer that contains the Component.

(Inherited from Component)
DesignMode DesignMode DesignMode DesignMode

Ottiene un valore che indica se il Component si trova in modalità progettazione.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents

Ottiene o imposta la generazione dell'evento Exited quando il processo viene terminato.Gets or sets whether the Exited event should be raised when the process terminates.

Events Events Events Events

Ottiene l'elenco dei gestori eventi allegati a questo Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
ExitCode ExitCode ExitCode ExitCode

Ottiene il valore specificato dal processo associato quando è stato terminato.Gets the value that the associated process specified when it terminated.

ExitTime ExitTime ExitTime ExitTime

Ottiene l'ora in cui il processo associato è stato terminato.Gets the time that the associated process exited.

Handle Handle Handle Handle

Ottiene l'handle nativo del processo associato.Gets the native handle of the associated process.

HandleCount HandleCount HandleCount HandleCount

Ottiene il numero di handle aperti dal processo.Gets the number of handles opened by the process.

HasExited HasExited HasExited HasExited

Ottiene un valore che indica se il processo associato è stato terminato.Gets a value indicating whether the associated process has been terminated.

Id Id Id Id

Ottiene l’identificatore univoco per il processo associato.Gets the unique identifier for the associated process.

MachineName MachineName MachineName MachineName

Ottiene il nome del computer sul quale è in esecuzione il processo associato.Gets the name of the computer the associated process is running on.

MainModule MainModule MainModule MainModule

Ottiene il modulo principale del processo associato.Gets the main module for the associated process.

MainWindowHandle MainWindowHandle MainWindowHandle MainWindowHandle

Ottiene l'handle della finestra principale del processo associato.Gets the window handle of the main window of the associated process.

MainWindowTitle MainWindowTitle MainWindowTitle MainWindowTitle

Ottiene la didascalia della finestra principale del processo.Gets the caption of the main window of the process.

MaxWorkingSet MaxWorkingSet MaxWorkingSet MaxWorkingSet

Ottiene o imposta la dimensione massima del working set, in byte, consentita per il processo associato.Gets or sets the maximum allowable working set size, in bytes, for the associated process.

MinWorkingSet MinWorkingSet MinWorkingSet MinWorkingSet

Ottiene o imposta la dimensione minima del working set, in byte, consentita per il processo associato.Gets or sets the minimum allowable working set size, in bytes, for the associated process.

Modules Modules Modules Modules

Ottiene i moduli che sono stati caricati dal processo associato.Gets the modules that have been loaded by the associated process.

NonpagedSystemMemorySize NonpagedSystemMemorySize NonpagedSystemMemorySize NonpagedSystemMemorySize

Ottiene la quantità di memoria di sistema non di paging, in byte, allocata per il processo associato.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

NonpagedSystemMemorySize64 NonpagedSystemMemorySize64 NonpagedSystemMemorySize64 NonpagedSystemMemorySize64

Ottiene la quantità di memoria di sistema non di paging, in byte, allocata per il processo associato.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

PagedMemorySize PagedMemorySize PagedMemorySize PagedMemorySize

Ottiene la quantità di memoria di paging, in byte, allocata per il processo associato.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedMemorySize64 PagedMemorySize64 PagedMemorySize64 PagedMemorySize64

Ottiene la quantità di memoria di paging, in byte, allocata per il processo associato.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedSystemMemorySize PagedSystemMemorySize PagedSystemMemorySize PagedSystemMemorySize

Ottiene la quantità di memoria di sistema paginabile, in byte, allocata per il processo associato.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PagedSystemMemorySize64 PagedSystemMemorySize64 PagedSystemMemorySize64 PagedSystemMemorySize64

Ottiene la quantità di memoria di sistema paginabile, in byte, allocata per il processo associato.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PeakPagedMemorySize PeakPagedMemorySize PeakPagedMemorySize PeakPagedMemorySize

Ottiene la quantità massima di memoria, in byte, nel file di paging della memoria virtuale usata dal processo associato.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakPagedMemorySize64 PeakPagedMemorySize64 PeakPagedMemorySize64 PeakPagedMemorySize64

Ottiene la quantità massima di memoria, in byte, nel file di paging della memoria virtuale usata dal processo associato.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakVirtualMemorySize PeakVirtualMemorySize PeakVirtualMemorySize PeakVirtualMemorySize

Ottiene la quantità massima di memoria virtuale in byte usata dal processo associato.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakVirtualMemorySize64 PeakVirtualMemorySize64 PeakVirtualMemorySize64 PeakVirtualMemorySize64

Ottiene la quantità massima di memoria virtuale in byte usata dal processo associato.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakWorkingSet PeakWorkingSet PeakWorkingSet PeakWorkingSet

Ottiene le dimensioni di picco del working set per il processo associato in byte.Gets the peak working set size for the associated process, in bytes.

PeakWorkingSet64 PeakWorkingSet64 PeakWorkingSet64 PeakWorkingSet64

Ottiene la quantità massima di memoria fisica in byte usata dal processo associato.Gets the maximum amount of physical memory, in bytes, used by the associated process.

PriorityBoostEnabled PriorityBoostEnabled PriorityBoostEnabled 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.Gets or sets a value indicating whether the associated process priority should temporarily be boosted by the operating system when the main window has the focus.

PriorityClass PriorityClass PriorityClass PriorityClass

Ottiene o imposta la categoria di priorità globale per il processo associato.Gets or sets the overall priority category for the associated process.

PrivateMemorySize PrivateMemorySize PrivateMemorySize PrivateMemorySize

Ottiene la quantità di memoria privata, in byte, allocata per il processo associato.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivateMemorySize64 PrivateMemorySize64 PrivateMemorySize64 PrivateMemorySize64

Ottiene la quantità di memoria privata, in byte, allocata per il processo associato.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivilegedProcessorTime PrivilegedProcessorTime PrivilegedProcessorTime PrivilegedProcessorTime

Ottiene il tempo privilegiato del processore per questo processo.Gets the privileged processor time for this process.

ProcessName ProcessName ProcessName ProcessName

Ottiene il nome del processo.Gets the name of the process.

ProcessorAffinity ProcessorAffinity ProcessorAffinity ProcessorAffinity

Ottiene o imposta i processori nei quali è pianificata l'esecuzione dei thread di questo processo.Gets or sets the processors on which the threads in this process can be scheduled to run.

Responding Responding Responding Responding

Ottiene un valore che indica se l'interfaccia utente del processo sta rispondendo.Gets a value indicating whether the user interface of the process is responding.

SafeHandle SafeHandle SafeHandle SafeHandle

Ottiene l'handle nativo di questo processo.Gets the native handle to this process.

SessionId SessionId SessionId SessionId

Ottiene l'identificatore della sessione di Servizi terminal per il processo associato.Gets the Terminal Services session identifier for the associated process.

Site Site Site Site

Ottiene o imposta l'oggetto ISite di Component.Gets or sets the ISite of the Component.

(Inherited from Component)
StandardError StandardError StandardError StandardError

Ottiene un flusso usato per leggere l'output di errore dell'applicazione.Gets a stream used to read the error output of the application.

StandardInput StandardInput StandardInput StandardInput

Ottiene un flusso usato per scrivere l'input dell'applicazione.Gets a stream used to write the input of the application.

StandardOutput StandardOutput StandardOutput StandardOutput

Ottiene un flusso usato per leggere l'output dell'applicazione.Gets a stream used to read the textual output of the application.

StartInfo StartInfo StartInfo StartInfo

Ottiene o imposta le proprietà da passare al metodo Start() del componente Process.Gets or sets the properties to pass to the Start() method of the Process.

StartTime StartTime StartTime StartTime

Ottiene l'ora in cui è stato avviato il processo associato.Gets the time that the associated process was started.

SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Ottiene o imposta l'oggetto usato per effettuare il marshalling delle chiamate del gestore eventi generate in seguito a un evento di terminazione di un processo.Gets or sets the object used to marshal the event handler calls that are issued as a result of a process exit event.

Threads Threads Threads Threads

Ottiene il gruppo di thread in esecuzione nel processo associato.Gets the set of threads that are running in the associated process.

TotalProcessorTime TotalProcessorTime TotalProcessorTime TotalProcessorTime

Ottiene il tempo totale del processore per questo processo.Gets the total processor time for this process.

UserProcessorTime UserProcessorTime UserProcessorTime UserProcessorTime

Ottiene il tempo utente del processore per questo processo.Gets the user processor time for this process.

VirtualMemorySize VirtualMemorySize VirtualMemorySize VirtualMemorySize

Ottiene la dimensione in byte della memoria virtuale del processo.Gets the size of the process's virtual memory, in bytes.

VirtualMemorySize64 VirtualMemorySize64 VirtualMemorySize64 VirtualMemorySize64

Ottiene la quantità di memoria virtuale, in byte, allocata per il processo associato.Gets the amount of the virtual memory, in bytes, allocated for the associated process.

WorkingSet WorkingSet WorkingSet WorkingSet

Ottiene l'utilizzo di memoria fisica del processo associato, espresso in byte.Gets the associated process's physical memory usage, in bytes.

WorkingSet64 WorkingSet64 WorkingSet64 WorkingSet64

Ottiene la quantità di memoria fisica, in byte, allocata per il processo associato.Gets the amount of physical memory, in bytes, allocated for the associated process.

Metodi

BeginErrorReadLine() BeginErrorReadLine() BeginErrorReadLine() BeginErrorReadLine()

Inizia le operazioni di lettura asincrona sul flusso StandardError reindirizzato dell'applicazione.Begins asynchronous read operations on the redirected StandardError stream of the application.

BeginOutputReadLine() BeginOutputReadLine() BeginOutputReadLine() BeginOutputReadLine()

Inizia le operazioni di lettura asincrona sul flusso StandardOutput reindirizzato dell'applicazione.Begins asynchronous read operations on the redirected StandardOutput stream of the application.

CancelErrorRead() CancelErrorRead() CancelErrorRead() CancelErrorRead()

Annulla l'operazione di lettura asincrona sul flusso StandardError reindirizzato di un'applicazione.Cancels the asynchronous read operation on the redirected StandardError stream of an application.

CancelOutputRead() CancelOutputRead() CancelOutputRead() CancelOutputRead()

Annulla l'operazione di lettura asincrona sul flusso StandardOutput reindirizzato di un'applicazione.Cancels the asynchronous read operation on the redirected StandardOutput stream of an application.

Close() Close() Close() Close()

Libera tutte le risorse associate a questo componente.Frees all the resources that are associated with this component.

CloseMainWindow() CloseMainWindow() CloseMainWindow() CloseMainWindow()

Chiude un processo che dispone di un'interfaccia utente inviando un messaggio di chiusura alla corrispondente finestra principale.Closes a process that has a user interface by sending a close message to its main window.

CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) 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.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() Dispose()
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Rilascia tutte le risorse usate dal processo.Release all resources used by this process.

EnterDebugMode() EnterDebugMode() EnterDebugMode() 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.Puts a Process component in state to interact with operating system processes that run in a special mode by enabling the native property SeDebugPrivilege on the current thread.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetCurrentProcess() GetCurrentProcess() GetCurrentProcess() GetCurrentProcess()

Ottiene un nuovo componente Process e lo associa al processo attivo.Gets a new Process component and associates it with the currently active process.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Consente di recuperare l'oggetto servizio di durata corrente per controllare i criteri di durata per l'istanza.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
GetProcessById(Int32) GetProcessById(Int32) GetProcessById(Int32) GetProcessById(Int32)

Restituisce un nuovo componente Process, dato l'identificatore di un processo nel computer locale.Returns a new Process component, given the identifier of a process on the local computer.

GetProcessById(Int32, String) GetProcessById(Int32, String) GetProcessById(Int32, String) GetProcessById(Int32, String)

Restituisce un nuovo componente Process, dato un identificatore di processo e il nome di un computer sulla rete.Returns a new Process component, given a process identifier and the name of a computer on the network.

GetProcesses() GetProcesses() GetProcesses() GetProcesses()

Crea un nuovo componente Process per ciascuna risorsa di processo del computer locale.Creates a new Process component for each process resource on the local computer.

GetProcesses(String) GetProcesses(String) GetProcesses(String) GetProcesses(String)

Crea un nuovo componente Process per ciascuna risorsa di processo nel computer specificato.Creates a new Process component for each process resource on the specified computer.

GetProcessesByName(String) GetProcessesByName(String) GetProcessesByName(String) 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.Creates an array of new Process components and associates them with all the process resources on the local computer that share the specified process name.

GetProcessesByName(String, String) GetProcessesByName(String, String) GetProcessesByName(String, String) 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.Creates an array of new Process components and associates them with all the process resources on a remote computer that share the specified process name.

GetService(Type) GetService(Type) GetService(Type) GetService(Type)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.Returns an object that represents a service provided by the Component or by its Container.

(Inherited from Component)
GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.Obtains a lifetime service object to control the lifetime policy for this instance.

(Inherited from MarshalByRefObject)
Kill() Kill() Kill() Kill()

Arresta immediatamente il processo associato.Immediately stops the associated process.

Kill(Boolean) Kill(Boolean) Kill(Boolean) Kill(Boolean)

Arresta immediatamente il processo associato e, facoltativamente, i processi figlio/discendenti.Immediately stops the associated process, and optionally its child/descendent processes.

LeaveDebugMode() LeaveDebugMode() LeaveDebugMode() LeaveDebugMode()

Fa uscire un componente Process dallo stato che permette di interagire con i processi del sistema operativo eseguiti in modalità speciale.Takes a Process component out of the state that lets it interact with operating system processes that run in a special mode.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

Crea una copia dei riferimenti dell'oggetto MarshalByRefObject corrente.Creates a shallow copy of the current MarshalByRefObject object.

(Inherited from MarshalByRefObject)
OnExited() OnExited() OnExited() OnExited()

Genera l'evento Exited.Raises the Exited event.

Refresh() Refresh() Refresh() Refresh()

Elimina le informazioni relative al processo associato memorizzate nella cache all'interno del componente del processo.Discards any information about the associated process that has been cached inside the process component.

Start() Start() Start() Start()

Avvia (o riutilizza) la risorsa di processo specificata dalla proprietà StartInfo di questo componente Process e la associa al componente.Starts (or reuses) the process resource that is specified by the StartInfo property of this Process component and associates it with the component.

Start(ProcessStartInfo) Start(ProcessStartInfo) Start(ProcessStartInfo) 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.Starts the process resource that is specified by the parameter containing process start information (for example, the file name of the process to start) and associates the resource with a new Process component.

Start(String) Start(String) Start(String) 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.Starts a process resource by specifying the name of a document or application file and associates the resource with a new Process component.

Start(String, String) Start(String, String) Start(String, String) 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.Starts a process resource by specifying the name of an application and a set of command-line arguments, and associates the resource with a new Process component.

Start(String, String, SecureString, String) Start(String, String, SecureString, String) Start(String, String, SecureString, String) 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.Starts a process resource by specifying the name of an application, a user name, a password, and a domain and associates the resource with a new Process component.

Start(String, String, String, SecureString, String) Start(String, String, String, SecureString, String) Start(String, String, String, SecureString, String) 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.Starts a process resource by specifying the name of an application, a set of command-line arguments, a user name, a password, and a domain and associates the resource with a new Process component.

ToString() ToString() ToString() ToString()

Converte il nome del processo in una stringa, combinandola al tipo di componente padre, se disponibile.Formats the process's name as a string, combined with the parent component type, if applicable.

WaitForExit() WaitForExit() WaitForExit() WaitForExit()

Indica al componente Process di attendere in modo indefinito la terminazione del processo associato.Instructs the Process component to wait indefinitely for the associated process to exit.

WaitForExit(Int32) WaitForExit(Int32) WaitForExit(Int32) WaitForExit(Int32)

Indica al componente Process di attendere per il numero specificato di millisecondi che il processo venga terminato.Instructs the Process component to wait the specified number of milliseconds for the associated process to exit.

WaitForInputIdle() WaitForInputIdle() WaitForInputIdle() WaitForInputIdle()

Il componente Process attenderà in modo indefinito che il processo associato entri in uno stato inattivo.Causes the Process component to wait indefinitely for the associated process to enter an idle state. Questo overload viene applicato soltanto ai processi dotati di interfaccia utente e, quindi, di un ciclo di messaggi.This overload applies only to processes with a user interface and, therefore, a message loop.

WaitForInputIdle(Int32) WaitForInputIdle(Int32) WaitForInputIdle(Int32) WaitForInputIdle(Int32)

Il componente Process attenderà per un numero specificato di millisecondi che il processo associato entri in uno stato inattivo.Causes the Process component to wait the specified number of milliseconds for the associated process to enter an idle state. Questo overload viene applicato soltanto ai processi dotati di interfaccia utente e, quindi, di un ciclo di messaggi.This overload applies only to processes with a user interface and, therefore, a message loop.

Eventi

Disposed Disposed Disposed Disposed

Si verifica quando il componente viene eliminato da una chiamata al metodo Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
ErrorDataReceived ErrorDataReceived ErrorDataReceived ErrorDataReceived

Si verifica quando un'applicazione scrive nel proprio flusso StandardError reindirizzato.Occurs when an application writes to its redirected StandardError stream.

Exited Exited Exited Exited

Si verifica al termine di un processo.Occurs when a process exits.

OutputDataReceived OutputDataReceived OutputDataReceived OutputDataReceived

Si verifica quando un'applicazione scrive nel proprio flusso StandardOutput reindirizzato.Occurs each time an application writes a line to its redirected StandardOutput stream.

Sicurezza

LinkDemand
per l'attendibilità totale per il chiamante immediato.for full trust for the immediate caller. Questa classe non può essere usata da codice parzialmente attendibile.This class cannot be used by partially trusted code.

InheritanceDemand
per l'attendibilità totale per gli eredi.for full trust for inheritors. Questa classe non può essere ereditata da codice parzialmente attendibile.This class cannot be inherited by partially trusted code.

Si applica a

Vedi anche