¿Cómo paso argumentos de la línea de comandos a una aplicación WinForms?

Tengo dos aplicaciones WinForms diferentes, AppA y AppB. Ambos ejecutan .NET 2.0.

En AppA quiero abrir AppB, pero necesito pasarle argumentos de línea de comandos. ¿Cómo consumo los argumentos que paso en la línea de comando?

Este es mi método principal actual en AppB, pero no creo que puedas cambiarlo.

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

Luego, los argumentos se almacenarán en la argsmatriz de cadenas:

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

La mejor manera de trabajar con argumentos para su aplicación winforms es usar

string[] args = Environment.GetCommandLineArgs();

Probablemente pueda combinar esto con el uso de una enumeración para solidificar el uso de la matriz a lo largo de su base de código.

"Y puede usar esto en cualquier lugar de su aplicación, no está restringido a usarlo en el método main () como en una aplicación de consola".

Encontrado en: AQUÍ

Puede tomar la línea de comando de cualquier aplicación .Net accediendo a la propiedad Environment.CommandLine. Tendrá la línea de comando como una sola cadena, pero analizar los datos que está buscando no debería ser muy difícil.

Tener un método Main vacío no afectará esta propiedad ni la capacidad de otro programa para agregar un parámetro de línea de comando.

Considere que necesita desarrollar un programa a través del cual necesita pasar dos argumentos. En primer lugar, debe abrir la clase Program.cs y agregar argumentos en el método Main como se muestra a continuación y pasar estos argumentos al constructor del formulario de 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])));           
   }
}

En la clase de formulario de Windows, agregue un constructor parametrizado que acepte los valores de entrada de la clase Program como se muestra a continuación.

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

Para probar esto, puede abrir el símbolo del sistema e ir a la ubicación donde se encuentra este exe. Dé el nombre del archivo y luego parmeter1 parameter2. Por ejemplo, vea a continuación

C:\MyApplication>Yourexename p10 5

Desde el código C # anterior, aparecerá un cuadro de mensaje con valor p10 5.

Usas esta firma: (en c #) static void Main (string [] args)

Este artículo también puede ayudar a explicar el papel de la función principal en la programación: http://en.wikipedia.org/wiki/Main_function_(programming)

Aquí tienes un pequeño ejemplo:

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

Puede que esta no sea una solución popular para todos, pero me gusta Application Framework en Visual Basic, incluso cuando uso C #.

Agregar una referencia a Microsoft.VisualBasic

Cree una clase llamada 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 su rutina Main () para que se vea así

static class Program
{

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

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

Este método ofrece algunas funciones útiles adicionales (como compatibilidad con SplashScreen y algunos eventos útiles)

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