Process.Start Metodo

Origine:

Process.Unix.cs

Origine:

Process.Unix.cs

Origine:

Process.Unix.cs

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ arguments, System::String ^ userName, System::Security::SecureString ^ password, System::String ^ domain);

[System.CLSCompliant(false)]
[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Diagnostics.Process? Start (string fileName, string arguments, string userName, System.Security.SecureString password, string domain);

[System.CLSCompliant(false)]
public static System.Diagnostics.Process Start (string fileName, string arguments, string userName, System.Security.SecureString password, string domain);

public static System.Diagnostics.Process Start (string fileName, string arguments, string userName, System.Security.SecureString password, string domain);

[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member Start : string * string * string * System.Security.SecureString * string -> System.Diagnostics.Process

[<System.CLSCompliant(false)>]
static member Start : string * string * string * System.Security.SecureString * string -> System.Diagnostics.Process

static member Start : string * string * string * System.Security.SecureString * string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, arguments As String, userName As String, password As SecureString, domain As String) As Process

Parametri

Restituisce

Nuovo Process associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato parallelamente a istanze dello stesso processo già in esecuzione sarà indipendente dalle altre. Inoltre, l'avvio può restituire un processo non Null con la relativa proprietà HasExited già impostata su true. In questo caso, è possibile che il processo avviato abbia attivato un'istanza esistente di se stesso e quindi sia terminato.

Attributi

CLSCompliantAttribute SupportedOSPlatformAttribute

Eccezioni

Commenti

Usare questo overload per creare un nuovo processo e il relativo thread primario specificando il nome del file, gli argomenti della riga di comando, il nome utente, la password e il dominio. Il nuovo processo esegue quindi il file eseguibile specificato nel contesto di sicurezza delle credenziali specificate (utente, dominio e password).

Questo overload consente di avviare un processo senza prima creare una nuova Process istanza. L'overload è un'alternativa alla procedura esplicita di creazione di una nuova Process istanza, l'impostazione delle FileNameproprietà , UserNameArgumentsPassworde Domain della proprietà della StartInfo proprietà e la chiamata Start all'istanza.Process

Analogamente, nello stesso modo in cui la finestra di dialogo Esegui può accettare un nome di file eseguibile con o senza l'estensione .exe, l'estensione .exe è facoltativa nel fileName parametro. Ad esempio, è possibile impostare il fileName parametro su "Notepad.exe" o "Blocco note". Se il parametro rappresenta un file eseguibile, il fileNamearguments parametro potrebbe rappresentare un file da eseguire, ad esempio il file di testo in Notepad.exe myfile.txt.

Ogni volta che si usa Start per avviare un processo, potrebbe essere necessario chiuderlo o perdere risorse di sistema. Chiudere i processi usando CloseMainWindow o Kill. È possibile verificare se un processo è già stato chiuso usando la relativa HasExited proprietà.

Origine:

Process.Unix.cs

Origine:

Process.Unix.cs

Origine:

Process.Unix.cs

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ userName, System::Security::SecureString ^ password, System::String ^ domain);

[System.CLSCompliant(false)]
[System.Runtime.Versioning.SupportedOSPlatform("windows")]
public static System.Diagnostics.Process? Start (string fileName, string userName, System.Security.SecureString password, string domain);

[System.CLSCompliant(false)]
public static System.Diagnostics.Process Start (string fileName, string userName, System.Security.SecureString password, string domain);

public static System.Diagnostics.Process Start (string fileName, string userName, System.Security.SecureString password, string domain);

[<System.CLSCompliant(false)>]
[<System.Runtime.Versioning.SupportedOSPlatform("windows")>]
static member Start : string * string * System.Security.SecureString * string -> System.Diagnostics.Process

[<System.CLSCompliant(false)>]
static member Start : string * string * System.Security.SecureString * string -> System.Diagnostics.Process

static member Start : string * string * System.Security.SecureString * string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, userName As String, password As SecureString, domain As String) As Process

