Process Process Process Process Class

Definição

Fornece acesso a processos locais e remotos e permite que você inicie e pare os processos do sistema local.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
Herança

Exemplos

O exemplo a seguir usa uma instância da Process classe para iniciar um processo.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()
        {
            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 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.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 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.
                End Using
            Catch e As Exception
                Console.WriteLine((e.Message))
            End Try
        End Sub
    End Class
End Namespace

O exemplo a seguir usa Process a própria classe e um Start método estático para iniciar um processo.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

        ' 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

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

O exemplo F# a seguir define runProc uma função que inicia um processo, captura todas as informações de saída e erro e registra o número de milissegundos em que o processo foi executado.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. A runProc função tem três parâmetros: o nome do aplicativo a ser iniciado, os argumentos a serem fornecidos ao aplicativo e o diretório inicial.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

O código para a runProc função foi escrito por ImaginaryDevelopment e está disponível na licença pública da Microsoft.The code for the runProc function was written by ImaginaryDevelopment and is available under the Microsoft Public License.

Comentários

Um Process componente fornece acesso a um processo que está sendo executado em um computador.A Process component provides access to a process that is running on a computer. Um processo, nos termos mais simples, é um aplicativo em execução.A process, in the simplest terms, is a running app. Um thread é a unidade básica para a qual o sistema operacional aloca o tempo do processador.A thread is the basic unit to which the operating system allocates processor time. Um thread pode executar qualquer parte do código do processo, incluindo partes que estão sendo executadas atualmente por outro thread.A thread can execute any part of the code of the process, including parts currently being executed by another thread.

O Process componente é uma ferramenta útil para iniciar, interromper, controlar e monitorar aplicativos.The Process component is a useful tool for starting, stopping, controlling, and monitoring apps. Você pode usar o Process componente para obter uma lista dos processos que estão em execução ou pode iniciar um novo processo.You can use the Process component, to obtain a list of the processes that are running, or you can start a new process. Um Process componente é usado para acessar processos do sistema.A Process component is used to access system processes. Depois que Process um componente é inicializado, ele pode ser usado para obter informações sobre o processo em execução.After a Process component has been initialized, it can be used to obtain information about the running process. Essas informações incluem o conjunto de threads, os módulos carregados (arquivos. dll e. exe) e informações de desempenho, como a quantidade de memória que o processo está usando.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.

Esse tipo implementa a interface IDisposable.This type implements the IDisposable interface. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/finally.To dispose of the type directly, call its Dispose method in a try/finally block. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Observação

os processos de 32 bits não podem acessar os módulos de um processo de 64 bits.32-bit processes cannot access the modules of a 64-bit process. Se você tentar obter informações sobre um processo de 64 bits de um processo de 32 bits, receberá uma Win32Exception exceção.If you try to get information about a 64-bit process from a 32-bit process, you will get a Win32Exception exception. Um processo de 64 bits, por outro lado, pode acessar os módulos de um processo de 32 bits.A 64-bit process, on the other hand, can access the modules of a 32-bit process.

O componente processo Obtém informações sobre um grupo de propriedades de uma só vez.The process component obtains information about a group of properties all at once. Depois que Process o componente obtiver informações sobre um membro de qualquer grupo, ele armazenará em cache os valores para as outras propriedades nesse grupo e não obterá novas informações sobre os outros membros do grupo até que Refresh você chame o método.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. Portanto, não há garantia de que um valor de propriedade seja mais novo do que a última Refresh chamada para o método.Therefore, a property value is not guaranteed to be any newer than the last call to the Refresh method. As divisões de grupo são dependentes do sistema operacional.The group breakdowns are operating-system dependent.

Se você tiver uma variável de caminho declarada no seu sistema usando aspas, deverá qualificar totalmente esse caminho ao iniciar qualquer processo encontrado nesse local.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. Caso contrário, o sistema não encontrará o caminho.Otherwise, the system will not find the path. Por exemplo, se c:\mypath não estiver em seu caminho e você adicioná-lo usando aspas: path = %path%;"c:\mypath", você deverá qualificar totalmente qualquer processo no c:\mypath ao iniciá-lo.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.

Um processo do sistema é identificado exclusivamente no sistema pelo identificador do processo.A system process is uniquely identified on the system by its process identifier. Como muitos recursos do Windows, um processo também é identificado por seu identificador, que pode não ser exclusivo no computador.Like many Windows resources, a process is also identified by its handle, which might not be unique on the computer. Um identificador é o termo genérico para um identificador de um recurso.A handle is the generic term for an identifier of a resource. O sistema operacional persiste o identificador de processo, que é acessado por meio Process da Handle Propriedade do componente, mesmo quando o processo foi encerrado.The operating system persists the process handle, which is accessed through the Handle property of the Process component, even when the process has exited. Portanto, você pode obter as informações administrativas do processo, como ExitCode (geralmente zero para o êxito ou um código de erro diferente de zero) e o. ExitTimeThus, 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. Os identificadores são um recurso extremamente valioso, portanto, o vazamento de identificadores é mais virulentos do que vazar memória.Handles are an extremely valuable resource, so leaking handles is more virulent than leaking memory.

Observação

Esta classe contém uma demanda de link e uma demanda de herança no nível de classe que se aplica a todos os membros.This class contains a link demand and an inheritance demand at the class level that applies to all members. Um SecurityException é lançado quando o chamador imediato ou a classe derivada não tem permissão de confiança total.A SecurityException is thrown when either the immediate caller or the derived class does not have full-trust permission. Para obter detalhes sobre as demandas de segurança, consulte demandas de link.For details about security demands, see Link Demands.

.NET Core.NET CoreRegistraNotes

Na .NET Framework, a Process classe por padrão usa Console codificações, que normalmente são codificações de página de código, para os fluxos de entrada, saída e erro.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. Para o código de exemplo, em sistemas cuja cultura é inglês (Estados Unidos), a página de código 437 é a Console codificação padrão para a classe.For example code, on systems whose culture is English (United States), code page 437 is the default encoding for the Console class. No entanto, .NET Core.NET Core o pode tornar apenas um subconjunto limitado dessas codificações disponíveis.However, .NET Core.NET Core may make only a limited subset of these encodings available. Se esse for o caso, ele será Encoding.UTF8 usado como a codificação padrão.If this is the case, it uses Encoding.UTF8 as the default encoding.

Se um Process objeto depender de codificações de página de código específicas, você ainda poderá torná-los disponíveis fazendo o seguinte antes de Process chamar qualquer método: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. Adicione uma referência ao assembly System. Text. Encoding. CodePageings. dll ao seu projeto.Add a reference to the System.Text.Encoding.CodePages.dll assembly to your project.

  2. Recupere o EncodingProvider objeto CodePagesEncodingProvider.Instance da propriedade.Retrieve the EncodingProvider object from the CodePagesEncodingProvider.Instance property.

  3. Passe o EncodingProvider objeto para o Encoding.RegisterProvider método para tornar as codificações adicionais com suporte do provedor de codificação disponíveis.Pass the EncodingProvider object to the Encoding.RegisterProvider method to make the additional encodings supported by the encoding provider available.

A Process classe usará automaticamente a codificação do sistema padrão em vez de UTF8, desde que você tenha registrado o provedor de codificação antes Process de chamar qualquer método.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.

Construtores

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

Inicializa uma nova instância da classe Process.Initializes a new instance of the Process class.

Propriedades

BasePriority BasePriority BasePriority BasePriority

Obtém a prioridade base do processo associado.Gets the base priority of the associated process.

CanRaiseEvents CanRaiseEvents CanRaiseEvents CanRaiseEvents

Obtém um valor que indica se o componente pode acionar um evento.Gets a value indicating whether the component can raise an event.

(Inherited from Component)
Container Container Container Container

Obtém o IContainer que contém o Component.Gets the IContainer that contains the Component.

(Inherited from Component)
DesignMode DesignMode DesignMode DesignMode

Obtém um valor que indica se o Component está no modo de design no momento.Gets a value that indicates whether the Component is currently in design mode.

(Inherited from Component)
EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents EnableRaisingEvents

Obtém ou define se o evento Exited deve ser gerado quando o processo é encerrado.Gets or sets whether the Exited event should be raised when the process terminates.

Events Events Events Events

Obtém a lista de manipuladores de eventos que estão anexados a este Component.Gets the list of event handlers that are attached to this Component.

(Inherited from Component)
ExitCode ExitCode ExitCode ExitCode

Obtém o valor especificado pelo processo associado quando ele foi finalizado.Gets the value that the associated process specified when it terminated.

ExitTime ExitTime ExitTime ExitTime

Obtém a hora em que o processo associado foi encerrado.Gets the time that the associated process exited.

Handle Handle Handle Handle

Obtém o identificador nativo do processo associado.Gets the native handle of the associated process.

HandleCount HandleCount HandleCount HandleCount

Obtém o número de identificadores abertos pelo processo.Gets the number of handles opened by the process.

HasExited HasExited HasExited HasExited

Obtém um valor que indica se o processo associado foi encerrado.Gets a value indicating whether the associated process has been terminated.

Id Id Id Id

Obtém o identificador exclusivo para o processo associado.Gets the unique identifier for the associated process.

MachineName MachineName MachineName MachineName

Obtém o nome do computador no qual o processo associado está em execução.Gets the name of the computer the associated process is running on.

MainModule MainModule MainModule MainModule

Obtém o módulo principal do processo associado.Gets the main module for the associated process.

MainWindowHandle MainWindowHandle MainWindowHandle MainWindowHandle

Obtém o identificador de janela da janela principal do processo associado.Gets the window handle of the main window of the associated process.

MainWindowTitle MainWindowTitle MainWindowTitle MainWindowTitle

Obtém a legenda da janela principal do processo.Gets the caption of the main window of the process.

MaxWorkingSet MaxWorkingSet MaxWorkingSet MaxWorkingSet

Obtém ou define o tamanho de conjunto de trabalho máximo permitido em bytes para o processo associado.Gets or sets the maximum allowable working set size, in bytes, for the associated process.

MinWorkingSet MinWorkingSet MinWorkingSet MinWorkingSet

Obtém ou define o tamanho de conjunto de trabalho mínimo permitido em bytes para o processo associado.Gets or sets the minimum allowable working set size, in bytes, for the associated process.

Modules Modules Modules Modules

Obtém os módulos que foram carregados pelo processo associado.Gets the modules that have been loaded by the associated process.

NonpagedSystemMemorySize NonpagedSystemMemorySize NonpagedSystemMemorySize NonpagedSystemMemorySize

Obtém a quantidade de memória não paginada, em bytes, alocada para o processo associado.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

NonpagedSystemMemorySize64 NonpagedSystemMemorySize64 NonpagedSystemMemorySize64 NonpagedSystemMemorySize64

Obtém a quantidade de memória não paginada, em bytes, alocada para o processo associado.Gets the amount of nonpaged system memory, in bytes, allocated for the associated process.

PagedMemorySize PagedMemorySize PagedMemorySize PagedMemorySize

Obtém a quantidade de memória paginada, em bytes, alocada para o processo associado.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedMemorySize64 PagedMemorySize64 PagedMemorySize64 PagedMemorySize64

Obtém a quantidade de memória paginada, em bytes, alocada para o processo associado.Gets the amount of paged memory, in bytes, allocated for the associated process.

PagedSystemMemorySize PagedSystemMemorySize PagedSystemMemorySize PagedSystemMemorySize

Obtém a quantidade de memória paginável do sistema, em bytes, alocada para o processo associado.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PagedSystemMemorySize64 PagedSystemMemorySize64 PagedSystemMemorySize64 PagedSystemMemorySize64

Obtém a quantidade de memória paginável do sistema, em bytes, alocada para o processo associado.Gets the amount of pageable system memory, in bytes, allocated for the associated process.

PeakPagedMemorySize PeakPagedMemorySize PeakPagedMemorySize PeakPagedMemorySize

Obtém a quantidade máxima de memória, em bytes, no arquivo de paginação de memória virtual usado pelo processo associado.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakPagedMemorySize64 PeakPagedMemorySize64 PeakPagedMemorySize64 PeakPagedMemorySize64

Obtém a quantidade máxima de memória, em bytes, no arquivo de paginação de memória virtual usado pelo processo associado.Gets the maximum amount of memory in the virtual memory paging file, in bytes, used by the associated process.

PeakVirtualMemorySize PeakVirtualMemorySize PeakVirtualMemorySize PeakVirtualMemorySize

Obtém a quantidade máxima de memória virtual, em bytes, usada pelo processo associado.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakVirtualMemorySize64 PeakVirtualMemorySize64 PeakVirtualMemorySize64 PeakVirtualMemorySize64

Obtém a quantidade máxima de memória virtual, em bytes, usada pelo processo associado.Gets the maximum amount of virtual memory, in bytes, used by the associated process.

PeakWorkingSet PeakWorkingSet PeakWorkingSet PeakWorkingSet

Obtém o tamanho do conjunto de trabalho máximo para o processo associado, em bytes.Gets the peak working set size for the associated process, in bytes.

PeakWorkingSet64 PeakWorkingSet64 PeakWorkingSet64 PeakWorkingSet64

Obtém a quantidade máxima de memória física, em bytes, usada pelo processo associado.Gets the maximum amount of physical memory, in bytes, used by the associated process.

PriorityBoostEnabled PriorityBoostEnabled PriorityBoostEnabled PriorityBoostEnabled

Obtém ou define um valor que indica se a prioridade do processo associada deve temporariamente ser aumentada pelo sistema operacional quando o foco estiver na janela principal.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

Obtém ou define a categoria geral de prioridade para o processo associado.Gets or sets the overall priority category for the associated process.

PrivateMemorySize PrivateMemorySize PrivateMemorySize PrivateMemorySize

Obtém a quantidade de memória privada, em bytes, alocada ao processo associado.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivateMemorySize64 PrivateMemorySize64 PrivateMemorySize64 PrivateMemorySize64

Obtém a quantidade de memória privada, em bytes, alocada ao processo associado.Gets the amount of private memory, in bytes, allocated for the associated process.

PrivilegedProcessorTime PrivilegedProcessorTime PrivilegedProcessorTime PrivilegedProcessorTime

Obtém o tempo de processador privilegiado para esse processo.Gets the privileged processor time for this process.

ProcessName ProcessName ProcessName ProcessName

Obtém o nome do processo.Gets the name of the process.

ProcessorAffinity ProcessorAffinity ProcessorAffinity ProcessorAffinity

Obtém ou define os processadores nos quais os threads desse processo podem ser agendados para execução.Gets or sets the processors on which the threads in this process can be scheduled to run.

Responding Responding Responding Responding

Obtém um valor que indica se a interface do usuário do processo está respondendo.Gets a value indicating whether the user interface of the process is responding.

SafeHandle SafeHandle SafeHandle SafeHandle

Obtém o identificador nativo para esse processo.Gets the native handle to this process.

SessionId SessionId SessionId SessionId

Obtém o identificador de sessão dos Serviços de Terminal para o processo associado.Gets the Terminal Services session identifier for the associated process.

Site Site Site Site

Obtém ou define o ISite do Component.Gets or sets the ISite of the Component.

(Inherited from Component)
StandardError StandardError StandardError StandardError

Obtém um fluxo usado para ler a saída de erro do aplicativo.Gets a stream used to read the error output of the application.

StandardInput StandardInput StandardInput StandardInput

Obtém um fluxo usado para gravar a entrada do aplicativo.Gets a stream used to write the input of the application.

StandardOutput StandardOutput StandardOutput StandardOutput

Obtém um fluxo usado para ler a saída textual do aplicativo.Gets a stream used to read the textual output of the application.

StartInfo StartInfo StartInfo StartInfo

Obtém ou define as propriedades a serem passadas para o método Start() do Process.Gets or sets the properties to pass to the Start() method of the Process.

StartTime StartTime StartTime StartTime

Obtém a hora em que o processo associado foi iniciado.Gets the time that the associated process was started.

SynchronizingObject SynchronizingObject SynchronizingObject SynchronizingObject

Obtém ou define o objeto usado para realizar marshaling das chamadas do manipulador de eventos emitidas como resultado de um evento de encerramento de um processo.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

Obtém o conjunto de threads que estão em execução no processo associado.Gets the set of threads that are running in the associated process.

TotalProcessorTime TotalProcessorTime TotalProcessorTime TotalProcessorTime

Obtém o tempo de processador total para esse processo.Gets the total processor time for this process.

UserProcessorTime UserProcessorTime UserProcessorTime UserProcessorTime

Obtém o tempo de processador do usuário para esse processo.Gets the user processor time for this process.

VirtualMemorySize VirtualMemorySize VirtualMemorySize VirtualMemorySize

Obtém o tamanho da memória virtual do processo, em bytes.Gets the size of the process's virtual memory, in bytes.

VirtualMemorySize64 VirtualMemorySize64 VirtualMemorySize64 VirtualMemorySize64

Obtém a quantidade de memória virtual, em bytes, alocada para o processo associado.Gets the amount of the virtual memory, in bytes, allocated for the associated process.

WorkingSet WorkingSet WorkingSet WorkingSet

Obtém o uso de memória física do processo associado, em bytes.Gets the associated process's physical memory usage, in bytes.

WorkingSet64 WorkingSet64 WorkingSet64 WorkingSet64

Obtém a quantidade de memória física, em bytes, alocada para o processo associado.Gets the amount of physical memory, in bytes, allocated for the associated process.

Métodos

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

Inicia as operações de leitura assíncronas no fluxo StandardError redirecionado do aplicativo.Begins asynchronous read operations on the redirected StandardError stream of the application.

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

Inicia as operações de leitura assíncronas no fluxo StandardOutput redirecionado do aplicativo.Begins asynchronous read operations on the redirected StandardOutput stream of the application.

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

Cancela a operação de leitura assíncrona no fluxo StandardError redirecionado de um aplicativo.Cancels the asynchronous read operation on the redirected StandardError stream of an application.

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

Cancela a operação de leitura assíncrona no fluxo StandardOutput redirecionado de um aplicativo.Cancels the asynchronous read operation on the redirected StandardOutput stream of an application.

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

Libera todos os recursos associados a esse componente.Frees all the resources that are associated with this component.

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

Fecha um processo que tem uma interface do usuário enviando uma mensagem de fechamento à janela principal.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)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.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)

