Process Clase

Definición

Espacio de nombres:

System.Diagnostics

Ensamblado:

System.Diagnostics.Process.dll

Source:

Process.cs

Proporciona acceso a procesos locales y remotos y le permite iniciar y detener los procesos del sistema local.

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

public class Process : System.ComponentModel.Component, IDisposable

type Process = class
    inherit Component
    interface IDisposable

Public Class Process
Inherits Component
Implements IDisposable

Herencia

Object

MarshalByRefObject

Component

Process

Implementaciones

IDisposable

Ejemplos

En el ejemplo siguiente se usa una instancia de la clase Process para iniciar un proceso.

#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);
            }
        }
    }
}

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

En el ejemplo siguiente se usa la propia clase Process y un método de Start estático para iniciar un proceso.

#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();
        }
    }
}

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

En el siguiente ejemplo de F# se define una función de runProc que inicia un proceso, captura toda la información de salida y error y registra el número de milisegundos que se ha ejecutado el proceso. La función runProc tiene tres parámetros: el nombre de la aplicación que se va a iniciar, los argumentos que se van a proporcionar a la aplicación y el directorio 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

El código de la función runProc fue escrito por imaginaryDevelopment y está disponible en la licencia pública de Microsoft.

Comentarios

Un componente Process proporciona acceso a un proceso que se ejecuta en un equipo. Un proceso, en los términos más sencillos, es una aplicación en ejecución. Un subproceso es la unidad básica a la que el sistema operativo asigna tiempo de procesador. Un subproceso puede ejecutar cualquier parte del código del proceso, incluidas las partes que está ejecutando actualmente otro subproceso.

El componente Process es una herramienta útil para iniciar, detener, controlar y supervisar aplicaciones. Puede usar el componente Process para obtener una lista de los procesos que se ejecutan o puede iniciar un nuevo proceso. Un componente de Process se usa para acceder a los procesos del sistema. Después de inicializar un componente Process, se puede usar para obtener información sobre el proceso en ejecución. Esta información incluye el conjunto de subprocesos, los módulos cargados ( archivos.dll y .exe) y la información de rendimiento, como la cantidad de memoria que usa el proceso.

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de usar el tipo, debe eliminarlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/finally. Para eliminarlo indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para obtener más información, vea la sección "Using an Object that Implements IDisposable" (Usar un objeto que implementa IDisposable) en la documentación de la interfaz de IDisposable.

Importante

Llamar a métodos de esta clase con datos que no son de confianza es un riesgo de seguridad. Llame a los métodos de esta clase solo con datos de confianza. Para obtener más información, vea Validar todas las entradas.

Nota

Los procesos de 32 bits no pueden acceder a los módulos de un proceso de 64 bits. Si intenta obtener información sobre un proceso de 64 bits a partir de un proceso de 32 bits, obtendrá una excepción de Win32Exception. Por otro lado, un proceso de 64 bits puede acceder a los módulos de un proceso de 32 bits.

El componente de proceso obtiene información sobre un grupo de propiedades a la vez. Después de que el componente Process haya obtenido información sobre un miembro de cualquier grupo, almacenará en caché los valores de las otras propiedades de ese grupo y no obtendrá información nueva sobre los otros miembros del grupo hasta que llame al método Refresh. Por lo tanto, no se garantiza que un valor de propiedad sea más reciente que la última llamada al método Refresh. Los desgloses del grupo dependen del sistema operativo.

Si tiene una variable de ruta de acceso declarada en el sistema con comillas, debe calificar por completo esa ruta de acceso al iniciar cualquier proceso que se encuentre en esa ubicación. De lo contrario, el sistema no encontrará la ruta de acceso. Por ejemplo, si c:\mypath no está en la ruta de acceso y lo agrega con comillas: path = %path%;"c:\mypath", debe calificar completamente cualquier proceso en c:\mypath al iniciarlo.

Un proceso del sistema se identifica de forma única en el sistema por su identificador de proceso. Al igual que muchos recursos de Windows, un proceso también se identifica mediante su identificador, que podría no ser único en el equipo. Un identificador es el término genérico para un identificador de un recurso. El sistema operativo conserva el identificador de proceso, al que se accede a través de la propiedad Handle del componente Process, incluso cuando el proceso se ha salido. Por lo tanto, puede obtener la información administrativa del proceso, como el ExitCode (normalmente cero para éxito o un código de error distinto de cero) y el ExitTime. Los identificadores son un recurso extremadamente valioso, por lo que los identificadores de fuga son más virulentos que la pérdida de memoria.