Parametri

Restituisce

Nuovo Process associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato parallelamente a istanze dello stesso processo già in esecuzione sarà indipendente dalle altre. Inoltre, l'avvio può restituire un processo non Null con la relativa proprietà HasExited già impostata su true. In questo caso, è possibile che il processo avviato abbia attivato un'istanza esistente di se stesso e quindi sia terminato.

Attributi

CLSCompliantAttribute SupportedOSPlatformAttribute

Eccezioni

Esempio

L'esempio di codice seguente illustra l'uso di questo overload per avviare un file eseguibile e illustra anche la generazione di un Win32Exception oggetto quando viene eseguito un tentativo di avviare un'applicazione associata a un file non eseguibile.

// NOTE: This example requires a text.txt file file in your Documents folder
using System;
using System.Diagnostics;
using System.Security;
using System.ComponentModel;

class Example
{
    static void Main()
    {
        Console.Write("Enter your domain: ");
        string domain = Console.ReadLine();
        Console.Write("Enter you user name: ");
        string uname = Console.ReadLine();
        Console.Write("Enter your password: ");
        SecureString password = new SecureString();
        ConsoleKeyInfo key;
        do
        {
            key = Console.ReadKey(true);

            // Ignore any key out of range.
            if (((int)key.Key) >= 33 && ((int)key.Key <= 90) && key.Key != ConsoleKey.Enter)
            {
                // Append the character to the password.
                password.AppendChar(key.KeyChar);
                Console.Write("*");
            }
            // Exit if Enter key is pressed.
        } while (key.Key != ConsoleKey.Enter);
        Console.WriteLine();

        try
        {
            Console.WriteLine("\nTrying to launch NotePad using your login information...");
            Process.Start("notepad.exe", uname, password, domain);
        }
        catch (Win32Exception ex)
        {
            Console.WriteLine(ex.Message);
        }

        string path = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\\";

        try
        {
            // The following call to Start succeeds if test.txt exists.
            Console.WriteLine("\nTrying to launch 'text.txt'...");
            Process.Start(path + "text.txt");
        }
        catch (Win32Exception ex)
        {
            Console.WriteLine(ex.Message);
        }

        try
        {
            // Attempting to start in a shell using this Start overload fails. This causes
            // the following exception, which is picked up in the catch block below:
            // The specified executable is not a valid application for this OS platform.
            Console.WriteLine("\nTrying to launch 'text.txt' with your login information...");
            Process.Start(path + "text.txt", uname, password, domain);
        }
        catch (Win32Exception ex)
        {
            Console.WriteLine(ex.Message);
        }
        finally
        {
            password.Dispose();
        }
    }
}

' This sample requires a text.txt file file in your documents folder.
' You'll also need to set the startup object in the project to Sub Main.
Imports System.Diagnostics
Imports System.Security
Imports System.ComponentModel

Module Program
    Sub Main()
        Console.Write("Enter your domain: ")
        Dim domain As String = Console.ReadLine()
        Console.Write("Enter you user name: ")
        Dim uname As String = Console.ReadLine()
        Console.Write("Enter your password: ")
        Dim password As New SecureString()
        Dim key As ConsoleKeyInfo
        Do
            key = Console.ReadKey(True)

            ' Ignore any key out of range.
            If key.Key >= 33 AndAlso key.Key <= 90 AndAlso key.Key <> ConsoleKey.Enter Then
                ' Append the character to the password.
                password.AppendChar(key.KeyChar)
                Console.Write("*")
            End If
            ' Exit if Enter key is pressed.
        Loop While key.Key <> ConsoleKey.Enter
        Console.WriteLine()

        Try
            Console.WriteLine(vbCrLf + "Trying to launch NotePad using your login information...")
            Process.Start("notepad.exe", uname, password, domain)
        Catch ex As Win32Exception
            Console.WriteLine(ex.Message)
        End Try

        Dim path As String = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + "\"

        Try
            ' The following call to Start succeeds if test.txt exists.
            Console.WriteLine(vbCrLf + "Trying to launch 'text.txt'...")
            Process.Start(path + "Text.txt")
        Catch ex As Win32Exception
            Console.WriteLine(ex.Message)
        End Try

        Try
            ' Attempting to start in a shell using this Start overload fails. This causes
            ' the following exception, which is picked up in the catch block below:
            ' The specified executable is not a valid application for this OS platform.
            Console.WriteLine(vbCrLf + "Trying to launch 'text.txt' with your login information...")
            Process.Start(path + "Text.txt", uname, password, domain)
        Catch ex As Win32Exception
            Console.WriteLine(ex.Message)
        Finally
            password.Dispose()
        End Try
    End Sub
