Process Classe

Définition

Espace de noms:

System.Diagnostics

Assembly:

System.Diagnostics.Process.dll

Source:

Process.cs

Fournit l’accès aux processus locaux et distants et vous permet de démarrer et d’arrêter les processus système locaux.

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

Héritage

Object

MarshalByRefObject

Component

Process

Implémente

IDisposable

Exemples

L’exemple suivant utilise une instance de la classe Process pour démarrer un processus.

#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

L’exemple suivant utilise la classe Process elle-même et une méthode de Start statique pour démarrer un processus.

#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’exemple F# suivant définit une fonction runProc qui démarre un processus, capture toutes les informations de sortie et d’erreur, et enregistre le nombre de millisecondes que le processus a exécutées. La fonction runProc a trois paramètres : le nom de l’application à lancer, les arguments à fournir à l’application et le répertoire de démarrage.

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

Le code de la fonction a été écrit par ImaginaryDevelopment et est disponible sous lede licence publique Microsoft .

Remarques

Un composant Process fournit l’accès à un processus en cours d’exécution sur un ordinateur. Un processus, en termes les plus simples, est une application en cours d’exécution. Un thread est l’unité de base à laquelle le système d’exploitation alloue du temps processeur. Un thread peut exécuter n’importe quelle partie du code du processus, y compris les parties en cours d’exécution par un autre thread.

Le composant Process est un outil utile pour démarrer, arrêter, contrôler et surveiller les applications. Vous pouvez utiliser le composant Process, pour obtenir la liste des processus en cours d’exécution, ou démarrer un nouveau processus. Un composant Process est utilisé pour accéder aux processus système. Une fois qu’un composant Process a été initialisé, il peut être utilisé pour obtenir des informations sur le processus en cours d’exécution. Ces informations incluent l’ensemble de threads, les modules chargés (.dll et .exe fichiers) et les informations de performances telles que la quantité de mémoire utilisée par le processus.

Ce type implémente l’interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer le type directement, appelez sa méthode Dispose dans un bloc try/finally. Pour le supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet implémentant IDisposable » dans la documentation de l’interface IDisposable.

Important

L’appel de méthodes de cette classe avec des données non approuvées est un risque de sécurité. Appelez les méthodes de cette classe uniquement avec des données approuvées. Pour plus d’informations, consultez Valider toutes les entrées.

Note

Les processus 32 bits ne peuvent pas accéder aux modules d’un processus 64 bits. Si vous essayez d’obtenir des informations sur un processus 64 bits à partir d’un processus 32 bits, vous obtiendrez une exception Win32Exception. Un processus 64 bits, d’autre part, peut accéder aux modules d’un processus 32 bits.

Le composant de processus obtient des informations sur un groupe de propriétés en même temps. Une fois que le composant Process a obtenu des informations sur un membre d’un groupe, il met en cache les valeurs des autres propriétés de ce groupe et n’obtient pas de nouvelles informations sur les autres membres du groupe tant que vous n’appelez pas la méthode Refresh. Par conséquent, une valeur de propriété n’est pas garantie comme étant plus récente que le dernier appel à la méthode Refresh. Les répartitions de groupes dépendent du système d’exploitation.

Si vous disposez d’une variable de chemin d’accès déclarée dans votre système à l’aide de guillemets, vous devez qualifier pleinement ce chemin lors du démarrage d’un processus trouvé à cet emplacement. Sinon, le système ne trouve pas le chemin d’accès. Par exemple, si c:\mypath n’est pas dans votre chemin d’accès et que vous l’ajoutez à l’aide de guillemets : path = %path%;"c:\mypath", vous devez qualifier entièrement tout processus dans c:\mypath lors du démarrage.

Un processus système est identifié de façon unique sur le système par son identificateur de processus. Comme de nombreuses ressources Windows, un processus est également identifié par son handle, qui peut ne pas être unique sur l’ordinateur. Un handle est le terme générique d’un identificateur d’une ressource. Le système d’exploitation conserve le handle de processus, accessible via la propriété Handle du composant Process, même lorsque le processus a quitté. Ainsi, vous pouvez obtenir les informations administratives du processus, telles que la ExitCode (généralement zéro pour la réussite ou un code d’erreur différent de zéro) et le ExitTime. Les poignées sont une ressource extrêmement précieuse, de sorte que les poignées de fuite sont plus agressives que la fuite de mémoire.

Note

