web-dev-qa-db-fra.com

Comment passer 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 souhaite ouvrir AppB, mais je dois lui transmettre des arguments de ligne de commande. Comment utiliser les arguments que je passe en ligne de commande?

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

  static void main()
  {
  }
c#winformscommand-line
90
MRFerocius
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 alors stockés dans le tableau de chaînes args:

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

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

string[] args = Environment.GetCommandLineArgs();

Vous pouvez probablement coupler cela avec l'utilisation d'un enum pour solidifier l'utilisation du tableau dans votre base de code.

"Et vous pouvez l’utiliser n'importe où dans votre application, vous n'êtes pas simplement obligé de l'utiliser dans la méthode main () comme dans une application console."

Trouvé à: ICI

171
Hannibul33

Vous pouvez récupérer la ligne de commande de toute application .Net en accédant à la propriété Environment.CommandLine. La ligne de commande sera 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é ni la capacité d'un autre programme d'ajouter un paramètre de ligne de commande.

12
JaredPar

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, puis les transmettre 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 de formulaire Windows, ajoutez un constructeur paramétré qui accepte les valeurs d'entrée de la classe Programme comme ci-dessous.

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

Pour tester cela, vous pouvez ouvrir la commande Invite et aller à l'emplacement où ce fichier EXE est placé. Donnez le nom du fichier puis parmeter1 paramètre2. Par exemple, voir ci-dessous

C:\MyApplication>Yourexename p10 5

À partir du code C # ci-dessus, une invite Messagebox de valeur p10 5.

9
Sarath Avanavu

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

Cela n’est peut-être pas une solution populaire pour tout le monde, mais j’aime bien le cadre d’application dans Visual Basic, même avec C #.

Ajouter une référence à Microsoft.VisualBasic

Créez 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 ressembler à 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 utiles supplémentaires (telles que la prise en charge de 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;
4
Jürgen Steinblock