Process.Start Metodo

Origine:

Process.Unix.cs

Origine:

Process.Unix.cs

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

Process Nuovo associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato insieme alle istanze già in esecuzione dello stesso processo sarà indipendente dagli altri. Inoltre, Start può restituire un processo non Null con la relativa HasExited proprietà già impostata su true. In questo caso, il processo avviato potrebbe aver attivato un'istanza esistente di se stessa e quindi chiusa.

Attributi

CLSCompliantAttribute SupportedOSPlatformAttribute

Eccezioni

Commenti

Usare questo overload per creare un nuovo processo e il relativo thread primario specificando il nome 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 ai passaggi espliciti di creazione di una nuova Process istanza, l'impostazione delle FileNameproprietà , PasswordUserNameArguments, , e Domain della proprietà della proprietà e la StartInfo chiamata Start per l'istanza Process di .

Analogamente, allo 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 fileName parametro rappresenta un file eseguibile, il arguments parametro potrebbe rappresentare un file su cui agire, 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 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à .

Origine:

Process.Unix.cs

Origine:

Process.Unix.cs

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

Process Nuovo associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato insieme alle istanze già in esecuzione dello stesso processo sarà indipendente dagli altri. Inoltre, Start può restituire un processo non Null con la relativa HasExited proprietà già impostata su true. In questo caso, il processo avviato potrebbe aver attivato un'istanza esistente di se stessa e quindi chiusa.

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

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

printf "Enter your domain: "
let domain = stdin.ReadLine()
printf "Enter you user name: "
let uname = stdin.ReadLine()
printf "Enter your password: "
let password = new SecureString()

let mutable key = Console.ReadKey(true)

while key.Key <> ConsoleKey.Enter do
    // Ignore any key out of range.
    if int key.Key >= 33 && int key.Key <= 90 && key.Key <> ConsoleKey.Enter then
        // Append the character to the password.
        password.AppendChar key.KeyChar
        Console.Write "*"

    key <- Console.ReadKey(true)

printfn ""

try
    printfn "\nTrying to launch NotePad using your login information..."
    Process.Start("notepad.exe", uname, password, domain) |> ignore
with :? Win32Exception as ex ->
    printfn $"{ex.Message}"

let path = Environment.GetFolderPath Environment.SpecialFolder.MyDocuments + @"\"

try
    // The following call to Start succeeds if test.txt exists.
    printfn "\nTrying to launch 'text.txt'..."
    Process.Start $"{path}text.txt" |> ignore
with :? Win32Exception as ex ->
    printfn $"{ex.Message}"

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.
        printfn "\nTrying to launch 'text.txt' with your login information..."
        Process.Start($"{path}text.txt", uname, password, domain) |> ignore
    with :? Win32Exception as ex ->
        printfn $"{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 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 ai passaggi espliciti di creazione di una nuova Process istanza, l'impostazione delle FileNameproprietà , UserNamePassword, e Domain della proprietà della proprietà e la StartInfo chiamata Start per l'istanza Process di .

Analogamente, allo 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 fileName parametro rappresenta un file eseguibile, il arguments parametro potrebbe rappresentare un file su cui agire, 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 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à .

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

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

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start(string fileName, 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.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * string -> System.Diagnostics.Process

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

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

Parametri

Restituisce

Process Nuovo associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato insieme alle istanze già in esecuzione dello stesso processo sarà indipendente dagli altri. Inoltre, Start può restituire un processo non Null con la relativa HasExited proprietà già impostata su true. In questo caso, il processo avviato potrebbe aver attivato un'istanza esistente di se stessa e quindi chiusa.

Attributi

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

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 a icona mentre si passa a un sito specifico.

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

Commenti

Usare questo overload per avviare una risorsa di processo specificando il nome 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 ai passaggi espliciti di creazione di una nuova Process istanza, dell'impostazione dei FileName membri e Arguments della proprietà e della StartInfo chiamata Start per l'istanza Process di .

L'avvio di un processo specificando il nome file e gli argomenti è simile alla digitazione del nome file e degli argomenti della Run riga di comando nella 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 a un editor, ad esempio blocco note, oppure può avere un .doc se sono stati associati .doc file con uno strumento di elaborazione delle parole, ad esempio Microsoft Word. Analogamente, allo stesso modo in cui la Run finestra di dialogo 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 fileName parametro rappresenta un file eseguibile, il arguments parametro potrebbe rappresentare un file su cui agire, ad esempio il file di testo in Notepad.exe myfile.txt. Se il fileName parametro rappresenta un file di comando (.cmd), il arguments parametro deve includere un argomento "/c" o "/k" per specificare se la finestra di comando viene chiusa o rimane dopo il completamento.

A differenza degli altri overload, l'overload di che non dispone di Start parametri non è un static membro. Usare tale 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 il nome file della risorsa di processo da avviare e gli argomenti della riga di comando da passare.

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 è presente nel percorso e lo si aggiunge usando le 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 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à .

Qui è necessaria una nota sugli stati apartment nei thread gestiti. Quando UseShellExecute si trova true nella proprietà del componente di processo, assicurarsi di avere impostato un modello di StartInfo threading nell'applicazione impostando l'attributo [STAThread] sul main() metodo . In caso contrario, un thread gestito può trovarsi in uno unknown stato o inserire nello stato , il secondo dei quali è in conflitto con l'essere UseShellExecuteMTAtrue. 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, per impostazione predefinita è e una volta impostata MTA, 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
• ProcessStartInfo
• CloseMainWindow()
• Kill()

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

Origine:

Process.cs

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

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

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

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

Public Shared Function Start (fileName As String) As Process

Parametri

Restituisce

Process Nuovo associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato insieme alle istanze già in esecuzione dello stesso processo sarà indipendente dagli altri. Inoltre, Start può restituire un processo non Null con la relativa HasExited proprietà già impostata su true. In questo caso, il processo avviato potrebbe aver attivato un'istanza esistente di se stessa e quindi chiusa.

Attributi

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

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 a icona mentre si passa a un sito specifico.

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

Commenti

Usare questo overload per avviare una risorsa di processo specificandone il nome 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 ai passaggi espliciti di creazione di una nuova Process istanza, dell'impostazione FileName del membro della StartInfo proprietà e della chiamata Start per l'istanza Process .

È 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 specificandone 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 a un editor, ad esempio blocco note, oppure può avere un .doc se sono stati associati .doc file con uno strumento di elaborazione delle parole, ad esempio Microsoft Word. Analogamente, allo stesso modo in cui la Run finestra di dialogo 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".

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 che non dispone di Start parametri non è un static membro. Usare tale 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 il nome file della risorsa di processo da avviare.

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 è presente nel percorso e lo si aggiunge usando le 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 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à .

Qui è necessaria una nota sugli stati apartment nei thread gestiti. Quando UseShellExecute si trova true nella proprietà del componente di processo, assicurarsi di avere impostato un modello di StartInfo threading nell'applicazione impostando l'attributo [STAThread] sul main() metodo . In caso contrario, un thread gestito può trovarsi in uno unknown stato o inserire nello stato , il secondo dei quali è in conflitto con l'essere UseShellExecuteMTAtrue. 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, per impostazione predefinita è e una volta impostata MTA, 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

Origine:

Process.cs

Origine:

Process.cs

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

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
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);

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

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

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

