Process Process Process Process Class

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.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
Héritage

Exemples

L’exemple suivant utilise une instance de la Process classe démarre un processus.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()
        {
            Process myProcess = new 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);
            }
        }
    }
}
Imports System
Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        Public Shared Sub Main()
            Dim myProcess As New 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 e As Exception
                Console.WriteLine((e.Message))
            End Try
        End Sub 'Main
    End Class
End Namespace

L’exemple suivant utilise le Process lui-même et statique de la classe Start méthode pour démarrer un processus.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 'OpenApplication

        ' 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 'OpenWithArguments

        ' 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 'OpenWithStartInfo

        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 'Main
    End Class 'MyProcess
End Namespace 'MyProcessSample

Ce qui suit F# exemple définit un runProc fonction qui démarre un processus, capture toutes les informations de sortie et d’erreur et enregistre le nombre de millisecondes pendant lesquelles l’exécution du processus.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. Le runProc fonction a trois paramètres : le nom de l’application au lancement, les arguments à fournir à l’application et le répertoire de démarrage.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

Le code pour le runProc fonction a été écrit par ImaginaryDevelopment et est disponible sous le Microsoft Public License.The code for the runProc function was written by ImaginaryDevelopment and is available under the Microsoft Public License.

Remarques

Un Process composant fournit l’accès à un processus qui s’exécute sur un ordinateur.A Process component provides access to a process that is running on a computer. Un processus, d’autres termes, est une application en cours d’exécution.A process, in the simplest terms, is a running app. Un thread est l’unité de base à laquelle le système d’exploitation alloue du temps processeur.A thread is the basic unit to which the operating system allocates processor time. Un thread peut exécuter n’importe quelle partie du code du processus, y compris des parties en cours d’exécution par un autre thread.A thread can execute any part of the code of the process, including parts currently being executed by another thread.

Le Process composant est un outil utile pour démarrer, arrêter, contrôler et surveiller les applications.The Process component is a useful tool for starting, stopping, controlling, and monitoring apps. Vous pouvez utiliser le Process composant, pour obtenir une liste des processus en cours d’exécution, ou vous pouvez démarrer un nouveau processus.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 composant est utilisé pour accéder aux processus système.A Process component is used to access system processes. Après un Process composant a été initialisé, il peut être utilisé pour obtenir des informations sur le processus en cours d’exécution.After a Process component has been initialized, it can be used to obtain information about the running process. Ces informations incluent l’ensemble des threads, les modules chargés (fichiers .dll et .exe), et à l’aide d’informations sur les performances telles que la quantité de mémoire du processus.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.

