Process Classe

Définition

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

Object

MarshalByRefObject

Component

Process

Héritage

Object

Process

Implémente

IDisposable

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 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 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 documentation de l’interface IDisposable .

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é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 .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. Récupérez l’objet EncodingProvider à partir de la CodePagesEncodingProvider.Instance propriété .

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

Propriétés

Méthodes

Événements

S’applique à

Voir aussi

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