Process Classe

Definição

public ref class Process : System::ComponentModel::Component

public class Process : System.ComponentModel.Component

type Process = class
    inherit Component

Public Class Process
Inherits Component

Herança

Object

MarshalByRefObject

Component

Process

Exemplos

O exemplo seguinte utiliza uma instância da Process classe para iniciar um processo.

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        public static void Main()
        {
            try
            {
                using (Process myProcess = new Process())
                {
                    myProcess.StartInfo.UseShellExecute = false;
                    // You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe";
                    myProcess.StartInfo.CreateNoWindow = true;
                    myProcess.Start();
                    // This code assumes the process you are starting will terminate itself.
                    // Given that it is started without a window so you cannot terminate it
                    // on the desktop, it must terminate itself or you can do it programmatically
                    // from this application using the Kill method.
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

open System.Diagnostics

try
    use myProcess = new Process()
    myProcess.StartInfo.UseShellExecute <- false
    // You can start any process, HelloWorld is a do-nothing example.
    myProcess.StartInfo.FileName <- @"C:\HelloWorld.exe"
    myProcess.StartInfo.CreateNoWindow <- true
    myProcess.Start() |> ignore
// This code assumes the process you are starting will terminate itself.
// Given that it is started without a window so you cannot terminate it
// on the desktop, it must terminate itself or you can do it programmatically
// from this application using the Kill method.
with e ->
    printfn $"{e.Message}"

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        Public Shared Sub Main()
            Try
                Using myProcess As New Process()

                    myProcess.StartInfo.UseShellExecute = False
                    ' You can start any process, HelloWorld is a do-nothing example.
                    myProcess.StartInfo.FileName = "C:\\HelloWorld.exe"
                    myProcess.StartInfo.CreateNoWindow = True
                    myProcess.Start()
                    ' This code assumes the process you are starting will terminate itself. 
                    ' Given that it is started without a window so you cannot terminate it 
                    ' on the desktop, it must terminate itself or you can do it programmatically
                    ' from this application using the Kill method.
                End Using
            Catch e As Exception
                Console.WriteLine((e.Message))
            End Try
        End Sub
    End Class
End Namespace

O exemplo seguinte utiliza a Process própria classe e um método estático Start para iniciar um processo.

using System;
using System.Diagnostics;
using System.ComponentModel;

namespace MyProcessSample
{
    class MyProcess
    {
        // Opens the Internet Explorer application.
        void OpenApplication(string myFavoritesPath)
        {
            // Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe");

            // Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath);
        }

        // Opens urls and .html documents using Internet Explorer.
        void OpenWithArguments()
        {
            // url's are not considered documents. They can only be opened
            // by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com");

            // Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.htm");
            Process.Start("IExplore.exe", "C:\\myPath\\myFile.asp");
        }

        // Uses the ProcessStartInfo class to start new processes,
        // both in a minimized mode.
        void OpenWithStartInfo()
        {
            ProcessStartInfo startInfo = new ProcessStartInfo("IExplore.exe");
            startInfo.WindowStyle = ProcessWindowStyle.Minimized;

            Process.Start(startInfo);

            startInfo.Arguments = "www.northwindtraders.com";

            Process.Start(startInfo);
        }

        static void Main()
        {
            // Get the path that stores favorite links.
            string myFavoritesPath =
                Environment.GetFolderPath(Environment.SpecialFolder.Favorites);

            MyProcess myProcess = new MyProcess();

            myProcess.OpenApplication(myFavoritesPath);
            myProcess.OpenWithArguments();
            myProcess.OpenWithStartInfo();
        }
    }
}

module processstartstatic

open System
open System.Diagnostics

// Opens the Internet Explorer application.
let openApplication (myFavoritesPath: string) =
    // Start Internet Explorer. Defaults to the home page.
    Process.Start "IExplore.exe" |> ignore

    // Display the contents of the favorites folder in the browser.
    Process.Start myFavoritesPath |> ignore

// Opens urls and .html documents using Internet Explorer.
let openWithArguments () =
    // url's are not considered documents. They can only be opened
    // by passing them as arguments.
    Process.Start("IExplore.exe", "www.northwindtraders.com") |> ignore

    // Start a Web page using a browser associated with .html and .asp files.
    Process.Start("IExplore.exe", @"C:\myPath\myFile.htm") |> ignore
    Process.Start("IExplore.exe", @"C:\myPath\myFile.asp") |> ignore

// Uses the ProcessStartInfo class to start new processes,
// both in a minimized mode.
let openWithStartInfo () =
    let startInfo = ProcessStartInfo "IExplore.exe"
    startInfo.WindowStyle <- ProcessWindowStyle.Minimized

    Process.Start startInfo |> ignore

    startInfo.Arguments <- "www.northwindtraders.com"

    Process.Start startInfo |> ignore

// Get the path that stores favorite links.
let myFavoritesPath = Environment.GetFolderPath Environment.SpecialFolder.Favorites

openApplication myFavoritesPath
openWithArguments ()
openWithStartInfo ()

Imports System.Diagnostics
Imports System.ComponentModel

Namespace MyProcessSample
    Class MyProcess
        ' Opens the Internet Explorer application.
        Public Sub OpenApplication(myFavoritesPath As String)
            ' Start Internet Explorer. Defaults to the home page.
            Process.Start("IExplore.exe")

            ' Display the contents of the favorites folder in the browser.
            Process.Start(myFavoritesPath)
        End Sub

        ' Opens URLs and .html documents using Internet Explorer.
        Sub OpenWithArguments()
            ' URLs are not considered documents. They can only be opened
            ' by passing them as arguments.
            Process.Start("IExplore.exe", "www.northwindtraders.com")

            ' Start a Web page using a browser associated with .html and .asp files.
            Process.Start("IExplore.exe", "C:\myPath\myFile.htm")
            Process.Start("IExplore.exe", "C:\myPath\myFile.asp")
        End Sub

        ' Uses the ProcessStartInfo class to start new processes,
        ' both in a minimized mode.
        Sub OpenWithStartInfo()
            Dim startInfo As New ProcessStartInfo("IExplore.exe")
            startInfo.WindowStyle = ProcessWindowStyle.Minimized

            Process.Start(startInfo)

            startInfo.Arguments = "www.northwindtraders.com"

            Process.Start(startInfo)
        End Sub

        Shared Sub Main()
            ' Get the path that stores favorite links.
            Dim myFavoritesPath As String = Environment.GetFolderPath(Environment.SpecialFolder.Favorites)

            Dim myProcess As New MyProcess()

            myProcess.OpenApplication(myFavoritesPath)
            myProcess.OpenWithArguments()
            myProcess.OpenWithStartInfo()
        End Sub
    End Class
End Namespace 'MyProcessSample

O seguinte exemplo de F# define uma runProc função que inicia um processo, captura toda a informação de saída e erro, e regista o número de milissegundos que o processo executou. A runProc função tem três parâmetros: o nome da aplicação a lançar, os argumentos a fornecer à aplicação e o diretório inicial.

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

O código para a função runProc foi escrito por ImaginaryDevelopment e está disponível sob a Licença Pública Microsoft.

Observações

Um Process componente fornece acesso a um processo que está a correr num computador. Um processo, em termos simples, é uma aplicação em execução. Um thread é a unidade básica à qual o sistema operativo aloca o tempo do processador. Um thread pode executar qualquer parte do código do processo, incluindo partes que estejam a ser executadas por outro thread.

O Process componente é uma ferramenta útil para iniciar, parar, controlar e monitorizar aplicações. Pode usar o Process componente para obter uma lista dos processos que estão a correr, ou pode iniciar um novo processo. Um componente é usado para aceder a Process processos do sistema. Depois de um Process componente ter sido inicializado, pode ser usado para obter informações sobre o processo em execução. Essa informação inclui o conjunto de threads, os módulos carregados (ficheiros.dll e .exe) e informações de desempenho, como a quantidade de memória que o processo está a utilizar.

Este tipo implementa a interface IDisposable. Quando terminar de usar o tipo, você deve eliminá-lo direta ou indiretamente. Para descartar o tipo diretamente, chame seu método Dispose em um bloco try/finally. Para descartá-lo indiretamente, use uma construção de linguagem como using (em C#) ou Using (em Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa IDisposable" na documentação da interface IDisposable.

O componente de processo obtém informação sobre um grupo de propriedades de uma só vez. Depois de o Process componente obter informação sobre um membro de qualquer grupo, irá armazenar em cache os valores das outras propriedades desse grupo e não obterá nova informação sobre os outros membros do grupo até que chame o Refresh método. Portanto, o valor de uma propriedade não é garantido que seja mais recente do que a última chamada ao Refresh método. A divisão dos grupos depende do sistema operativo.

Se tiver uma variável de caminho declarada no seu sistema usando aspas, deve qualificar totalmente esse caminho ao iniciar qualquer processo encontrado nesse local. Caso contrário, o sistema não encontrará o caminho. Por exemplo, se c:\mypath não estiver no seu caminho, e adicionar usando aspas: path = %path%;"c:\mypath", deve qualificar totalmente qualquer processo c:\mypath ao iniciá-lo.

Um processo do sistema é identificado de forma única no sistema pelo seu identificador de processo. Como muitos recursos do Windows, um processo também é identificado pelo seu handle, que pode não ser único no computador. Um handle é o termo genérico para identificador de um recurso. O sistema operativo mantém o handle do processo, que é acedido através da Handle propriedade do Process componente, mesmo quando o processo saiu. Assim, pode obter a informação administrativa do processo, como o ExitCode (normalmente zero para sucesso ou um código de erro diferente de zero) e o ExitTime. As alças são um recurso extremamente valioso, por isso vazar alças é mais virulento do que vazar memória.

No macOS, as seguintes propriedades retornam 0:

• PeakVirtualMemorySize64
• PrivateMemorySize64
• PeakWorkingSet64

.NET Notas Principais

No .NET Framework, a classe Process utiliza por defeito codificações Console, que são tipicamente codificações de páginas de código, para os fluxos de entrada, saída e erro. Por exemplo, código, em sistemas cuja cultura é o inglês (Estados Unidos), a página de código 437 é a codificação padrão para a classe Console. No entanto, o .NET Core pode disponibilizar apenas um subconjunto limitado dessas codificações. Se for esse o caso, usa Encoding.UTF8 como codificação padrão.

Se um Process objeto depende de codificações específicas de páginas de código, pode ainda assim disponibilizá-las fazendo o seguinte antes de chamar qualquer Process método:

1. Recupere o objeto EncodingProvider da propriedade CodePagesEncodingProvider.Instance.

2. Passe o EncodingProvider objeto para o Encoding.RegisterProvider método para disponibilizar as codificações adicionais suportadas pelo provedor de codificação.

A Process classe usará automaticamente a codificação padrão do sistema em vez do UTF8, desde que tenha registado o fornecedor de codificação antes de chamar qualquer Process método.

Ver também

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