Ce type implémente le IDisposable interface.This type implements the IDisposable interface. Lorsque vous avez fini d’utiliser le type, vous devez supprimer il directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer le type directement, appelez sa Dispose méthode dans un try / finally bloc.To dispose of the type directly, call its Dispose method in a try/finally block. Pour supprimer indirectement, utiliser une construction de langage tel que using (en c#) ou Using (en Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « À l’aide un objet qui implémente IDisposable » dans le IDisposable rubrique de l’interface.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Note

processus 32 bits ne peut pas accéder aux modules d’un processus 64 bits.32-bit processes cannot access the modules of a 64-bit process. Si vous essayez d’obtenir des informations sur un processus 64 bits à partir d’un processus 32 bits, vous obtiendrez un Win32Exception exception.If you try to get information about a 64-bit process from a 32-bit process, you will get a Win32Exception exception. Un processus 64 bits, peuvent quant à eux, accéder aux modules d’un processus 32 bits.A 64-bit process, on the other hand, can access the modules of a 32-bit process.

Le composant de processus obtient des informations sur un groupe de propriétés à la fois.The process component obtains information about a group of properties all at once. Après le Process composant a obtenu des informations sur un membre d’un groupe, il sera mettre en cache les valeurs pour les autres propriétés de ce groupe et d’obtenir des nouvelles informations sur les autres membres du groupe jusqu'à ce que vous appeliez la Refresh (méthode).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. Par conséquent, une valeur de propriété n’est pas garantie pour être plus récente que le dernier appel à la Refresh (méthode).Therefore, a property value is not guaranteed to be any newer than the last call to the Refresh method. Les répartitions des groupes dépendent du système d’exploitation.The group breakdowns are operating-system dependent.

Si vous avez une variable de chemin d’accès déclarée dans votre système à l’aide de guillemets, vous devez qualifier entièrement ce chemin d’accès lors du démarrage de n’importe quel processus trouvé dans cet emplacement.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. Sinon, le système ne trouvera pas le chemin d’accès.Otherwise, the system will not find the path. Par exemple, si c:\mypath n’est pas dans votre chemin d’accès, et l’ajouter à l’aide de guillemets : path = %path%;"c:\mypath", vous devez qualifier complètement tout processus dans c:\mypath lorsque vous le démarrez.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 processus système est identifié de manière unique sur le système par son identificateur de processus.A system process is uniquely identified on the system by its process identifier. Comme de nombreuses ressources de Windows, un processus est également identifié par son handle, qui peut ne pas être unique sur l’ordinateur.Like many Windows resources, a process is also identified by its handle, which might not be unique on the computer. Un handle est le terme générique pour un identificateur d’une ressource.A handle is the generic term for an identifier of a resource. Le système d’exploitation conserve le handle du processus, qui est accessible via la Handle propriété de la Process composant, même lorsque le processus est terminé.The operating system persists the process handle, which is accessed through the Handle property of the Process component, even when the process has exited. Par conséquent, vous pouvez obtenir des informations le processus d’administration, telles que la ExitCode (généralement zéro en cas de réussite ou un code d’erreur différent de zéro) et le ExitTime.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. Handles constituent une ressource extrêmement précieuse, par conséquent, les pertes de handles sont plus virulents à une fuite de mémoire.Handles are an extremely valuable resource, so leaking handles is more virulent than leaking memory.

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.This class contains a link demand and an inheritance demand at the class level that applies to all members. Un SecurityException est levée lorsque l’appelant immédiat ou la classe dérivée n’a pas d’autorisations de confiance totale.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Pour plus d’informations sur les demandes de sécurité, consultez demandes de liaison.For details about security demands, see Link Demands.

.NET Core.NET Core Notes de publicationNotes

Dans le .NET Framework, le Process classe par défaut, utilise Console encodages, qui sont en général des codages de page, pour les flux d’entrée, sortie et d’erreur de code.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. Par exemple de code, sur les systèmes dont la culture est anglais (États-Unis), page de codes 437 est l’encodage par défaut pour le Console classe.For example code, on systems whose culture is English (United States), code page 437 is the default encoding for the Console class. Toutefois, .NET Core.NET Core peut effectuer uniquement un sous-ensemble limité de ces encodages disponibles.However, .NET Core.NET Core may make only a limited subset of these encodings available. Si c’est le cas, il utilise Encoding.UTF8 comme l’encodage par défaut.If this is the case, it uses Encoding.UTF8 as the default encoding.

Si un Process objet dépend des codages de page de codes spécifique, vous pouvez toujours les rendre disponibles de la manière suivante avant vous appeler les Process méthodes :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. Ajoutez une référence à l’assembly System.Text.Encoding.CodePages.dll à votre projet.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Récupérer le EncodingProvider de l’objet à partir de la CodePagesEncodingProvider.Instance propriété.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Passer le EncodingProvider de l’objet à la Encoding.RegisterProvider méthode permettant d’apporter les autres encodages pris en charge par le fournisseur d’encodage disponible.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

Le Process classe puis utilisent automatiquement l’encodage du système par défaut au lieu d’UTF-8, sous réserve que vous avez enregistré le fournisseur d’encodage avant d’appeler une Process méthodes.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.

Constructeurs

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

Initialise une nouvelle instance de la classe Process.Initializes a new instance of the Process class.

Propriétés

BasePriority BasePriority BasePriority BasePriority

Obtient la priorité de base du processus associé.Gets the base priority of the associated process.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Obtient une valeur qui indique si le composant peut déclencher un événement.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
Container Container Container Container

Obtient le IContainer qui contient Component.Gets the IContainer that contains the Component.

(Inherited from Component)
DesignMode DesignMode DesignMode DesignMode

Obtient une valeur qui indique si Component est actuellement en mode design.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents

Obtient ou définit une valeur indiquant si l'événement Exited est déclenché quand le processus ne s'exécute plus.Gets or sets whether the Exited event should be raised when the process terminates.

Events Events Events Events

Obtient la liste des gestionnaires d'événements attachés à ce Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
ExitCode ExitCode ExitCode ExitCode

Obtient la valeur spécifiée par le processus associé au moment où il s'est terminé.Gets the value that the associated process specified when it terminated.

ExitTime ExitTime ExitTime ExitTime

Obtient l'heure à laquelle le processus associé s'est terminé.Gets the time that the associated process exited.

Handle Handle Handle Handle

Obtient le handle natif du processus associé.Gets the native handle of the associated process.

HandleCount HandleCount HandleCount HandleCount

Obtient le nombre de handles ouverts par le processus.Gets the number of handles opened by the process.

HasExited HasExited HasExited HasExited

Obtient une valeur indiquant si le processus associé s'est terminé.Gets a value indicating whether the associated process has been terminated.

Id Id Id Id

Obtient l'identificateur unique du processus associé.Gets the unique identifier for the associated process.

MachineName MachineName MachineName MachineName

Obtient le nom de l'ordinateur sur lequel s'exécute le processus associé.Gets the name of the computer the associated process is running on.

MainModule MainModule MainModule MainModule

Obtient le module principal pour le processus associé.Gets the main module for the associated process.

MainWindowHandle MainWindowHandle MainWindowHandle MainWindowHandle

Obtient le handle de la fenêtre principale du processus associé.Gets the window handle of the main window of the associated process.

MainWindowTitle MainWindowTitle MainWindowTitle MainWindowTitle

Obtient la légende de la fenêtre principale du processus.Gets the caption of the main window of the process.

MaxWorkingSet MaxWorkingSet MaxWorkingSet MaxWorkingSet

Obtient ou définit la taille maximale autorisée du jeu de travail, en octets, pour le processus associé.Gets or sets the maximum allowable working set size, in bytes, for the associated process.

MinWorkingSet MinWorkingSet MinWorkingSet MinWorkingSet

Obtient ou définit la taille minimale autorisée du jeu de travail, en octets, pour le processus associé.Gets or sets the minimum allowable working set size, in bytes, for the associated process.

Modules Modules Modules Modules

Obtient les modules qui ont été chargés par le processus associé.Gets the modules that have been loaded by the associated process.

NonpagedSystemMemorySize NonpagedSystemMemorySize NonpagedSystemMemorySize NonpagedSystemMemorySize

Obtient la quantité de mémoire système non paginée, en octets, allouée pour le processus associé.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

NonpagedSystemMemorySize64 NonpagedSystemMemorySize64 NonpagedSystemMemorySize64 NonpagedSystemMemorySize64

Obtient la quantité de mémoire système non paginée, en octets, allouée pour le processus associé.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

PagedMemorySize PagedMemorySize PagedMemorySize PagedMemorySize

Obtient la quantité de mémoire paginée, en octets, allouée au processus associé.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedMemorySize64 PagedMemorySize64 PagedMemorySize64 PagedMemorySize64

Obtient la quantité de mémoire paginée, en octets, allouée au processus associé.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedSystemMemorySize PagedSystemMemorySize PagedSystemMemorySize PagedSystemMemorySize

Obtient la quantité de mémoire système paginable, en octets, allouée pour le processus associé.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PagedSystemMemorySize64 PagedSystemMemorySize64 PagedSystemMemorySize64 PagedSystemMemorySize64

Obtient la quantité de mémoire système paginable, en octets, allouée pour le processus associé.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PeakPagedMemorySize PeakPagedMemorySize PeakPagedMemorySize PeakPagedMemorySize

Obtient la quantité maximale de mémoire dans le fichier d’échange de la mémoire virtuelle, en octets, utilisé par le processus associé.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakPagedMemorySize64 PeakPagedMemorySize64 PeakPagedMemorySize64 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é.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakVirtualMemorySize PeakVirtualMemorySize PeakVirtualMemorySize PeakVirtualMemorySize

Obtient la quantité maximale de la mémoire virtuelle, en octets, utilisée par le processus associé.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakVirtualMemorySize64 PeakVirtualMemorySize64 PeakVirtualMemorySize64 PeakVirtualMemorySize64

Obtient la quantité maximale de la mémoire virtuelle, en octets, utilisée par le processus associé.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakWorkingSet PeakWorkingSet PeakWorkingSet PeakWorkingSet

Obtient la taille maximale du jeu de travail du processus associé, en octets.Gets the peak working set size for the associated process, in bytes.

PeakWorkingSet64 PeakWorkingSet64 PeakWorkingSet64 PeakWorkingSet64

Obtient la quantité maximale de mémoire physique, en octets, utilisée par le processus associé.Gets the maximum amount of physical memory, in bytes, used by the associated process.

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

Obtient ou définit la catégorie de priorité générale pour le processus associé.Gets or sets the overall priority category for the associated process.

PrivateMemorySize PrivateMemorySize PrivateMemorySize PrivateMemorySize

Obtient la quantité de mémoire privée, en octets, allouée pour le processus associé.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivateMemorySize64 PrivateMemorySize64 PrivateMemorySize64 PrivateMemorySize64

Obtient la quantité de mémoire privée, en octets, allouée pour le processus associé.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivilegedProcessorTime PrivilegedProcessorTime PrivilegedProcessorTime PrivilegedProcessorTime

Obtient le temps processeur privilégié pour ce processus.Gets the privileged processor time for this process.

ProcessName ProcessName ProcessName ProcessName

Obtient le nom du processus.Gets the name of the process.

ProcessorAffinity ProcessorAffinity ProcessorAffinity ProcessorAffinity

Obtient ou définit les processeurs sur lesquels l'exécution des threads de ce processus peut être planifiée.Gets or sets the processors on which the threads in this process can be scheduled to run.

Responding Responding Responding Responding

Obtient une valeur indiquant si l'interface utilisateur du processus répond.Gets a value indicating whether the user interface of the process is responding.

SafeHandle SafeHandle SafeHandle SafeHandle

Obtient le handle natif de ce processus.Gets the native handle to this process.

SessionId SessionId SessionId SessionId

Obtient l'identificateur de session Terminal Server du processus associé.Gets the Terminal Services session identifier for the associated process.

Site Site Site Site

Obtient ou définit le ISite de Component.Gets or sets the ISite of the Component.

(Inherited from Component)
StandardError StandardError StandardError StandardError

Obtient un flux utilisé pour lire la sortie d'erreur de l'application.Gets a stream used to read the error output of the application.

StandardInput StandardInput StandardInput StandardInput

Obtient un flux utilisé pour écrire l'entrée de l'application.Gets a stream used to write the input of the application.

StandardOutput StandardOutput StandardOutput StandardOutput

Obtient un flux utilisé pour lire la sortie textuelle de l'application.Gets a stream used to read the textual output of the application.

StartInfo StartInfo StartInfo StartInfo

Obtient ou définit les propriétés à passer à la méthode Start() de Process.Gets or sets the properties to pass to the Start() method of the Process.

StartTime StartTime StartTime StartTime

Obtient l'heure à laquelle le processus associé a démarré.Gets the time that the associated process was started.

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

Obtient le jeu des threads en cours d'exécution dans le processus associé.Gets the set of threads that are running in the associated process.

TotalProcessorTime TotalProcessorTime TotalProcessorTime TotalProcessorTime

Obtient le temps processeur total pour ce processus.Gets the total processor time for this process.

UserProcessorTime UserProcessorTime UserProcessorTime UserProcessorTime

Obtient le temps processeur utilisateur pour ce processus.Gets the user processor time for this process.

VirtualMemorySize VirtualMemorySize VirtualMemorySize VirtualMemorySize

Obtient la taille (en octets) de la mémoire virtuelle du processus.Gets the size of the process's virtual memory, in bytes.

VirtualMemorySize64 VirtualMemorySize64 VirtualMemorySize64 VirtualMemorySize64

Obtient la quantité de mémoire virtuelle, en octets, allouée au processus associé.Gets the amount of the virtual memory, in bytes, allocated for the associated process.

WorkingSet WorkingSet WorkingSet WorkingSet

Obtient l’utilisation de mémoire physique du processus associé, en octets.Gets the associated process's physical memory usage, in bytes.

WorkingSet64 WorkingSet64 WorkingSet64 WorkingSet64

Obtient la quantité de mémoire physique, en octets, allouée au processus associé.Gets the amount of physical memory, in bytes, allocated for the associated process.

Méthodes

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

Commence des opérations de lecture asynchrones sur le flux de données StandardError redirigé de l'application.Begins asynchronous read operations on the redirected StandardError stream of the application.

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

Commence des opérations de lecture asynchrones sur le flux de données StandardOutput redirigé de l'application.Begins asynchronous read operations on the redirected StandardOutput stream of the application.

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

Annule l'opération de lecture asynchrone sur le flux StandardError redirigé d'une application.Cancels the asynchronous read operation on the redirected StandardError stream of an application.

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

Annule l'opération de lecture asynchrone sur le flux StandardOutput redirigé d'une application.Cancels the asynchronous read operation on the redirected StandardOutput stream of an application.

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

Libère toutes les ressources associées à ce composant.Frees all the resources that are associated with this component.

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

Ferme un processus possédant une interface utilisateur en envoyant un message de fermeture à sa fenêtre 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)

