Comment transmettre des arguments de ligne de commande à une application WinForms?

J'ai deux applications WinForms différentes, AppA et AppB. Les deux exécutent .NET 2.0.

Dans AppA, je veux ouvrir AppB, mais je dois lui passer des arguments de ligne de commande. Comment consommer les arguments que je passe en ligne de commande?

C'est ma méthode principale actuelle dans AppB, mais je ne pense pas que vous puissiez changer cela?

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

Les arguments seront ensuite stockés dans le argstableau de chaînes:

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

La meilleure façon de travailler avec des arguments pour votre application winforms est d'utiliser

string[] args = Environment.GetCommandLineArgs();

Vous pouvez probablement coupler cela avec l'utilisation d'une énumération pour solidifier l'utilisation du tableau dans toute votre base de code.

«Et vous pouvez l'utiliser n'importe où dans votre application, vous n'êtes pas seulement limité à l'utiliser dans la méthode main () comme dans une application console.»

Trouvé à: ICI

Vous pouvez récupérer la ligne de commande de n'importe quelle application .Net en accédant à la propriété Environment.CommandLine. Il aura la ligne de commande sous la forme d'une seule chaîne, mais l'analyse des données que vous recherchez ne devrait pas être très difficile.

Le fait d'avoir une méthode Main vide n'affectera pas cette propriété ou la capacité d'un autre programme à ajouter un paramètre de ligne de commande.

Considérez que vous devez développer un programme à travers lequel vous devez passer deux arguments. Tout d'abord, vous devez ouvrir la classe Program.cs et ajouter des arguments dans la méthode Main comme ci-dessous et passer ces arguments au constructeur du formulaire 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])));           
   }
}

Dans la classe Windows Form, ajoutez un constructeur paramétré qui accepte les valeurs d'entrée de la classe Program comme ci-dessous.

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

Pour tester cela, vous pouvez ouvrir l'invite de commande et aller à l'emplacement où cet exe est placé. Donnez le nom du fichier puis parmeter1 parameter2. Par exemple, voir ci-dessous

C:\MyApplication>Yourexename p10 5

À partir du code C # ci-dessus, il affichera une boîte de message avec une valeur p10 5.

Vous utilisez cette signature: (en c #) static void Main (string [] args)

Cet article peut également aider à expliquer le rôle de la fonction principale dans la programmation: http://en.wikipedia.org/wiki/Main_function_(programming)

Voici un petit exemple pour vous:

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

Cela n'est peut-être pas une solution populaire pour tout le monde, mais j'aime le Framework d'application dans Visual Basic, même lorsque vous utilisez C #.

Ajouter une référence à Microsoft.VisualBasic

Créer une classe appelée 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);
    }

}

Modifiez votre routine Main () pour qu'elle ressemble à ceci

static class Program
{

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

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

Cette méthode offre des fonctionnalités supplémentaires utiles (comme le support SplashScreen et certains événements utiles)

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