Process Clase

Definición

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

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
Herencia
Herencia
Process
Implementaciones

Ejemplos

En el ejemplo siguiente se usa una instancia de la Process clase 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);
            }
        }
    }
}
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 Process propia clase y un método estático Start 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();
        }
    }
}
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 runProc función 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 runProc función 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 runProc función fue escrito por ImaginaryDevelopment y está disponible bajo la licencia pública Microsoft.

Comentarios

Un Process componente 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, incluidos los elementos que está ejecutando actualmente otro subproceso.

El Process componente es una herramienta útil para iniciar, detener, controlar y supervisar aplicaciones. Puede usar el Process componente para obtener una lista de los procesos que se están ejecutando o puede iniciar un nuevo proceso. Se usa un Process componente para acceder a los procesos del sistema. Una vez inicializado un Process componente, 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 (.dll y .exe archivos) y la información de rendimiento, como la cantidad de memoria que está usando el proceso.

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/finally. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.

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 Win32Exception excepción. Un proceso de 64 bits, por otro lado, 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. Una vez que el Process componente haya obtenido información sobre un miembro de cualquier grupo, almacenará en caché los valores de las demás propiedades de ese grupo y no obtendrá información nueva sobre los demás miembros del grupo hasta que llame al Refresh método . Por lo tanto, no se garantiza que un valor de propiedad sea más reciente que la última llamada al Refresh método . Los desgloses del grupo dependen del sistema operativo.

Si tiene una variable de ruta de acceso declarada en el sistema con comillas, debe calificar completamente 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 Handle propiedad del Process componente, incluso cuando se ha salido del proceso. Por lo tanto, puede obtener la información administrativa del proceso, como ( ExitCode normalmente cero para el éxito o un código de error distinto de cero) y ExitTime. Los identificadores son un recurso extremadamente valioso, por lo que los identificadores de fuga son más virulentos que las fugas 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. SecurityException Se produce una excepción 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 Solicitudes de vínculo.

Notas de .NET Core

En .NET Framework, la Process clase usa Console de forma predeterminada 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 Console clase . Sin embargo, .NET Core puede hacer que solo haya disponible un subconjunto limitado de estas codificaciones. Si este es el caso, se usa Encoding.UTF8 como codificación predeterminada.

Si un Process objeto depende de codificaciones de páginas de códigos específicas, puede hacer que estén disponibles haciendo lo siguiente antes de llamar a cualquier Process método:

  1. Agregue una referencia al ensamblado System.Text.Encoding.CodePages.dll al proyecto.

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

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

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

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 la interfaz IContainer que contiene la clase Component.

(Heredado de Component)
DesignMode

Obtiene un valor que indica si Component está actualmente en modo de diseño.

(Heredado de Component)
EnableRaisingEvents

Obtiene o establece si el evento Exited debe provocarse cuando termine el proceso.

Events

Obtiene la lista de controladores de eventos asociados a Component.

(Heredado de Component)
ExitCode

Obtiene el valor especificado por el proceso asociado al terminar.

ExitTime

Obtiene el momento en el que terminó 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 el proceso asociado finalizó.

Id

Obtiene el identificador único del proceso asociado.

MachineName

Obtiene el nombre del equipo en el que se está ejecutando 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 del espacio de trabajo máximo permitido, en bytes, para el proceso asociado.

MinWorkingSet

Obtiene o establece el tamaño del espacio de trabajo mínimo permitido, en bytes, para el proceso asociado.

Modules

Obtiene los módulos cargados por el proceso asociado.

NonpagedSystemMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de la memoria no paginada del sistema en bytes que se asignó para el proceso asociado.

NonpagedSystemMemorySize64

Obtiene el tamaño de la memoria no paginada del sistema en bytes que se asignó para el proceso asociado.

PagedMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de la memoria paginada, en bytes, asignada para el proceso asociado.

PagedMemorySize64

Obtiene el tamaño de la memoria paginada, en bytes, asignada para el proceso asociado.

PagedSystemMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de la memoria paginable del sistema en bytes que se asignó para el proceso asociado.

PagedSystemMemorySize64

Obtiene el tamaño de la memoria paginable del sistema en bytes que se asignó para el proceso asociado.

PeakPagedMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de memoria máximo en el archivo de paginación de la memoria virtual, en bytes, que usa el proceso asociado.

PeakPagedMemorySize64

