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

106

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()
  {
  }
MRFerocius
la source

Réponses:

118
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
Thomas
la source
6
entrée: "n'importe quel.exe -v foo / lol nisp". Sortie: args [0] = "-v"; args [1] = "toto"; args [2] = "/ lol"; args [3] = "nisp"; Qu'est-ce qui pourrait être plus facile?
Callum Rogers
Je ne peux pas croire que j'ai vu ce «string [] args» tant de fois après une année entière et il ne m'est jamais arrivé que ce fût jusqu'à maintenant! haha
Niklas
1
Il semble que args [0] est le chemin complet et le nom exe de l'application en cours d'exécution et args [1] est le premier paramètre.
Allan F
197

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

Hannibul33
la source
25
Le premier élément du tableau contient le nom de fichier du programme en cours d'exécution. Si le nom de fichier n'est pas disponible, le premier élément est égal à String.Empty. Les éléments restants contiennent tous les jetons supplémentaires saisis sur la ligne de commande.
EKanadily
@docesam Cela m'a beaucoup aidé, merci! Se demandait pourquoi il essayait de charger le programme lui-même sous forme de texte.
Kaitlyn
Après des années de développement C #, je n'ai jamais su que cette méthode existait. Agréable.
CathalMF
1
y a-t-il un avantage à utiliser cette méthode par rapport à l'envoi des paramètres main(string[] args)?
Ajuster le
12

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.

JaredPar
la source
26
Ou utilisez Environment.GetCommandLineArgs () qui retourne un tableau de chaînes d'arguments tout comme Main (string [] args)
Brettski
11

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.

Sarath Avanavu
la source
7

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");
    }
}
Chrisghardwick
la source
4

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;
Jürgen Steinblock
la source