Cette classe contient une demande de liaison et une demande d’héritage au niveau de la classe qui s’applique à tous les membres. Une SecurityException est levée lorsque l’appelant immédiat ou la classe dérivée n’a pas d’autorisation de confiance totale. Pour plus d’informations sur les demandes de sécurité, consultez Link Demands.

Notes .NET Core

Dans .NET Framework, la classe Process utilise par défaut des encodages Console, qui sont généralement des encodages de page de codes, pour les flux d’entrée, de sortie et d’erreur. Par exemple, sur les systèmes dont la culture est anglaise (États-Unis), la page de codes 437 est l’encodage par défaut pour la classe Console. Toutefois, .NET Core ne peut rendre disponible qu’un sous-ensemble limité de ces encodages. Si c’est le cas, il utilise Encoding.UTF8 comme encodage par défaut.

Si un objet Process dépend d’encodages de page de codes spécifiques, vous pouvez toujours les rendre disponibles en effectuant les suivantes avant vous appelez des méthodes Process :

1. Récupérez l’objet EncodingProvider à partir de la propriété CodePagesEncodingProvider.Instance.

2. Transmettez l’objet EncodingProvider à la méthode Encoding.RegisterProvider pour rendre les encodages supplémentaires pris en charge par le fournisseur d’encodage.

La classe Process utilise alors automatiquement l’encodage système par défaut plutôt que UTF8, à condition que vous ayez inscrit le fournisseur d’encodage avant d’appeler des méthodes Process.

Constructeurs

Process()

Initialise une nouvelle instance de la classe Process.

Propriétés

BasePriority	Obtient la priorité de base du processus associé.
CanRaiseEvents	Obtient une valeur indiquant si le composant peut déclencher un événement. (Hérité de Component)
Container	Obtient le IContainer qui contient le Component. (Hérité de Component)
DesignMode	Obtient une valeur qui indique si le Component est actuellement en mode création. (Hérité de Component)
EnableRaisingEvents	Obtient ou définit si l’événement Exited doit être déclenché lorsque le processus se termine.
Events	Obtient la liste des gestionnaires d’événements qui sont attachés à cette Component. (Hérité de Component)
ExitCode	Obtient la valeur spécifiée par le processus associé lorsqu’il s’est terminé.
ExitTime	Obtient l’heure à laquelle le processus associé s’est arrêté.
Handle	Obtient le handle natif du processus associé.
HandleCount	Obtient le nombre de handles ouverts par le processus.
HasExited	Obtient une valeur indiquant si le processus associé a été arrêté.
Id	Obtient l’identificateur unique du processus associé.
MachineName	Obtient le nom de l’ordinateur sur lequel s’exécute le processus associé.
MainModule	Obtient le module principal du processus associé.
MainWindowHandle	Obtient le handle de fenêtre de la fenêtre principale du processus associé.
MainWindowTitle	Obtient la légende de la fenêtre principale du processus.
MaxWorkingSet	Obtient ou définit la taille maximale autorisée du jeu de travail, en octets, pour le processus associé.
MinWorkingSet	Obtient ou définit la taille minimale autorisée du jeu de travail autorisé, en octets, pour le processus associé.
Modules	Obtient les modules qui ont été chargés par le processus associé.
NonpagedSystemMemorySize	Obsolète. Obtient la quantité de mémoire système non paginé, en octets, allouée pour le processus associé.
NonpagedSystemMemorySize64	Obtient la quantité de mémoire système non paginé, en octets, allouée pour le processus associé.
PagedMemorySize	Obsolète. Obtient la quantité de mémoire paginée, en octets, allouée pour le processus associé.
PagedMemorySize64	Obtient la quantité de mémoire paginée, en octets, allouée pour le processus associé.
PagedSystemMemorySize	Obsolète. Obtient la quantité de mémoire système paginable, en octets, allouée pour le processus associé.
PagedSystemMemorySize64	Obtient la quantité de mémoire système paginable, en octets, allouée pour le processus associé.
PeakPagedMemorySize	Obsolète. Obtient la quantité maximale de mémoire dans le fichier de pagination de la mémoire virtuelle, en octets, utilisée par le processus associé.
PeakPagedMemorySize64	Obtient la quantité maximale de mémoire dans le fichier de pagination de la mémoire virtuelle, en octets, utilisée par le processus associé.
PeakVirtualMemorySize	Obsolète. Obtient la quantité maximale de mémoire virtuelle, en octets, utilisée par le processus associé.
PeakVirtualMemorySize64	Obtient la quantité maximale de mémoire virtuelle, en octets, utilisée par le processus associé.
PeakWorkingSet	Obsolète. Obtient la taille de jeu de travail de pointe pour le processus associé, en octets.
PeakWorkingSet64	Obtient la quantité maximale de mémoire physique, en octets, utilisée par le processus associé.
PriorityBoostEnabled	Obtient ou définit une valeur indiquant si la priorité de processus associée doit être temporairement renforcée par le système d’exploitation lorsque la fenêtre principale a le focus.
PriorityClass	Obtient ou définit la catégorie de priorité globale pour le processus associé.
PrivateMemorySize	Obsolète. Obtient la quantité de mémoire privée, en octets, allouée pour le processus associé.
PrivateMemorySize64	Obtient la quantité de mémoire privée, en octets, allouée pour le processus associé.
PrivilegedProcessorTime	Obtient le temps processeur privilégié pour ce processus.
ProcessName	Obtient le nom du processus.
ProcessorAffinity	Obtient ou définit les processeurs sur lesquels les threads de ce processus peuvent être planifiés pour s’exécuter.
Responding	Obtient une valeur indiquant si l’interface utilisateur du processus répond.
SafeHandle	Obtient le handle natif de ce processus.
SessionId	Obtient l’identificateur de session Terminal Services pour le processus associé.
Site	Obtient ou définit la ISite du Component. (Hérité de Component)
StandardError	Obtient un flux utilisé pour lire la sortie d’erreur de l’application.
StandardInput	Obtient un flux utilisé pour écrire l’entrée de l’application.
StandardOutput	Obtient un flux utilisé pour lire la sortie textuelle de l’application.
StartInfo	Obtient ou définit les propriétés à passer à la méthode Start() du Process.
StartTime	Obtient l’heure à laquelle le processus associé a été démarré.
SynchronizingObject	Obtient ou définit l’objet utilisé pour marshaler les appels de gestionnaire d’événements émis à la suite d’un événement de sortie de processus.
Threads	Obtient l’ensemble de threads en cours d’exécution dans le processus associé.
TotalProcessorTime	Obtient le temps processeur total pour ce processus.
UserProcessorTime	Obtient le temps processeur utilisateur pour ce processus.
VirtualMemorySize	Obsolète. Obtient la taille de la mémoire virtuelle du processus, en octets.
VirtualMemorySize64	Obtient la quantité de mémoire virtuelle, en octets, allouée pour le processus associé.
WorkingSet	Obsolète. Obtient l’utilisation de la mémoire physique du processus associé, en octets.
WorkingSet64	Obtient la quantité de mémoire physique, en octets, allouée pour le processus associé.