Obtiene el tamaño de memoria máximo en el archivo de paginación de la memoria virtual, en bytes, que usa el proceso asociado.

PeakVirtualMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene la cantidad máxima de memoria virtual, en bytes, que usa el proceso asociado.

PeakVirtualMemorySize64

Obtiene la cantidad máxima de memoria virtual, en bytes, que usa el proceso asociado.

PeakWorkingSet
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de espacio de trabajo máximo para el proceso asociado, en bytes.

PeakWorkingSet64

Obtiene la cantidad máxima de la memoria física, en bytes que usa el proceso asociado.

PriorityBoostEnabled

Obtiene o establece un valor que indica si el sistema operativo debería aumentar temporalmente la prioridad del proceso asociado cuando la ventana principal tenga el foco.

PriorityClass

Obtiene o establece la categoría de prioridad general del proceso asociado.

PrivateMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de memoria privada, en bytes, asignada para el proceso asociado.

PrivateMemorySize64

Obtiene el tamaño de memoria privada, en bytes, asignada para el proceso asociado.

PrivilegedProcessorTime

Obtiene el tiempo de procesador con privilegios de este proceso.

ProcessName

Obtiene el nombre del proceso.

ProcessorAffinity

Obtiene o establece los procesadores en los que se puede programar la ejecución de los subprocesos de este proceso.

Responding

Obtiene un valor que indica si la interfaz de usuario del proceso está respondiendo.

SafeHandle

Obtiene el identificador nativo de este proceso.

SessionId

Obtiene el identificador de la sesión de Terminal Services para el proceso asociado.

Site

Obtiene o establece ISite de Component.

(Heredado de Component)
StandardError

Obtiene una secuencia que se usa para leer la salida de errores de la aplicación.

StandardInput

Obtiene una secuencia que se usa para escribir la entrada de la aplicación.

StandardOutput

Obtiene una secuencia usada para leer la salida de texto de la aplicación.

StartInfo

Obtiene o establece las propiedades que se pasan al método Start() de Process.

StartTime

Obtiene el momento en el que se inició el proceso asociado.

SynchronizingObject

Obtiene o establece el objeto usado para calcular las referencias de las llamadas del controlador de eventos emitidas como resultado de un evento de terminación del proceso.

Threads

Obtiene el conjunto de subprocesos que se están ejecutando en el proceso asociado.

TotalProcessorTime

Obtiene el tiempo de procesador total de este proceso.

UserProcessorTime

Obtiene el tiempo de procesador de usuario de este proceso.

VirtualMemorySize
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el tamaño de la memoria virtual del proceso en bytes.

VirtualMemorySize64

Obtiene la cantidad de la memoria virtual, en bytes, que se asignó para el proceso asociado.

WorkingSet
Obsoleto.
Obsoleto.
Obsoleto.
Obsoleto.

Obtiene el uso de memoria física del proceso asociado, en bytes.

WorkingSet64

Obtiene el tamaño de memoria física, expresado en bytes, que se asignó para el proceso asociado.

Métodos

BeginErrorReadLine()

Inicia las operaciones de lectura asincrónica en la secuencia de StandardError redirigida de la aplicación.

BeginOutputReadLine()

Inicia las operaciones de lectura asincrónica en la secuencia de StandardOutput redirigida de la aplicación.

CancelErrorRead()

Cancela la operación de lectura asincrónica en la secuencia redirigida de StandardError de una aplicación.

CancelOutputRead()

Cancela la operación de lectura asincrónica en la secuencia redirigida de StandardOutput de una aplicación.

Close()

Libera todos los recursos asociados a este componente.

CloseMainWindow()

Cierra un proceso que contiene una interfaz de usuario mediante el envío de un mensaje de cierre a su ventana principal.

CreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto.

(Heredado de MarshalByRefObject)
Dispose()

Realiza tareas definidas por la aplicación asociadas a la liberación o al restablecimiento de recursos no administrados.

Dispose()

Libera todos los recursos que usa Component.

(Heredado de Component)
Dispose(Boolean)

Libera todos los recursos utilizados por este proceso.

EnterDebugMode()

Coloca un componente Process en estado de interacción con los procesos del sistema operativo que se ejecutan en un modo especial; para ello, habilita la propiedad nativa SeDebugPrivilege en el subproceso actual.

Equals(Object)