End Module

Commenti

Usare questo overload per creare un nuovo processo e il relativo thread primario specificando il nome del file, il nome utente, la password e il dominio. Il nuovo processo esegue quindi il file eseguibile specificato nel contesto di sicurezza delle credenziali specificate (utente, dominio e password).

Questo overload consente di avviare un processo senza prima creare una nuova Process istanza. L'overload è un'alternativa alla procedura esplicita di creazione di una nuova Process istanza, l'impostazione delle FileNameproprietà , UserNamePassword, e Domain della proprietà della StartInfo proprietà e la chiamata Start all'istanzaProcess.

Analogamente, nello stesso modo in cui la finestra di dialogo Esegui può accettare un nome di file eseguibile con o senza l'estensione .exe, l'estensione .exe è facoltativa nel fileName parametro. Ad esempio, è possibile impostare il fileName parametro su "Notepad.exe" o "Blocco note". Se il parametro rappresenta un file eseguibile, il fileNamearguments parametro potrebbe rappresentare un file da eseguire, ad esempio il file di testo in Notepad.exe myfile.txt.

Ogni volta che si usa Start per avviare un processo, potrebbe essere necessario chiuderlo o perdere risorse di sistema. Chiudere i processi usando CloseMainWindow o Kill. È possibile verificare se un processo è già stato chiuso usando la relativa HasExited proprietà.

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::String ^ arguments);

public static System.Diagnostics.Process Start (string fileName, string arguments);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start (string fileName, string arguments);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process Start (string fileName, string arguments);

static member Start : string * string -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * string -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : string * string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, arguments As String) As Process

Parametri

Restituisce

Nuovo Process associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato parallelamente a istanze dello stesso processo già in esecuzione sarà indipendente dalle altre. Inoltre, l'avvio può restituire un processo non Null con la relativa proprietà HasExited già impostata su true. In questo caso, è possibile che il processo avviato abbia attivato un'istanza esistente di se stesso e quindi sia terminato.

Attributi

UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Eccezioni

Esempio

Nell'esempio seguente viene prima generato un'istanza di Internet Explorer e viene visualizzato il contenuto della cartella Preferiti nel browser. Avvia quindi alcune altre istanze di Internet Explorer e visualizza alcune pagine o siti specifici. Infine avvia Internet Explorer con la finestra ridotta al minimo durante la navigazione in un sito specifico.

#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

Commenti

Usare questo overload per avviare una risorsa di processo specificando il nome del file e gli argomenti della riga di comando. L'overload associa la risorsa a un nuovo Process oggetto.

Questo overload consente di avviare un processo senza prima creare una nuova Process istanza. L'overload è un'alternativa alla procedura esplicita di creazione di una nuova Process istanza, l'impostazione e i FileNameArguments membri della StartInfo proprietà e la chiamata Start all'istanza Process .