Libere todos os recursos usados por esse processo.Release all resources used by this process.

EnterDebugMode() EnterDebugMode() EnterDebugMode() EnterDebugMode()

Coloca um componente Process no estado para interagir com os processos do sistema operacional executados em um modo especial, habilitando a propriedade nativa SeDebugPrivilege no thread atual.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)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

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

Obtém um novo componente Process e o associa ao processo ativo no momento.Gets a new Process component and associates it with the currently active process.

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

Serve como a função de hash padrão.Serves as the default hash function.

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

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.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)

Retorna um novo componente Process, tendo em conta o identificador de um processo no computador 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)

Retorna um novo componente Process, dado um identificador de processo e o nome de um computador na rede.Returns a new Process component, given a process identifier and the name of a computer on the network.

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

Cria um novo componente Process para cada recurso de processo no computador local.Creates a new Process component for each process resource on the local computer.

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

Cria um novo componente Process para cada recurso de processo no computador especificado.Creates a new Process component for each process resource on the specified computer.

GetProcessesByName(String) GetProcessesByName(String) GetProcessesByName(String) GetProcessesByName(String)

Cria uma matriz de novos componentes Process e os associa a todos os recursos do processo no computador local que compartilham o nome do processo especificado.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)

Cria uma matriz de novos componentes Process e os associa a todos os recursos do processo em um computador remoto que compartilham o nome do processo especificado.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)

