Wie übergebe ich Befehlszeilenargumente an eine WinForms-Anwendung?

Ich habe zwei verschiedene WinForms-Anwendungen, AppA & AppB. Auf beiden wird .NET 2.0 ausgeführt.

In AppA möchte ich AppB öffnen, muss aber Befehlszeilenargumente übergeben. Wie verwende ich die Argumente, die ich in der Befehlszeile übergebe?

Dies ist meine aktuelle Hauptmethode in AppB, aber ich glaube nicht, dass Sie dies ändern können?

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

Die Argumente werden dann im argsString-Array gespeichert :

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

Der beste Weg, um mit Argumenten für Ihre Winforms-App zu arbeiten, ist die Verwendung

string[] args = Environment.GetCommandLineArgs();

Sie können dies wahrscheinlich mit der Verwendung einer Aufzählung koppeln , um die Verwendung des Arrays in Ihrer Codebasis zu festigen.

"Und Sie können dies überall in Ihrer Anwendung verwenden. Sie müssen es nicht nur in der main () -Methode wie in einer Konsolenanwendung verwenden."

Gefunden bei: HIER

Sie können die Befehlszeile jeder .NET-Anwendung abrufen, indem Sie auf die Eigenschaft Environment.CommandLine zugreifen. Die Befehlszeile wird als einzelne Zeichenfolge angezeigt, aber das Parsen der gesuchten Daten sollte nicht besonders schwierig sein.

Eine leere Main-Methode hat keine Auswirkungen auf diese Eigenschaft oder die Fähigkeit eines anderen Programms, einen Befehlszeilenparameter hinzuzufügen.

Stellen Sie sich vor, Sie müssen ein Programm entwickeln, über das Sie zwei Argumente übergeben müssen. Zunächst müssen Sie die Program.cs- Klasse öffnen und wie unten in der Main- Methode Argumente hinzufügen und diese Argumente an den Konstruktor des Windows-Formulars übergeben.

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

Fügen Sie in der Windows-Formularklasse einen parametrisierten Konstruktor hinzu, der die Eingabewerte der Programmklasse wie folgt akzeptiert .

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

Um dies zu testen, können Sie die Eingabeaufforderung öffnen und zu dem Speicherort gehen, an dem sich diese Exe befindet. Geben Sie den Dateinamen und dann parmeter1 parameter2 an. Zum Beispiel siehe unten

C:\MyApplication>Yourexename p10 5

Aus dem obigen C # -Code wird eine Messagebox mit Wert angezeigt p10 5.

Sie verwenden diese Signatur: (in c #) static void Main (string [] args)

Dieser Artikel kann auch dazu beitragen, die Rolle der Hauptfunktion bei der Programmierung zu erläutern: http://en.wikipedia.org/wiki/Main_function_(programming)

Hier ist ein kleines Beispiel für Sie:

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

Dies ist möglicherweise nicht für alle eine beliebte Lösung, aber ich mag das Application Framework in Visual Basic, selbst wenn C # verwendet wird.

Fügen Sie einen Verweis auf hinzu Microsoft.VisualBasic

Erstellen Sie eine Klasse mit dem Namen 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);
    }

}

Ändern Sie Ihre Main () - Routine so, dass sie so aussieht

static class Program
{

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

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

Diese Methode bietet einige zusätzliche nützliche Funktionen (wie SplashScreen-Unterstützung und einige nützliche Ereignisse).

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