L'avvio di un processo specificando il nome del file e gli argomenti è simile a quello di digitare il nome del file e gli argomenti della riga di comando nella Run finestra di dialogo del menu Di Windows Start . Pertanto, il nome del file non deve rappresentare un file eseguibile. Può essere di qualsiasi tipo di file per cui l'estensione è stata associata a un'applicazione installata nel sistema. Ad esempio, il nome del file può avere un'estensione .txt se sono stati associati file di testo con un editor, ad esempio Blocco note, oppure può avere un .doc se sono stati associati file .doc con uno strumento di elaborazione delle parole, ad esempio Microsoft Word. Analogamente, nello stesso modo in cui la finestra di dialogo può accettare un nome di file eseguibile con o senza l'estensione .exe, l'estensione Run .exe è facoltativa nel fileName parametro. Ad esempio, è possibile impostare il fileName parametro su "Notepad.exe" o "Blocco note". Se il parametro rappresenta un file eseguibile, il fileNamearguments parametro potrebbe rappresentare un file da eseguire, ad esempio il file di testo in Notepad.exe myfile.txt. Se il parametro rappresenta un file di comando (.cmd), il fileNamearguments parametro deve includere un argomento "" o "/c/k" per specificare se la finestra dei comandi viene chiusa o rimane dopo il completamento.

A differenza degli altri overload, l'overload di Start che non ha parametri non è un static membro. Usare tale overload quando è già stata creata un'istanza e le informazioni di avvio specificate (incluso il nome del file) e si vuole avviare una Process risorsa di processo e associarla all'istanza esistente Process . Usare uno degli static overload quando si vuole creare un nuovo Process componente anziché avviare un processo per un componente esistente. Sia questo overload che l'overload senza parametri consentono di specificare il nome file della risorsa del processo per avviare e passare gli argomenti della riga di comando.

Se si dispone di una variabile di percorso dichiarata nel sistema usando virgolette, è necessario qualificare completamente tale percorso quando si avvia qualsiasi processo trovato in tale posizione. In caso contrario, il sistema non troverà il percorso. Ad esempio, se c:\mypath non si trova nel percorso e lo si aggiunge usando virgolette: path = %path%;"c:\mypath", è necessario qualificare completamente qualsiasi processo durante c:\mypath l'avvio.

Ogni volta che si usa Start per avviare un processo, potrebbe essere necessario chiuderlo o perdere risorse di sistema. Chiudere i processi usando CloseMainWindow o Kill. È possibile verificare se un processo è già stato chiuso usando la relativa HasExited proprietà.

Una nota sugli stati dell'appartamento nei thread gestiti è necessaria qui. Quando UseShellExecute si trova true nella proprietà del StartInfo componente del processo, assicurarsi di aver impostato un modello di threading nell'applicazione impostando l'attributo [STAThread] sul main() metodo. In caso contrario, un thread gestito può essere in uno unknown stato o inserire nello stato, l'ultimo dei quali è in conflitto con UseShellExecute l'essere MTAtrue. Alcuni metodi richiedono che lo stato dell'appartamento non sia unknown. Se lo stato non è impostato in modo esplicito, quando l'applicazione rileva tale metodo, il valore predefinito MTAè , e una volta impostato, lo stato dell'appartamento non può essere modificato. Tuttavia, MTA causa la generazione di un'eccezione quando la shell del sistema operativo gestisce il thread.

Vedi anche

• FileName
• StartInfo
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName);

public static System.Diagnostics.Process Start (string fileName);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start (string fileName);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process Start (string fileName);

static member Start : string -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : string -> System.Diagnostics.Process

Public Shared Function Start (fileName As String) As Process

Parametri

Restituisce

Nuovo Process associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato parallelamente a istanze dello stesso processo già in esecuzione sarà indipendente dalle altre. Inoltre, l'avvio può restituire un processo non Null con la relativa proprietà HasExited già impostata su true. In questo caso, è possibile che il processo avviato abbia attivato un'istanza esistente di se stesso e quindi sia terminato.

Attributi

UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Eccezioni

Esempio