Retorna um objeto que representa um serviço fornecido pelo Component ou pelo seu Container.Returns an object that represents a service provided by the Component or by its Container.

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

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Interrompe imediatamente o processo associado.Immediately stops the associated process.

Kill(Boolean) Kill(Boolean) Kill(Boolean) Kill(Boolean)

Interrompe imediatamente o processo associado e, opcionalmente, seus processos filho/descendentes.Immediately stops the associated process, and optionally its child/descendent processes.

LeaveDebugMode() LeaveDebugMode() LeaveDebugMode() LeaveDebugMode()

Tira um componente Process do estado que permite a ele interagir com processos do sistema operacional que são executados em um modo especial.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()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

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

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

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

Aciona o evento Exited.Raises the Exited event.

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

Descarta informações sobre o processo associado que foi armazenado em cache dentro do componente do processo.Discards any information about the associated process that has been cached inside the process component.

Start() Start() Start() Start()

Inicia (ou reutiliza) o recurso do processo que é especificado pela propriedade StartInfo desse componente Process e o associa ao componente.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)

Inicia o recurso de processo especificado pelo parâmetro que contém informações de início do processo (por exemplo, o nome do arquivo do processo a ser iniciado) e associa o recurso a um novo componente 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)

Inicia um recurso de processo especificando o nome de um arquivo de aplicativo ou documento e associa o recurso a um novo componente 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)