Nota

Esta clase contiene una demanda de vínculo y una demanda de herencia en el nivel de clase que se aplica a todos los miembros. Se produce un SecurityException cuando el llamador inmediato o la clase derivada no tienen permiso de plena confianza. Para obtener más información sobre las demandas de seguridad, consulte Link Demand.

Notas de .NET Core

En .NET Framework, la clase Process usa de forma predeterminada Console codificaciones, que normalmente son codificaciones de página de códigos, para las secuencias de entrada, salida y error. Por ejemplo, en sistemas cuya referencia cultural es inglés (Estados Unidos), la página de códigos 437 es la codificación predeterminada para la clase Console. Sin embargo, .NET Core puede hacer que solo haya disponible un subconjunto limitado de estas codificaciones. Si este es el caso, usa Encoding.UTF8 como codificación predeterminada.

Si un objeto de Process depende de codificaciones de páginas de códigos específicas, puede seguir haciéndolos disponibles haciendo lo siguiente antes de que llame a los métodos de Process:

1. Recupere el objeto EncodingProvider de la propiedad CodePagesEncodingProvider.Instance.

2. Pase el objeto EncodingProvider al método Encoding.RegisterProvider para que las codificaciones adicionales sean compatibles con el proveedor de codificación.

A continuación, la clase Process usará automáticamente la codificación del sistema predeterminada en lugar de UTF8, siempre que haya registrado el proveedor de codificación antes de llamar a los métodos de Process.

Constructores

Process()

Inicializa una nueva instancia de la clase Process.

Propiedades

