Como posso passar argumentos de linha de comando para um aplicativo WinForms?

Eu tenho dois aplicativos WinForms diferentes, AppA e AppB. Ambos estão executando o .NET 2.0.

No AppA, desejo abrir o AppB, mas preciso passar argumentos de linha de comando para ele. Como faço para consumir os argumentos que passo na linha de comando?

Este é meu método principal atual no AppB, mas não acho que você pode mudar isso.

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

Os argumentos serão armazenados na argsmatriz da string:

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

A melhor maneira de trabalhar com args para seu aplicativo winforms é usar

string[] args = Environment.GetCommandLineArgs();

Você provavelmente pode acoplar isso ao uso de um enum para solidificar o uso do array em toda a sua base de código.

"E você pode usar isso em qualquer lugar em seu aplicativo, você não está apenas restrito a usá-lo no método main () como em um aplicativo de console."

Encontrado em: AQUI

Você pode obter a linha de comando de qualquer aplicativo .Net acessando a propriedade Environment.CommandLine. Ele terá a linha de comando como uma única string, mas analisar os dados que você está procurando não deve ser terrivelmente difícil.

Ter um método Main vazio não afetará essa propriedade ou a capacidade de outro programa de adicionar um parâmetro de linha de comando.

Considere que você precisa desenvolver um programa por meio do qual precisa passar dois argumentos. Em primeiro lugar, você precisa abrir a classe Program.cs e adicionar argumentos no método Main como mostrado abaixo e passar esses argumentos para o construtor do formulário do 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])));           
   }
}

Na classe de formulário do Windows, adicione um construtor parametrizado que aceita os valores de entrada da classe de programa como abaixo.

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

Para testar isso, você pode abrir o prompt de comando e ir para o local onde este exe está colocado. Dê o nome do arquivo e parmeter1 parâmetro2. Por exemplo, veja abaixo

C:\MyApplication>Yourexename p10 5

A partir do código C # acima, ele solicitará uma caixa de mensagem com valor p10 5.

Você usa esta assinatura: (em c #) static void Main (string [] args)

Este artigo também pode ajudar a explicar a função da função principal na programação: http://en.wikipedia.org/wiki/Main_function_(programming)

Aqui está um pequeno exemplo para você:

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

Esta pode não ser uma solução popular para todos, mas eu gosto do Application Framework em Visual Basic, mesmo quando uso C #.

Adicione uma referência a Microsoft.VisualBasic

Crie uma classe chamada 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);
    }

}

Modifique sua rotina Main () para ficar assim

static class Program
{

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

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

Este método oferece alguns recursos úteis adicionais (como suporte a SplashScreen e alguns eventos úteis)

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