Nell'esempio seguente viene prima generato un'istanza di Internet Explorer e viene visualizzato il contenuto della cartella Preferiti nel browser. Avvia quindi alcune altre istanze di Internet Explorer e visualizza alcune pagine o siti specifici. Infine avvia Internet Explorer con la finestra ridotta al minimo durante la navigazione in un sito specifico.

#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

Commenti

Usare questo overload per avviare una risorsa di processo specificando il nome del file. L'overload associa la risorsa a un nuovo Process oggetto.

Questo overload consente di avviare un processo senza prima creare una nuova Process istanza. L'overload è un'alternativa alla procedura esplicita di creazione di una nuova Process istanza, l'impostazione del membro della StartInfo proprietà e la FileName chiamata Start all'istanzaProcess.

È possibile avviare un'applicazione ClickOnce impostando il fileName parametro sul percorso (ad esempio, un indirizzo Web) da cui è stata originariamente installata l'applicazione. Non avviare un'applicazione ClickOnce specificando il percorso installato nel disco rigido.

L'avvio di un processo specificando il nome del file è simile alla digitazione delle informazioni nella Run finestra di dialogo del menu di Windows Start . Pertanto, il nome del file non deve rappresentare un file eseguibile. Può essere di qualsiasi tipo di file per cui l'estensione è stata associata a un'applicazione installata nel sistema. Ad esempio, il nome del file può avere un'estensione .txt se sono stati associati file di testo con un editor, ad esempio Blocco note, oppure può avere un .doc se sono stati associati file .doc con uno strumento di elaborazione delle parole, ad esempio Microsoft Word. Analogamente, nello stesso modo in cui la finestra di dialogo può accettare un nome di file eseguibile con o senza l'estensione .exe, l'estensione Run .exe è facoltativa nel fileName parametro. Ad esempio, è possibile impostare il fileName parametro su "Notepad.exe" o "Blocco note".

Questo overload non consente argomenti della riga di comando per il processo. Se è necessario specificare uno o più argomenti della riga di comando per il processo, usare gli Process.Start(ProcessStartInfo) overload o Process.Start(String, String) .

A differenza degli altri overload, l'overload di Start che non ha parametri non è un static membro. Usare tale overload quando è già stata creata un'istanza e le informazioni di avvio specificate (incluso il nome del file) e si vuole avviare una Process risorsa di processo e associarla all'istanza esistente Process . Usare uno degli static overload quando si vuole creare un nuovo Process componente anziché avviare un processo per un componente esistente. Sia questo overload che l'overload senza parametri consentono di specificare il nome file della risorsa del processo da avviare.

Se si dispone di una variabile di percorso dichiarata nel sistema usando virgolette, è necessario qualificare completamente tale percorso quando si avvia qualsiasi processo trovato in tale posizione. In caso contrario, il sistema non troverà il percorso. Ad esempio, se c:\mypath non si trova nel percorso e lo si aggiunge usando virgolette: path = %path%;"c:\mypath", è necessario qualificare completamente qualsiasi processo durante c:\mypath l'avvio.

Ogni volta che si usa Start per avviare un processo, potrebbe essere necessario chiuderlo o perdere risorse di sistema. Chiudere i processi usando CloseMainWindow o Kill. È possibile verificare se un processo è già stato chiuso usando la relativa HasExited proprietà.

Una nota sugli stati dell'appartamento nei thread gestiti è necessaria qui. Quando UseShellExecute si trova true nella proprietà del StartInfo componente del processo, assicurarsi di aver impostato un modello di threading nell'applicazione impostando l'attributo [STAThread] sul main() metodo. In caso contrario, un thread gestito può essere in unknown uno stato o inserito nello stato , il secondo dei quali è in conflitto con UseShellExecute l'essere MTAtrue. Alcuni metodi richiedono che lo stato dell'apartment non sia unknown. Se lo stato non è impostato in modo esplicito, quando l'applicazione rileva tale metodo, per impostazione predefinita MTAè e una volta impostato, lo stato dell'apartment non può essere modificato. Tuttavia, MTA fa sì che venga generata un'eccezione quando la shell del sistema operativo gestisce il thread.