Crée un objet contenant toutes les informations appropriées requises pour générer un proxy permettant de communiquer avec un objet distant.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)

Libère toutes les ressources utilisées par ce processus.Release all resources used by this process.

EnterDebugMode() EnterDebugMode() EnterDebugMode() 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.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)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

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

Obtient un nouveau composant Process et l'associe au processus actuellement actif.Gets a new Process component and associates it with the currently active process.

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

Fait office de fonction de hachage par défaut.Serves as the default hash function.

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

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

Retourne un nouveau composant Process, en fonction de l'identificateur d'un processus sur l'ordinateur local.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)

Retourne un nouveau composant Process, en fonction d'un identificateur de processus et du nom d'un ordinateur du réseau.Returns a new Process component, given a process identifier and the name of a computer on the network.

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

Crée un composant Process pour chaque ressource de processus sur l'ordinateur local.Creates a new Process component for each process resource on the local computer.

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

Crée un composant Process pour chaque ressource de processus sur l'ordinateur spécifié.Creates a new Process component for each process resource on the specified computer.

GetProcessesByName(String) GetProcessesByName(String) GetProcessesByName(String) 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é.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)

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é.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)

Retourne un objet qui représente un service fourni par Component ou par son Container.Returns an object that represents a service provided by the Component or by its Container.

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

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

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