Public Shared Function Start (startInfo As ProcessStartInfo) As Process

Parametri

Restituisce

Process Nuovo associato alla risorsa di processo o null se non viene avviata alcuna risorsa di processo. Si noti che un nuovo processo avviato insieme alle istanze già in esecuzione dello stesso processo sarà indipendente dagli altri. Inoltre, Start può restituire un processo non Null con la relativa HasExited proprietà già impostata su true. In questo caso, il processo avviato potrebbe aver attivato un'istanza esistente di se stessa e quindi chiusa.

Attributi

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

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 a icona mentre si passa a un sito specifico.

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

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

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 ai passaggi espliciti per la creazione di una nuova Process istanza, l'impostazione StartInfo delle relative proprietà e la chiamata Start per l'istanza Process .

L'uso di un'istanza ProcessStartInfo come parametro consente di chiamare Start con il maggior controllo su ciò che viene passato 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 questa è 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 .doc file con 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 che non dispone di Start parametri non è un static membro. Usare tale 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 è presente nel percorso e lo si aggiunge usando le 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 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à .

Qui è necessaria una nota sugli stati apartment nei thread gestiti. 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ò trovarsi in uno unknown stato o inserire nello stato , il secondo dei quali è in conflitto con l'essere UseShellExecuteMTAtrue. 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, per impostazione predefinita è e una volta impostata MTA, 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

Origine:

Process.cs

Origine:

Process.cs

public:
 bool Start();

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

public bool Start();

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

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

member this.Start : unit -> bool

[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
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 nuova risorsa di processo, ad esempio se viene riutilizzato un processo esistente.

Attributi

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Eccezioni

Esempio

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

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

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

open System.Diagnostics

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

Imports System.Diagnostics
Imports System.ComponentModel

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

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

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 . In alternativa, è 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 utilizzati per duplicare la funzionalità della Run finestra di dialogo del 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 a un editor, ad esempio Blocco note, oppure può avere un'estensione .doc se sono stati associati .doc file 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 file di testo. Specificare queste azioni usando il Verb membro della StartInfo proprietà . Per altri tipi di file, è possibile specificare 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 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 è presente nel percorso e lo si aggiunge usando le 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 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à .

Qui è necessaria una nota sugli stati apartment nei thread gestiti. Quando UseShellExecute si trova true nella proprietà del componente di processo, assicurarsi di avere impostato un modello di StartInfo threading nell'applicazione impostando l'attributo [STAThread] sul main() metodo . In caso contrario, un thread gestito può trovarsi in uno unknown stato o inserire nello stato , il secondo dei quali è in conflitto con l'essere UseShellExecuteMTAtrue. 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, per impostazione predefinita è e una volta impostata MTA, 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

Origine:

Process.cs

Origine:

Process.cs

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

[System.Runtime.Versioning.SupportedOSPlatform("maccatalyst")]
[System.Runtime.Versioning.UnsupportedOSPlatform("ios")]
[System.Runtime.Versioning.UnsupportedOSPlatform("tvos")]
public static System.Diagnostics.Process Start(string fileName, System.Collections.Generic.IEnumerable<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.SupportedOSPlatform("maccatalyst")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("ios")>]
[<System.Runtime.Versioning.UnsupportedOSPlatform("tvos")>]
static member Start : string * seq<string> -> System.Diagnostics.Process

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

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

Parametri

Restituisce

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

Attributi

SupportedOSPlatformAttribute UnsupportedOSPlatformAttribute

Commenti

Ogni argomento verrà preceduto automaticamente da escape, se necessario.