Process Classe

Définition

Fournit l'accès à des processus locaux ainsi que distants, et vous permet de démarrer et d'arrêter des processus système locaux.

public ref class Process : System::ComponentModel::Component, IDisposable
public ref class Process : IDisposable
public ref class Process : System::ComponentModel::Component
public class Process : System.ComponentModel.Component, IDisposable
public class Process : IDisposable
public class Process : System.ComponentModel.Component
type Process = class
    inherit Component
    interface IDisposable
type Process = class
    interface IDisposable
type Process = class
    inherit Component
Public Class Process
Inherits Component
Implements IDisposable
Public Class Process
Implements IDisposable
Public Class Process
Inherits Component
Héritage
Héritage
Process
Implémente

Exemples

L’exemple suivant utilise une instance de la Process classe 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);
            }
        }
    }
}
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 Process classe elle-même et une méthode statique Start 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();
        }
    }
}
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 runProc fonction 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 runProc fonction 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 runProc fonction a été écrit par ImaginaryDevelopment et est disponible sous la licence publique Microsoft.

Remarques

Un Process composant fournit l’accès à un processus qui s’exécute sur un ordinateur. Un processus, dans les 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 le 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 Process composant est un outil utile pour démarrer, arrêter, contrôler et superviser des applications. Vous pouvez utiliser le Process composant pour obtenir la liste des processus en cours d’exécution, ou vous pouvez démarrer un nouveau processus. Un Process composant est utilisé pour accéder aux processus système. Une fois qu’un Process composant 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 (fichiers .dll et .exe) 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 directement le type Dispose, appelez sa méthode dans un bloc try/finally. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.

Notes

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 Win32Exception exception. En revanche, un processus 64 bits 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 Process composant 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 Refresh méthode. Par conséquent, il n’est pas garanti qu’une valeur de propriété soit plus récente que le dernier appel à la Refresh méthode. Les répartitions de groupe dépendent du système d’exploitation.

Si vous avez une variable de chemin d’accès déclarée dans votre système à l’aide de guillemets, vous devez entièrement qualifier ce chemin lors du démarrage d’un processus trouvé à cet emplacement. Sinon, le système ne trouvera 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 entre guillemets : path = %path%;"c:\mypath", vous devez entièrement qualifier n’importe quel processus dans c:\mypath lors du démarrage.

Un processus système est identifié de manière 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, qui est accessible via la Handle propriété du Process composant, même lorsque le processus est arrêté. Ainsi, vous pouvez obtenir les informations administratives du processus, telles que (ExitCodegénéralement zéro pour la réussite ou un code d’erreur différent de zéro) et .ExitTime Les handles étant une ressource extrêmement précieuse, les handles qui fuient sont plus virulents que les fuites de mémoire.

Notes

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

Notes .NET Core

Dans .NET Framework, la Process classe utilise Console par défaut des encodages, qui sont généralement des encodages de page de code, pour les flux d’entrée, de sortie et d’erreur. Par exemple, sur les systèmes dont la culture est l’anglais (États-Unis), la page de code 437 est l’encodage par défaut de la Console classe. 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 Process objet dépend d’encodages de pages de code spécifiques, vous pouvez toujours les rendre disponibles en procédant comme suit avant d’appeler des Process méthodes :

  1. Ajoutez une référence à l’assembly System.Text.Encoding.CodePages.dll à votre projet.

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

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

La Process classe 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 Process méthodes.

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 qui indique si le composant peut déclencher un événement.

(Hérité de Component)
Container

Obtient le IContainer qui contient la Component.

(Hérité de Component)
DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.

(Hérité de Component)
EnableRaisingEvents

Obtient ou définit une valeur indiquant si l'événement Exited est déclenché quand le processus ne s'exécute plus.

Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.

(Hérité de Component)
ExitCode

Obtient la valeur spécifiée par le processus associé au moment où il s'est terminé.

ExitTime

Obtient l'heure à laquelle le processus associé s'est terminé.

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é s'est terminé.

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 pour le processus associé.

MainWindowHandle

Obtient le handle 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, en octets, pour le processus associé.

Modules

Obtient les modules qui ont été chargés par le processus associé.

NonpagedSystemMemorySize
Obsolète.
Obsolète.
Obsolète.
Obsolète.

Obtient la quantité de mémoire système non paginée, en octets, allouée pour le processus associé.

NonpagedSystemMemorySize64

Obtient la quantité de mémoire système non paginée, en octets, allouée pour le processus associé.

PagedMemorySize
Obsolète.
Obsolète.
Obsolète.
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.
Obsolète.
Obsolète.
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.
Obsolète.
Obsolète.
Obsolète.

Obtient la quantité maximale de mémoire dans le fichier d’échange de la mémoire virtuelle, en octets, utilisé par le processus associé.

PeakPagedMemorySize64

Obtient la quantité maximale de mémoire dans le fichier d’échange de la mémoire virtuelle, en octets, utilisé par le processus associé.

PeakVirtualMemorySize
Obsolète.
Obsolète.
Obsolète.
Obsolète.

Obtient la quantité maximale de la mémoire virtuelle, en octets, utilisée par le processus associé.

PeakVirtualMemorySize64

Obtient la quantité maximale de la mémoire virtuelle, en octets, utilisée par le processus associé.