Inicia um recurso de processo especificando o nome de um aplicativo e um conjunto de argumentos de linha de comando e associa o recurso a um novo componente 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)

Inicia um recurso de processo, especificando o nome de um aplicativo, um nome de usuário, uma senha e um domínio e associa o recurso a um novo componente 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)

Inicia um recurso de processo, especificando o nome de um aplicativo, um conjunto de argumentos de linha de comando, um nome de usuário, uma senha e um domínio e associa o recurso a um novo componente 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()

Formata o nome do processo como uma cadeia de caracteres, combinada com o tipo de componente pai, se aplicável.Formats the process's name as a string, combined with the parent component type, if applicable.

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

Instrui o componente Process a esperar indefinidamente que o processo associado seja encerrado.Instructs the Process component to wait indefinitely for the associated process to exit.

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

Instrui o componente Process a aguardar o número especificado de milissegundos para que o processo associado seja encerrado.Instructs the Process component to wait the specified number of milliseconds for the associated process to exit.

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

Faz com que o componente Process aguarde por tempo indefinido até que o processo associado entre em um estado ocioso.Causes the Process component to wait indefinitely for the associated process to enter an idle state. Essa sobrecarga se aplica apenas a processos com uma interface do usuário e, portanto, um loop de mensagem.This overload applies only to processes with a user interface and, therefore, a message loop.

