c# args parameter

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

Question

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

En AppA, quiero abrir AppB, pero necesito pasarle argumentos de línea de comando. ¿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 cambiar esto?

  static void main()
  {
  }

Answer 1

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 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 de programa como 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 y dirigirse a la ubicación donde se encuentra este exe. Indique el nombre del archivo y luego el parámetro parmeter1. Por ejemplo, ver a continuación

C:/MyApplication>Yourexename p10 5

Desde el código C # de arriba, aparecerá un Messagebox con el valor p10 5 .

Answer 2

La mejor forma de trabajar con args para tu aplicación de winforms es usar

string[] args = Environment.GetCommandLineArgs();

Probablemente pueda unir esto con el uso de una enumeración para solidificar el uso de la matriz a través de su base de código.

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

Encontrado en: HERE

Answer 3

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

Agregue una referencia a Microsoft.VisualBasic

Crea 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 características útiles adicionales (como el soporte de 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;

Answer 4

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ás buscando no debería ser terriblemente difícil.

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

Answer 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í hay un pequeño ejemplo para ti:

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

Answer 6

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

Los argumentos se almacenarán en la matriz de cadenas args :

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