Jak przekazać argumenty wiersza poleceń do aplikacji WinForms?

Mam dwie różne aplikacje WinForms, AppA i AppB. Obydwa korzystają z platformy .NET 2.0.

W AppA chcę otworzyć AppB, ale muszę przekazać do niego argumenty wiersza poleceń. Jak wykorzystać argumenty, które przekazuję w wierszu poleceń?

To jest moja obecna główna metoda w AppB, ale nie sądzę, że możesz to zmienić?

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

Argumenty zostaną następnie zapisane w argstablicy ciągów:

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

Najlepszym sposobem pracy z argumentami w aplikacji winforms jest użycie

string[] args = Environment.GetCommandLineArgs();

Prawdopodobnie możesz to połączyć za pomocą wyliczenia, aby wzmocnić użycie tablicy w całym kodzie.

„Można go używać w dowolnym miejscu aplikacji, nie ogranicza się tylko do używania go w metodzie main (), jak w aplikacji konsolowej”.

Znalezione pod adresem: TUTAJ

Możesz pobrać wiersz poleceń dowolnej aplikacji .Net, uzyskując dostęp do właściwości Environment.CommandLine. Będzie miał wiersz poleceń jako pojedynczy ciąg, ale analiza danych, których szukasz, nie powinna być strasznie trudna.

Posiadanie pustej metody Main nie wpłynie na tę właściwość ani na zdolność innego programu do dodawania parametru wiersza polecenia.

Rozważ, że musisz opracować program, za pomocą którego musisz przekazać dwa argumenty. Przede wszystkim musisz otworzyć klasę Program.cs i dodać argumenty w metodzie Main jak poniżej i przekazać te argumenty do konstruktora formularza 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])));           
   }
}

W klasie formularzy systemu Windows dodaj sparametryzowany konstruktor, który akceptuje wartości wejściowe z klasy Program, jak poniżej.

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

Aby to przetestować, możesz otworzyć wiersz polecenia i przejść do lokalizacji, w której znajduje się ten plik exe. Podaj nazwę pliku, a następnie parmeter1 parametr2. Na przykład patrz poniżej

C:\MyApplication>Yourexename p10 5

Z powyższego kodu C # zostanie wyświetlony komunikat Messagebox z wartością p10 5.

Używasz tego podpisu: (w C #) static void Main (string [] args)

Ten artykuł może pomóc w wyjaśnieniu roli głównej funkcji również w programowaniu: http://en.wikipedia.org/wiki/Main_function_(programming)

Oto mały przykład dla Ciebie:

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

Może nie jest to popularne rozwiązanie dla wszystkich, ale podoba mi się Application Framework w Visual Basic, nawet gdy używam C #.

Dodaj odniesienie do Microsoft.VisualBasic

Utwórz klasę o nazwie 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);
    }

}

Zmodyfikuj swoją procedurę Main (), aby wyglądała tak

static class Program
{

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

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

Ta metoda oferuje dodatkowe przydatne funkcje (takie jak obsługa SplashScreen i niektóre przydatne zdarzenia)

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