Determina si el objeto especificado es igual que el objeto actual.

(Heredado de Object)
GetCurrentProcess()

Obtiene un nuevo componente Process y lo asocia al proceso que está activo en ese momento.

GetHashCode()

Sirve como la función hash predeterminada.

(Heredado de Object)
GetLifetimeService()
Obsoleto.

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.

(Heredado de MarshalByRefObject)
GetProcessById(Int32)

Devuelve un nuevo componente Process, dado un identificador de un proceso en el equipo local.

GetProcessById(Int32, String)

Devuelve un nuevo componente Process, dados un identificador de proceso y el nombre de un equipo en la red.

GetProcesses()

Crea un nuevo componente Process para cada recurso de proceso del equipo local.

GetProcesses(String)

Crea un nuevo componente Process para cada recurso de proceso en el equipo especificado.

GetProcessesByName(String)

Crea una matriz de nuevos componentes Process y los asocia a todos los recursos de proceso del equipo local que comparten el nombre de proceso especificado.

GetProcessesByName(String, String)

Crea una matriz de nuevos componentes Process y los asocia a todos los recursos de proceso de un equipo remoto que comparten el nombre del proceso especificado.

GetService(Type)

Devuelve un objeto que representa el servicio suministrado por Component o por Container.

(Heredado de Component)
GetType()

Obtiene el Type de la instancia actual.

(Heredado de Object)
InitializeLifetimeService()
Obsoleto.

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

Recupera un componente Process del estado que le permite interactuar con procesos del sistema operativo que se ejecuten en un modo especial.

MemberwiseClone()

Crea una copia superficial del Object actual.

(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 acerca del proceso asociado que se haya almacenado en caché en el componente del proceso.

Start()

Inicia (o reutiliza) el recurso de proceso especificado por la propiedad StartInfo de este componente Process y lo asocia al componente.

Start(ProcessStartInfo)

Inicia el recurso de proceso que se especifica mediante el parámetro que contiene la 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 Process.

Start(String)

Inicia un recurso de proceso con la especificación del nombre de un documento o de un archivo de aplicación y asocia el recurso a un nuevo componente Process.

Start(String, IEnumerable<String>)

Inicia un recurso de proceso mediante la especificación del nombre de una aplicación y un conjunto de argumentos de línea de comandos.

Start(String, String)

Inicia un recurso de proceso mediante la especificación del nombre de una aplicación y un conjunto de argumentos de línea de comandos, y asocia el recurso a un nuevo componente Process.

Start(String, String, SecureString, String)

Inicia un recurso de proceso mediante la especificación del 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 mediante la especificación del nombre de una aplicación y 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.

ToString()

Aplica formato de cadena al nombre del proceso, combinándolo con el tipo de componente principal, si es aplicable.

ToString()

Devuelve una cadena que representa el objeto actual.

(Heredado de Object)
WaitForExit()

Indica al componente Process que espere indefinidamente hasta que el proceso asociado termine.

WaitForExit(Int32)

Indica al componente Process que espere a que el proceso asociado termine durante el número de milisegundos especificado.

WaitForExit(TimeSpan)

Indica al componente Process 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 cancellationToken.

WaitForInputIdle()

Hace que el componente Process espere indefinidamente a que el proceso asociado entre en estado de inactividad. Esta sobrecarga solo se aplica a los procesos que tengan una interfaz de usuario y, por tanto, un bucle de mensajes.

WaitForInputIdle(Int32)

Hace que el componente Process espere a que el proceso asociado entre en estado de inactividad durante el número de milisegundos especificado. Esta sobrecarga solo se aplica a los procesos que tengan una interfaz de usuario y, por tanto, un bucle de mensajes.

WaitForInputIdle(TimeSpan)

Hace que el Process componente espere a que el proceso asociado especifique timeout un estado inactivo. Esta sobrecarga solo se aplica a los procesos que tengan una interfaz de usuario y, por tanto, un bucle de mensajes.

Eventos

Disposed

Tiene lugar cuando una llamada elimina el componente mediante una llamada al método Dispose().

(Heredado de Component)
ErrorDataReceived

Se produce cuando una aplicación escribe en su secuencia redirigida de StandardError.

Exited

Se produce cuando termina un proceso.

OutputDataReceived

Se produce cada vez que una aplicación escribe una línea en su secuencia StandardOutput redirigida.

Se aplica a

Consulte también