Obtient un objet de service de durée de vie pour contrôler la stratégie de durée de vie de cette instance.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Arrête immédiatement le processus associé.Immediately stops the associated process.

LeaveDebugMode() LeaveDebugMode() LeaveDebugMode() 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.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()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

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

Crée une copie superficielle de l'objet MarshalByRefObject actuel.Creates a shallow copy of the current MarshalByRefObject object.

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

Déclenche l'événement Exited.Raises the Exited event.

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

Ignore toute information concernant le processus associé qui a été mis en cache dans le composant du processus.Discards any information about the associated process that has been cached inside the process component.

Start() Start() Start() 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.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)

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

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

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

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

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.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()

Met en forme le nom du processus en tant que chaîne, combinée au type de composant parent, le cas échéant.Formats the process's name as a string, combined with the parent component type, if applicable.

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

Indique au composant Process d'attendre indéfiniment que le processus associé s'arrête.Instructs the Process component to wait indefinitely for the associated process to exit.

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

Indique au composant Process d'attendre le nombre de millisecondes spécifié que le processus associé s'arrête.Instructs the Process component to wait the specified number of milliseconds for the associated process to exit.

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

Fait en sorte que le composant Process attende indéfiniment que le processus associé passe à un état inactif.Causes the Process component to wait indefinitely for the associated process to enter an idle state. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'une boucle de message.This overload applies only to processes with a user interface and, therefore, a message loop.