PeakWorkingSet
Obsolète.
Obsolète.
Obsolète.
Obsolète.

Obtient la taille maximale du jeu de travail du 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é du processus associée doit être temporairement renforcée par le système d'exploitation quand la fenêtre principale a le focus.

PriorityClass

Obtient ou définit la catégorie de priorité générale pour le processus associé.

PrivateMemorySize
Obsolète.
Obsolète.
Obsolète.
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 l'exécution des threads de ce processus peut être planifiée.

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 Server du processus associé.

Site

Obtient ou définit le ISite de 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() de Process.

StartTime

Obtient l'heure à laquelle le processus associé a démarré.

SynchronizingObject

Obtient ou définit l'objet utilisé pour marshaler des appels du gestionnaire d'événements émis à la suite d'un événement de sortie de processus.

Threads

Obtient le jeu des 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.
Obsolète.
Obsolète.
Obsolète.

Obtient la taille (en octets) de la mémoire virtuelle du processus.

VirtualMemorySize64

Obtient la quantité de mémoire virtuelle, en octets, allouée au processus associé.

WorkingSet
Obsolète.
Obsolète.
Obsolète.
Obsolète.

Obtient l’utilisation de mémoire physique du processus associé, en octets.

WorkingSet64

Obtient la quantité de mémoire physique, en octets, allouée au processus associé.

Méthodes

BeginErrorReadLine()

Commence des opérations de lecture asynchrones sur le flux de données StandardError redirigé de l'application.

BeginOutputReadLine()

Commence des opérations de lecture asynchrones sur le flux de données StandardOutput redirigé de l'application.

CancelErrorRead()

Annule l'opération de lecture asynchrone sur le flux StandardError redirigé d'une application.

CancelOutputRead()

Annule l'opération de lecture asynchrone sur le flux StandardOutput redirigé d'une application.

Close()

Libère toutes les ressources associées à ce composant.

CloseMainWindow()

Ferme un processus possédant une interface utilisateur en envoyant un message de fermeture à sa fenêtre principale.

CreateObjRef(Type)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.

(Hérité de MarshalByRefObject)
Dispose()

Exécute les tâches définies par l'application associées à la libération ou à la redéfinition des ressources non managées.

Dispose()

Libère toutes les ressources utilisées par Component.

(Hérité de Component)
Dispose(Boolean)

Libère toutes les ressources utilisées par ce processus.

EnterDebugMode()

Met un composant Process en état d'interagir avec des 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 actuellement actif.

GetHashCode()

Fait office 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 en cours qui contrôle la stratégie de durée de vie de cette instance.

(Hérité de MarshalByRefObject)
GetProcessById(Int32)

Retourne un nouveau composant Process, en fonction de l'identificateur d'un processus sur l'ordinateur local.

GetProcessById(Int32, String)

Retourne un nouveau composant Process, en fonction d'un identificateur de processus et du nom d'un ordinateur du réseau.

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)

Crée un tableau de nouveaux composants Process et les associe à toutes les ressources de processus de l'ordinateur local qui partagent le nom de processus spécifié.

GetProcessesByName(String, String)

Crée un tableau de nouveaux composants Process et les associe à toutes les ressources de processus sur l'ordinateur distant qui partagent le nom de processus spécifié.

GetService(Type)

Retourne un objet qui représente un service fourni par Component ou par son Container.

(Hérité de Component)
GetType()

Obtient le 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()

Met un composant Process hors de l'état qui lui permet d'interagir avec des processus du système d'exploitation qui s'exécutent en mode spécial.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(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 toute information concernant le processus associé qui a été mis en cache dans le composant du processus.

Start()

Démarre (ou réutilise) la ressource de processus qui est 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 qui est 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 l'associe à 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 l'associe à 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)

Démarre une ressource de processus en spécifiant le nom d’une application et un jeu d’arguments de ligne de commande et l’associe à la ressource avec un nouveau composant Process.

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 jeu 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.

ToString()

Met en forme le nom du processus en tant que chaîne, combinée au type de composant parent, le cas échéant.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)
WaitForExit()

Indique au composant Process d'attendre indéfiniment que le processus associé s'arrête.

WaitForExit(Int32)

Indique au composant Process d'attendre le nombre de millisecondes spécifié que le processus associé s'arrête.

WaitForExit(TimeSpan)

Indique au composant Process d’attendre la durée spécifiée pour que le processus associé se termine.

WaitForExitAsync(CancellationToken)

Demande au composant de processus d’attendre que le processus associé quitte ou que le cancellationToken soit annulé.

WaitForInputIdle()

Fait en sorte que le composant Process attende indéfiniment que le processus associé passe à un état inactif. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'une boucle de message.

WaitForInputIdle(Int32)

Fait en sorte que le composant Process attende pendant le nombre spécifié de millisecondes que le processus associé passe à un état inactif. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'une boucle de message.

WaitForInputIdle(TimeSpan)

Provoque le Process composant à attendre le spécifié timeout pour que le processus associé entre dans un état inactif. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'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 quand une application écrit dans son flux StandardError redirigé.

Exited

Se produit quand un processus se termine.

OutputDataReceived

Se produit quand une application écrit dans son flux StandardOutput redirigé.

S’applique à

Voir aussi