Vedi anche

• FileName
• StartInfo
• CloseMainWindow()
• Kill()

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

public:
 static System::Diagnostics::Process ^ Start(System::Diagnostics::ProcessStartInfo ^ startInfo);

public static System.Diagnostics.Process? Start (System.Diagnostics.ProcessStartInfo startInfo);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process? Start (System.Diagnostics.ProcessStartInfo startInfo);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process? Start (System.Diagnostics.ProcessStartInfo startInfo);

public static System.Diagnostics.Process Start (System.Diagnostics.ProcessStartInfo startInfo);

static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : System.Diagnostics.ProcessStartInfo -> System.Diagnostics.Process

Public Shared Function Start (startInfo As ProcessStartInfo) As Process

Parametri

Restituisce

Nuovo Process associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato parallelamente a istanze dello stesso processo già in esecuzione sarà indipendente dalle altre. Inoltre, l'avvio può restituire un processo non Null con la relativa proprietà HasExited già impostata su true. In questo caso, è possibile che il processo avviato abbia attivato un'istanza esistente di se stesso e quindi sia terminato.

Attributi

UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Eccezioni

Esempio

Nell'esempio seguente viene innanzitutto generato un'istanza di Internet Explorer e viene visualizzato il contenuto della cartella Preferiti nel browser. Avvia quindi alcune altre istanze di Internet Explorer e visualizza alcune pagine o siti specifici. Viene infine avviato Internet Explorer con la finestra ridotta a icona durante il passaggio a un sito specifico.

Per altri esempi di altri usi di questo metodo, vedere le singole proprietà della ProcessStartInfo classe .

#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

Commenti

Usare questo overload per avviare una risorsa di processo specificando un'istanza ProcessStartInfo di . L'overload associa la risorsa a un nuovo Process oggetto .

Questo overload consente di avviare un processo senza prima creare una nuova Process istanza. L'uso di questo overload con un ProcessStartInfo parametro è un'alternativa alla procedura esplicita di creazione di una nuova Process istanza, all'impostazione delle relative StartInfo proprietà e alla chiamata Start dell'istanza Process .

L'uso di un'istanza ProcessStartInfo come parametro consente di chiamare Start con il maggior controllo sugli elementi passati nella chiamata per avviare il processo. Se è necessario passare solo un nome file o un nome file e argomenti, non è necessario creare una nuova ProcessStartInfo istanza, anche se si tratta di un'opzione. L'unica Process.StartInfo proprietà che deve essere impostata è la FileName proprietà . La FileName proprietà non deve rappresentare un file eseguibile. Può essere di qualsiasi tipo di file per cui l'estensione è stata associata a un'applicazione installata nel sistema. Ad esempio, la FileName proprietà può avere un'estensione .txt se sono stati associati file di testo a un editor, ad esempio Blocco note, oppure può avere un'estensione .doc se sono stati associati file .doc a uno strumento di elaborazione delle parole, ad esempio Microsoft Word.

È possibile avviare un'applicazione ClickOnce specificando il percorso ,ad esempio un indirizzo Web, da cui è stata originariamente installata l'applicazione. Non avviare un'applicazione ClickOnce specificandone il percorso installato nel disco rigido.

Se vengono impostate le proprietà e ProcessStartInfo.Password dell'istanzaStartInfo, viene chiamata la funzione non gestitaCreateProcessWithLogonW, che avvia il processo in una nuova finestra anche se il valore della ProcessStartInfo.CreateNoWindow proprietà è true o il valore della ProcessStartInfo.WindowStyle proprietà è ProcessWindowStyle.Hidden.ProcessStartInfo.UserName Se la ProcessStartInfo.Domain proprietà è null, la ProcessStartInfo.UserName proprietà deve essere in formato UPN, l'utente@DNS_domain_name.