WaitForInputIdle(Int32) WaitForInputIdle(Int32) WaitForInputIdle(Int32) 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.Causes the Process component to wait the specified number of milliseconds for the associated process to enter an idle state. Cette surcharge s'applique uniquement aux processus dotés d'une interface utilisateur et, donc, d'une boucle de message.This overload applies only to processes with a user interface and, therefore, a message loop.

Événements

Disposed Disposed Disposed Disposed

Se produit lorsque le composant est supprimé par un appel à la méthode Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
ErrorDataReceived ErrorDataReceived ErrorDataReceived ErrorDataReceived

Se produit quand une application écrit dans son flux StandardError redirigé.Occurs when an application writes to its redirected StandardError stream.

Exited Exited Exited Exited

Se produit quand un processus se termine.Occurs when a process exits.

OutputDataReceived OutputDataReceived OutputDataReceived OutputDataReceived

Se produit quand une application écrit dans son flux StandardOutput redirigé.Occurs each time an application writes a line to its redirected StandardOutput stream.

Sécurité

LinkDemand
pour la confiance totale pour l’appelant immédiat.for full trust for the immediate caller. Cette classe ne peut pas être utilisée par du code partiellement fiable.This class cannot be used by partially trusted code.

InheritanceDemand
pour la confiance totale pour les héritiers.for full trust for inheritors. Cette classe ne peut pas être héritée par du code partiellement fiable.This class cannot be inherited by partially trusted code.

S’applique à

Voir aussi