BasePriority	Obtiene la prioridad base del proceso asociado.
CanRaiseEvents	Obtiene un valor que indica si el componente puede generar un evento. (Heredado de Component)
Container	Obtiene el IContainer que contiene el Component. (Heredado de Component)
DesignMode	Obtiene un valor que indica si el Component está actualmente en modo de diseño. (Heredado de Component)
EnableRaisingEvents	Obtiene o establece si se debe generar el evento Exited cuando finaliza el proceso.
Events	Obtiene la lista de controladores de eventos que están asociados a este Component. (Heredado de Component)
ExitCode	Obtiene el valor que especificó el proceso asociado cuando finalizó.
ExitTime	Obtiene la hora a la que salió el proceso asociado.
Handle	Obtiene el identificador nativo del proceso asociado.
HandleCount	Obtiene el número de identificadores abiertos por el proceso.
HasExited	Obtiene un valor que indica si se ha finalizado el proceso asociado.
Id	Obtiene el identificador único del proceso asociado.
MachineName	Obtiene el nombre del equipo en el que se ejecuta el proceso asociado.
MainModule	Obtiene el módulo principal del proceso asociado.
MainWindowHandle	Obtiene el identificador de ventana de la ventana principal del proceso asociado.
MainWindowTitle	Obtiene el título de la ventana principal del proceso.
MaxWorkingSet	Obtiene o establece el tamaño máximo permitido del conjunto de trabajo, en bytes, para el proceso asociado.
MinWorkingSet	Obtiene o establece el tamaño mínimo permitido del conjunto de trabajo, en bytes, para el proceso asociado.
Modules	Obtiene los módulos cargados por el proceso asociado.
NonpagedSystemMemorySize	Obsoletos. Obtiene la cantidad de memoria del sistema no paginada, en bytes, asignada para el proceso asociado.
NonpagedSystemMemorySize64	Obtiene la cantidad de memoria del sistema no paginada, en bytes, asignada para el proceso asociado.
PagedMemorySize	Obsoletos. Obtiene la cantidad de memoria paginada, en bytes, asignada para el proceso asociado.
PagedMemorySize64	Obtiene la cantidad de memoria paginada, en bytes, asignada para el proceso asociado.
PagedSystemMemorySize	Obsoletos. Obtiene la cantidad de memoria del sistema paginable, en bytes, asignada para el proceso asociado.
PagedSystemMemorySize64	Obtiene la cantidad de memoria del sistema paginable, en bytes, asignada para el proceso asociado.
PeakPagedMemorySize	Obsoletos. Obtiene la cantidad máxima de memoria en el archivo de paginación de memoria virtual, en bytes, utilizado por el proceso asociado.
PeakPagedMemorySize64	Obtiene la cantidad máxima de memoria en el archivo de paginación de memoria virtual, en bytes, utilizado por el proceso asociado.
PeakVirtualMemorySize	Obsoletos. Obtiene la cantidad máxima de memoria virtual, en bytes, usada por el proceso asociado.
PeakVirtualMemorySize64	Obtiene la cantidad máxima de memoria virtual, en bytes, usada por el proceso asociado.
PeakWorkingSet	Obsoletos. Obtiene el tamaño máximo del conjunto de trabajo para el proceso asociado, en bytes.
PeakWorkingSet64	Obtiene la cantidad máxima de memoria física, en bytes, usada por el proceso asociado.
PriorityBoostEnabled	Obtiene o establece un valor que indica si el sistema operativo debe aumentar temporalmente la prioridad del proceso asociado cuando la ventana principal tiene el foco.
PriorityClass	Obtiene o establece la categoría de prioridad general para el proceso asociado.
PrivateMemorySize	Obsoletos. Obtiene la cantidad de memoria privada, en bytes, asignada para el proceso asociado.
PrivateMemorySize64	Obtiene la cantidad de memoria privada, en bytes, asignada para el proceso asociado.
PrivilegedProcessorTime	Obtiene el tiempo del procesador con privilegios para este proceso.
ProcessName	Obtiene el nombre del proceso.
ProcessorAffinity	Obtiene o establece los procesadores en los que se pueden programar los subprocesos de este proceso.
Responding	Obtiene un valor que indica si la interfaz de usuario del proceso responde.
SafeHandle	Obtiene el identificador nativo de este proceso.
SessionId	Obtiene el identificador de sesión de Terminal Services para el proceso asociado.
Site	Obtiene o establece el ISite del Component. (Heredado de Component)
StandardError	Obtiene una secuencia que se usa para leer la salida de error de la aplicación.
StandardInput	Obtiene una secuencia usada para escribir la entrada de la aplicación.
StandardOutput	Obtiene una secuencia que se usa para leer la salida textual de la aplicación.
StartInfo	Obtiene o establece las propiedades que se van a pasar al método Start() del Process.
StartTime	Obtiene la hora en que se inició el proceso asociado.
SynchronizingObject	Obtiene o establece el objeto utilizado para serializar las llamadas del controlador de eventos que se emiten como resultado de un evento de salida de proceso.
Threads	Obtiene el conjunto de subprocesos que se ejecutan en el proceso asociado.
TotalProcessorTime	Obtiene el tiempo total del procesador para este proceso.
UserProcessorTime	Obtiene el tiempo de procesador del usuario para este proceso.
VirtualMemorySize	Obsoletos. Obtiene el tamaño de la memoria virtual del proceso, en bytes.
VirtualMemorySize64	Obtiene la cantidad de la memoria virtual, en bytes, asignada para el proceso asociado.
WorkingSet	Obsoletos. Obtiene el uso de memoria física del proceso asociado, en bytes.
WorkingSet64	Obtiene la cantidad de memoria física, en bytes, asignada para el proceso asociado.

Métodos