WaitForInputIdle(Int32) WaitForInputIdle(Int32) WaitForInputIdle(Int32) WaitForInputIdle(Int32)

Faz com que o componente Process a aguarde o número especificado de milissegundos para que o processo entre em um estado ocioso.Causes the Process component to wait the specified number of milliseconds for the associated process to enter an idle state. Essa sobrecarga se aplica apenas a processos com uma interface do usuário e, portanto, um loop de mensagem.This overload applies only to processes with a user interface and, therefore, a message loop.

Eventos

Disposed Disposed Disposed Disposed

Ocorre quando o componente é disposto por uma chamada para o método Dispose().Occurs when the component is disposed by a call to the Dispose() method.

(Inherited from Component)
ErrorDataReceived ErrorDataReceived ErrorDataReceived ErrorDataReceived

Ocorre quando um aplicativo realiza gravação em seu fluxo StandardError redirecionado.Occurs when an application writes to its redirected StandardError stream.

Exited Exited Exited Exited

Ocorre quando um processo é fechado.Occurs when a process exits.

OutputDataReceived OutputDataReceived OutputDataReceived OutputDataReceived

Ocorre sempre que um aplicativo grava uma linha no fluxo StandardOutput redirecionado.Occurs each time an application writes a line to its redirected StandardOutput stream.

Segurança

LinkDemand
para confiança total do chamador imediato.for full trust for the immediate caller. Esta classe não pode ser usada pelo código parcialmente confiável.This class cannot be used by partially trusted code.

InheritanceDemand
para confiança total de herdeiros.for full trust for inheritors. Esta classe não pode ser herdada pelo código parcialmente confiável.This class cannot be inherited by partially trusted code.

Aplica-se a

Veja também