A differenza degli altri overload, l'overload di Start che non ha parametri non è un static membro. Usare l'overload quando è già stata creata un'istanza Process e sono state specificate le informazioni di avvio (incluso il nome del file) e si vuole avviare una risorsa di processo e associarla all'istanza esistente Process . Usare uno degli static overload quando si vuole creare un nuovo Process componente anziché avviare un processo per un componente esistente. Sia questo overload che l'overload senza parametri consentono di specificare le informazioni di avvio per la risorsa di processo usando un'istanza ProcessStartInfo di .

Se nel sistema è stata dichiarata una variabile di percorso usando le virgolette, è necessario qualificare completamente tale percorso all'avvio di qualsiasi processo trovato in tale posizione. In caso contrario, il sistema non troverà il percorso. Ad esempio, se c:\mypath non si trova nel percorso e lo si aggiunge usando virgolette: path = %path%;"c:\mypath", è necessario qualificare completamente qualsiasi processo in c:\mypath al momento dell'avvio.

Ogni volta che si usa Start per avviare un processo, potrebbe essere necessario chiuderlo o rischiare di perdere risorse di sistema. Chiudere i processi usando CloseMainWindow o Kill. È possibile verificare se un processo è già stato chiuso usando la relativa HasExited proprietà .

Una nota sugli stati apartment nei thread gestiti è necessaria qui. Quando UseShellExecute si trova true nel startInfo parametro , assicurarsi di aver impostato un modello di threading nell'applicazione impostando l'attributo [STAThread] nel main() metodo . In caso contrario, un thread gestito può essere in unknown uno stato o inserito nello stato , il secondo dei quali è in conflitto con UseShellExecute l'essere MTAtrue. Alcuni metodi richiedono che lo stato dell'apartment non sia unknown. Se lo stato non è impostato in modo esplicito, quando l'applicazione rileva tale metodo, per impostazione predefinita MTAè e una volta impostato, lo stato dell'apartment non può essere modificato. Tuttavia, MTA fa sì che venga generata un'eccezione quando la shell del sistema operativo gestisce il thread.

Vedi anche

• StartInfo
• FileName
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

public:
 bool Start();

public bool Start ();

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public bool Start ();

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public bool Start ();

member this.Start : unit -> bool

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
member this.Start : unit -> bool

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
member this.Start : unit -> bool

Public Function Start () As Boolean

Restituisce

true se viene avviata una risorsa di processo, false se non viene avviata alcuna risorsa di processo nuova (ad esempio, se è stato riutilizzato un processo esistente).

Attributi

UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Eccezioni

Esempio

Nell'esempio seguente viene utilizzata un'istanza della Process classe per avviare un processo.

#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

Commenti

Usare questo overload per avviare una risorsa di processo e associarla al componente corrente Process . Il valore true restituito indica che è stata avviata una nuova risorsa di processo. Se la risorsa di processo specificata dal FileName membro della StartInfo proprietà è già in esecuzione nel computer, non viene avviata alcuna risorsa di processo aggiuntiva. La risorsa del processo in esecuzione viene invece riutilizzata e false viene restituita.

È possibile avviare un'applicazione ClickOnce specificando il percorso ,ad esempio un indirizzo Web, da cui è stata originariamente installata l'applicazione. Non avviare un'applicazione ClickOnce specificandone il percorso installato nel disco rigido.

Questo overload di Start non è un static metodo. È necessario chiamarlo da un'istanza della Process classe . Prima di chiamare Start, è necessario specificare StartInfo le informazioni sulle proprietà per questa Process istanza, perché tali informazioni vengono usate per determinare la risorsa di processo da avviare.

Gli altri overload del Start metodo sono static membri. Non è necessario creare un'istanza del Process componente prima di chiamare gli overload del metodo . È invece possibile chiamare Start per la Process classe stessa e viene creato un nuovo Process componente se il processo è stato avviato. In alternativa, null viene restituito se un processo è stato riutilizzato. La risorsa di processo viene associata automaticamente al nuovo Process componente restituito dal Start metodo .