Méthodes

BeginErrorReadLine()	Commence les opérations de lecture asynchrones sur le flux de StandardError redirigé de l’application.
BeginOutputReadLine()	Commence les opérations de lecture asynchrones sur le flux de StandardOutput redirigé de l’application.
CancelErrorRead()	Annule l’opération de lecture asynchrone sur le flux de StandardError redirigé d’une application.
CancelOutputRead()	Annule l’opération de lecture asynchrone sur le flux de StandardOutput redirigé d’une application.
Close()	Libère toutes les ressources associées à ce composant.
CloseMainWindow()	Ferme un processus qui a une interface utilisateur en envoyant un message de fermeture à sa fenêtre principale.
CreateObjRef(Type)	Crée un objet qui contient toutes les informations pertinentes requises pour générer un proxy utilisé pour communiquer avec un objet distant. (Hérité de MarshalByRefObject)
Dispose()	Libère toutes les ressources utilisées par le Component. (Hérité de Component)
Dispose(Boolean)	Relâchez toutes les ressources utilisées par ce processus.
EnterDebugMode()	Place un composant Process en état pour interagir avec les processus du système d’exploitation qui s’exécutent en mode spécial en activant la propriété native SeDebugPrivilege sur le thread actuel.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetCurrentProcess()	Obtient un nouveau composant Process et l’associe au processus actif.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetLifetimeService()	Obsolète. Récupère l’objet de service de durée de vie actuel qui contrôle la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
GetProcessById(Int32, String)	Retourne un nouveau composant Process, en fonction d’un identificateur de processus et du nom d’un ordinateur sur le réseau.
GetProcessById(Int32)	Retourne un nouveau composant Process, en fonction de l’identificateur d’un processus sur l’ordinateur local.
GetProcesses()	Crée un composant Process pour chaque ressource de processus sur l’ordinateur local.
GetProcesses(String)	Crée un composant Process pour chaque ressource de processus sur l’ordinateur spécifié.
GetProcessesByName(String, String)	Crée un tableau de nouveaux composants Process et les associe à toutes les ressources de processus sur un ordinateur distant qui partagent le nom de processus spécifié.
GetProcessesByName(String)	Crée un tableau de nouveaux composants Process et les associe à toutes les ressources de processus sur l’ordinateur local qui partagent le nom de processus spécifié.
GetService(Type)	Renvoie un objet qui représente un service fourni par l'Component ou par son Container. (Hérité de Component)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
InitializeLifetimeService()	Obsolète. Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance. (Hérité de MarshalByRefObject)
Kill()	Arrête immédiatement le processus associé.
Kill(Boolean)	Arrête immédiatement le processus associé et éventuellement ses processus enfants/descendants.
LeaveDebugMode()	Prend un composant Process hors de l’état qui lui permet d’interagir avec les processus du système d’exploitation qui s’exécutent en mode spécial.
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
MemberwiseClone(Boolean)	Crée une copie superficielle de l’objet MarshalByRefObject actuel. (Hérité de MarshalByRefObject)
OnExited()	Déclenche l’événement Exited.
Refresh()	Ignore toutes les informations sur le processus associé qui a été mis en cache à l’intérieur du composant de processus.
Start()	Démarre (ou réutilise) la ressource de processus spécifiée par la propriété StartInfo de ce composant Process et l’associe au composant.
Start(ProcessStartInfo)	Démarre la ressource de processus spécifiée par le paramètre contenant les informations de démarrage du processus (par exemple, le nom de fichier du processus à démarrer) et associe la ressource à un nouveau composant Process.
Start(String, IEnumerable<String>)	Démarre une ressource de processus en spécifiant le nom d’une application et un ensemble d’arguments de ligne de commande.
Start(String, String, SecureString, String)	Démarre une ressource de processus en spécifiant le nom d’une application, un nom d’utilisateur, un mot de passe et un domaine et associe la ressource à un nouveau composant Process.
Start(String, String, String, SecureString, String)	Démarre une ressource de processus en spécifiant le nom d’une application, un ensemble d’arguments de ligne de commande, un nom d’utilisateur, un mot de passe et un domaine et associe la ressource à un nouveau composant Process.
Start(String, String)	Démarre une ressource de processus en spécifiant le nom d’une application et un ensemble d’arguments de ligne de commande, puis associe la ressource à un nouveau composant Process.
Start(String)	Démarre une ressource de processus en spécifiant le nom d’un document ou d’un fichier d’application et en associant la ressource à un nouveau composant Process.
ToString()	Met en forme le nom du processus sous forme de chaîne, combiné au type de composant parent, le cas échéant.
WaitForExit()	Indique au composant Process d’attendre indéfiniment la sortie du processus associé.
WaitForExit(Int32)	Indique au composant Process d’attendre le nombre spécifié de millisecondes pour que le processus associé se termine.
WaitForExit(TimeSpan)	Indique au composant Processus d’attendre la durée spécifiée pour que le processus associé se termine.
WaitForExitAsync(CancellationToken)	Indique au composant de processus d’attendre la sortie du processus associé ou l’annulation de la cancellationToken.
WaitForInputIdle()	Provoque l’attente indéfinie du composant Process pour que le processus associé entre dans un état inactif. Cette surcharge s’applique uniquement aux processus avec une interface utilisateur et, par conséquent, à une boucle de message.
WaitForInputIdle(Int32)	Provoque le Process composant d’attendre le nombre spécifié de millisecondes pour que le processus associé entre un état inactif. Cette surcharge s’applique uniquement aux processus avec une interface utilisateur et, par conséquent, à une boucle de message.
WaitForInputIdle(TimeSpan)	Provoque l’attente du composant Process spécifié timeout pour que le processus associé entre un état inactif. Cette surcharge s’applique uniquement aux processus avec une interface utilisateur et, par conséquent, à une boucle de message.

Événements

Disposed	Se produit lorsque le composant est supprimé par un appel à la méthode Dispose(). (Hérité de Component)
ErrorDataReceived	Se produit lorsqu’une application écrit dans son flux de StandardError redirigé.
Exited	Se produit lorsqu’un processus se ferme.
OutputDataReceived	Se produit chaque fois qu’une application écrit une ligne dans son flux de StandardOutput redirigé.

Voir aussi

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