BeginErrorReadLine()	Comienza las operaciones de lectura asincrónicas en el flujo de StandardError redirigido de la aplicación.
BeginOutputReadLine()	Comienza las operaciones de lectura asincrónicas en el flujo de StandardOutput redirigido de la aplicación.
CancelErrorRead()	Cancela la operación de lectura asincrónica en el flujo de StandardError redirigido de una aplicación.
CancelOutputRead()	Cancela la operación de lectura asincrónica en el flujo de StandardOutput redirigido de una aplicación.
Close()	Libera todos los recursos asociados a este componente.
CloseMainWindow()	Cierra un proceso que tiene una interfaz de usuario enviando un mensaje de cierre a su ventana principal.
CreateObjRef(Type)	Crea un objeto que contiene toda la información pertinente necesaria para generar un proxy usado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos usados por el Component. (Heredado de Component)
Dispose(Boolean)	Libere todos los recursos usados por este proceso.
EnterDebugMode()	Coloca un componente de Process en estado para interactuar con los procesos del sistema operativo que se ejecutan en modo especial habilitando la propiedad nativa SeDebugPrivilege en el subproceso actual.
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
GetCurrentProcess()	Obtiene un nuevo componente Process y lo asocia al proceso activo actualmente.
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetProcessById(Int32, String)	Devuelve un nuevo componente Process, dado un identificador de proceso y el nombre de un equipo de la red.
GetProcessById(Int32)	Devuelve un nuevo componente Process, dado el identificador de un proceso en el equipo local.
GetProcesses()	Crea un nuevo componente de Process para cada recurso de proceso en el equipo local.
GetProcesses(String)	Crea un nuevo componente Process para cada recurso de proceso en el equipo especificado.
GetProcessesByName(String, String)	Crea una matriz de nuevos componentes de Process y los asocia a todos los recursos de proceso en un equipo remoto que comparte el nombre de proceso especificado.
GetProcessesByName(String)	Crea una matriz de nuevos componentes de Process y los asocia a todos los recursos de proceso del equipo local que comparten el nombre de proceso especificado.
GetService(Type)	Devuelve un objeto que representa un servicio proporcionado por el Component o por su Container. (Heredado de Component)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
Kill()	Detiene inmediatamente el proceso asociado.
Kill(Boolean)	Detiene inmediatamente el proceso asociado y, opcionalmente, sus procesos secundarios o descendientes.
LeaveDebugMode()	Quita un componente Process del estado que le permite interactuar con los procesos del sistema operativo que se ejecutan en un modo especial.
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
OnExited()	Genera el evento Exited.
Refresh()	Descarta cualquier información sobre el proceso asociado que se ha almacenado en caché dentro del componente de proceso.
Start()	Inicia (o reutiliza) el recurso de proceso especificado por la propiedad StartInfo de este componente de Process y lo asocia al componente.
Start(ProcessStartInfo)	Inicia el recurso de proceso especificado por el parámetro que contiene información de inicio del proceso (por ejemplo, el nombre de archivo del proceso que se va a iniciar) y asocia el recurso a un nuevo componente de Process.
Start(String, IEnumerable<String>)	Inicia un recurso de proceso especificando el nombre de una aplicación y un conjunto de argumentos de línea de comandos.
Start(String, String, SecureString, String)	Inicia un recurso de proceso especificando el nombre de una aplicación, un nombre de usuario, una contraseña y un dominio y asocia el recurso a un nuevo componente de Process.
Start(String, String, String, SecureString, String)	Inicia un recurso de proceso especificando el nombre de una aplicación, un conjunto de argumentos de línea de comandos, un nombre de usuario, una contraseña y un dominio y asocia el recurso a un nuevo componente de Process.
Start(String, String)	Inicia un recurso de proceso especificando el nombre de una aplicación y un conjunto de argumentos de línea de comandos y asocia el recurso a un nuevo componente de Process.
Start(String)	Inicia un recurso de proceso especificando el nombre de un archivo de documento o aplicación y asocia el recurso a un nuevo componente de Process.
ToString()	Da formato al nombre del proceso como una cadena, combinado con el tipo de componente primario, si procede.
WaitForExit()	Indica al componente Process que espere indefinidamente para que el proceso asociado salga.
WaitForExit(Int32)	Indica al componente Process que espere el número especificado de milisegundos para que el proceso asociado salga.
WaitForExit(TimeSpan)	Indica al componente Proceso que espere la cantidad de tiempo especificada para que el proceso asociado salga.
WaitForExitAsync(CancellationToken)	Indica al componente de proceso que espere a que se cierre el proceso asociado o que se cancele la cancellationToken.
WaitForInputIdle()	Hace que el componente Process espere indefinidamente para que el proceso asociado entre en un estado inactivo. Esta sobrecarga solo se aplica a los procesos con una interfaz de usuario y, por lo tanto, un bucle de mensajes.
WaitForInputIdle(Int32)	Hace que el componente Process espere al número especificado de milisegundos para que el proceso asociado entre en un estado inactivo. Esta sobrecarga solo se aplica a los procesos con una interfaz de usuario y, por lo tanto, un bucle de mensajes.
WaitForInputIdle(TimeSpan)	Hace que el componente Process espere al timeout especificado para que el proceso asociado entre en un estado inactivo. Esta sobrecarga solo se aplica a los procesos con una interfaz de usuario y, por lo tanto, un bucle de mensajes.

Eventos

Disposed	Se produce cuando el componente se elimina mediante una llamada al método Dispose(). (Heredado de Component)
ErrorDataReceived	Se produce cuando una aplicación escribe en su flujo de StandardError redirigido.
Exited	Se produce cuando se cierra un proceso.
OutputDataReceived	Se produce cada vez que una aplicación escribe una línea en su flujo de StandardOutput redirigido.

Consulte también

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