I StartInfo membri possono essere usati per duplicare la funzionalità della finestra di dialogo del Run menu di Windows Start . Qualsiasi elemento che può essere digitato in una riga di comando può essere avviato impostando i valori appropriati nella StartInfo proprietà. L'unica StartInfo proprietà che deve essere impostata è la FileName proprietà . La FileName proprietà non deve essere un file eseguibile. Può essere di qualsiasi tipo di file per cui l'estensione è stata associata a un'applicazione installata nel sistema. Ad esempio, la FileName proprietà può avere un'estensione .txt se sono stati associati file di testo con un editor, ad esempio Blocco note oppure può avere un'estensione .doc se sono stati associati file .doc con uno strumento di elaborazione delle parole, ad esempio Microsoft Word.

Nella riga di comando è possibile specificare le azioni da eseguire per determinati tipi di file. Ad esempio, è possibile stampare documenti o modificare i file di testo. Specificare queste azioni usando il Verb membro della StartInfo proprietà. Per altri tipi di file, è possibile specificare gli argomenti della riga di comando quando si avvia il file dalla Run finestra di dialogo. Ad esempio, è possibile passare un URL come argomento se si specifica il browser come FileName. Questi argomenti possono essere specificati nel StartInfo membro della Arguments proprietà.

Se si dispone di una variabile di percorso dichiarata nel sistema usando virgolette, è necessario qualificare completamente tale percorso quando si avvia qualsiasi processo trovato in tale posizione. In caso contrario, il sistema non troverà il percorso. Ad esempio, se c:\mypath non si trova nel percorso e lo si aggiunge usando virgolette: path = %path%;"c:\mypath", è necessario qualificare completamente qualsiasi processo durante c:\mypath l'avvio.

Ogni volta che si usa Start per avviare un processo, potrebbe essere necessario chiuderlo o perdere risorse di sistema. Chiudere i processi usando CloseMainWindow o Kill. È possibile verificare se un processo è già stato chiuso usando la relativa HasExited proprietà.

Una nota sugli stati dell'appartamento nei thread gestiti è necessaria qui. Quando UseShellExecute si trova true nella proprietà del StartInfo componente del processo, assicurarsi di aver impostato un modello di threading nell'applicazione impostando l'attributo [STAThread] sul main() metodo. In caso contrario, un thread gestito può essere in uno unknown stato o inserire nello stato, l'ultimo dei quali è in conflitto con UseShellExecute l'essere MTAtrue. Alcuni metodi richiedono che lo stato dell'appartamento non sia unknown. Se lo stato non è impostato in modo esplicito, quando l'applicazione rileva tale metodo, il valore predefinito MTAè , e una volta impostato, lo stato dell'appartamento non può essere modificato. Tuttavia, MTA causa la generazione di un'eccezione quando la shell del sistema operativo gestisce il thread.

Vedi anche

• StartInfo
• FileName
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

public:
 static System::Diagnostics::Process ^ Start(System::String ^ fileName, System::Collections::Generic::IEnumerable<System::String ^> ^ arguments);

public static System.Diagnostics.Process Start (string fileName, System.Collections.Generic.IEnumerable<string> arguments);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start (string fileName, System.Collections.Generic.IEnumerable<string> arguments);

[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
public static System.Diagnostics.Process Start (string fileName, System.Collections.Generic.IEnumerable<string> arguments);

static member Start : string * seq<string> -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * seq<string> -> System.Diagnostics.Process

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
[<System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")>]
static member Start : string * seq<string> -> System.Diagnostics.Process

Public Shared Function Start (fileName As String, arguments As IEnumerable(Of String)) As Process

Parametri

Restituisce

Nuovo Process associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo.

Attributi

UnsupportedOSPlatformAttribute SupportedOSPlatformAttribute

Commenti

Ogni argomento verrà eseguito automaticamente se necessario.