Come si passano gli argomenti della riga di comando a un'applicazione WinForms?

Ho due diverse applicazioni WinForms, AppA e AppB. Entrambi eseguono .NET 2.0.

In AppA voglio aprire AppB, ma devo passarvi gli argomenti della riga di comando. Come utilizzo gli argomenti che passo nella riga di comando?

Questo è il mio attuale metodo principale in AppB, ma non credo che tu possa cambiarlo?

  static void main()
  {
  }

static void Main(string[] args)
{
  // For the sake of this example, we're just printing the arguments to the console.
  for (int i = 0; i < args.Length; i++) {
    Console.WriteLine("args[{0}] == {1}", i, args[i]);
  }
}

Gli argomenti verranno quindi memorizzati nella argsmatrice di stringhe:

$ AppB.exe firstArg secondArg thirdArg
args[0] == firstArg
args[1] == secondArg
args[2] == thirdArg

Il modo migliore per lavorare con args per la tua app winforms è usare

string[] args = Environment.GetCommandLineArgs();

Probabilmente puoi accoppiarlo con l'uso di un enum per consolidare l'uso dell'array in tutta la tua base di codice.

"E puoi usarlo ovunque nella tua applicazione, non sei limitato a usarlo nel metodo main () come in un'applicazione console."

Trovato su: QUI

È possibile prendere la riga di comando di qualsiasi applicazione .Net accedendo alla proprietà Environment.CommandLine. Avrà la riga di comando come una singola stringa, ma analizzare i dati che stai cercando non dovrebbe essere terribilmente difficile.

Avere un metodo Main vuoto non influirà su questa proprietà o sulla capacità di un altro programma di aggiungere un parametro della riga di comando.

Considera che devi sviluppare un programma attraverso il quale devi passare due argomenti. Prima di tutto, è necessario aprire la classe Program.cs e aggiungere argomenti nel metodo Main come di seguito e passare questi argomenti al costruttore del form di Windows.

static class Program
{    
   [STAThread]
   static void Main(string[] args)
   {            
       Application.EnableVisualStyles();
       Application.SetCompatibleTextRenderingDefault(false);
       Application.Run(new Form1(args[0], Convert.ToInt32(args[1])));           
   }
}

Nella classe del modulo di Windows, aggiungi un costruttore parametrizzato che accetta i valori di input dalla classe Program come di seguito.

public Form1(string s, int i)
{
    if (s != null && i > 0)
       MessageBox.Show(s + " " + i);
}

Per testarlo, puoi aprire il prompt dei comandi e andare nella posizione in cui si trova questo exe. Assegnare il nome del file quindi parmeter1 parametro2. Ad esempio, vedi sotto

C:\MyApplication>Yourexename p10 5

Dal codice C # sopra, verrà richiesto un Messagebox con valore p10 5.

Usa questa firma: (in c #) static void Main (string [] args)

Questo articolo può aiutare a spiegare anche il ruolo della funzione principale nella programmazione: http://en.wikipedia.org/wiki/Main_function_(programming)

Ecco un piccolo esempio per te:

class Program
{
    static void Main(string[] args)
    {
        bool doSomething = false;

        if (args.Length > 0 && args[0].Equals("doSomething"))
            doSomething = true;

        if (doSomething) Console.WriteLine("Commandline parameter called");
    }
}

Questa potrebbe non essere una soluzione popolare per tutti, ma mi piace Application Framework in Visual Basic, anche quando si usa C #.

Aggiungi un riferimento a Microsoft.VisualBasic

Crea una classe chiamata WindowsFormsApplication

public class WindowsFormsApplication : WindowsFormsApplicationBase
{

    /// <summary>
    /// Runs the specified mainForm in this application context.
    /// </summary>
    /// <param name="mainForm">Form that is run.</param>
    public virtual void Run(Form mainForm)
    {
        // set up the main form.
        this.MainForm = mainForm;

        // Example code
        ((Form1)mainForm).FileName = this.CommandLineArgs[0];

        // then, run the the main form.
        this.Run(this.CommandLineArgs);
    }

    /// <summary>
    /// Runs this.MainForm in this application context. Converts the command
    /// line arguments correctly for the base this.Run method.
    /// </summary>
    /// <param name="commandLineArgs">Command line collection.</param>
    private void Run(ReadOnlyCollection<string> commandLineArgs)
    {
        // convert the Collection<string> to string[], so that it can be used
        // in the Run method.
        ArrayList list = new ArrayList(commandLineArgs);
        string[] commandLine = (string[])list.ToArray(typeof(string));
        this.Run(commandLine);
    }

}

Modifica la tua routine Main () in questo modo

static class Program
{

    [STAThread]
    static void Main()
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);

        var application = new WindowsFormsApplication();
        application.Run(new Form1());
    }
}

Questo metodo offre alcune funzionalità utili aggiuntive (come il supporto SplashScreen e alcuni eventi utili)

public event NetworkAvailableEventHandler NetworkAvailabilityChanged;d.
public event ShutdownEventHandler Shutdown;
public event StartupEventHandler Startup;
public event StartupNextInstanceEventHandler StartupNextInstance;
public event UnhandledExceptionEventHandler UnhandledException;