Argumenty wiersza poleceń w aplikacjach C# w niecałe 10 minut

Tim Corey

8m 46s

Podczas tworzenia nowoczesnych aplikacji w języku C# programiści często potrzebują elastyczności w zakresie sposobu uruchamiania i działania programów. Zamiast sztywnego kodowania każdej opcji, możesz uczynić swoją aplikację dynamiczną, umożliwiając użytkownikom przekazywanie argumentów wiersza poleceń podczas jej uruchamiania. Umożliwia to zarówno programistom, jak i użytkownikom podawanie parametrów wejściowych bezpośrednio z wiersza poleceń, dostosowując sposób działania aplikacji bez zmiany kodu.

W swoim zwięzłym, 10-minutowym samouczku zatytułowanym "Argumenty wiersza poleceń w aplikacjach C# w 10 minut lub mniej" Tim Corey jasno pokazuje, jak włączyć argumenty wiersza poleceń i skutecznie nimi zarządzać zarówno w aplikacjach konsolowych, jak i aplikacjach Windows Forms. W tym artykułe omówiono krok po kroku koncepcje wyjaśnione przez Tima.

Czym są argumenty wiersza poleceń?

Na początku Tim wyjaśnia, dlaczego argumenty wiersza poleceń mają znaczenie. Porównuje je do sposobu uruchamiania narzędzi takich jak Docker, gdzie określamy polecenia, np. jaki obraz załadować lub jakie zadanie wykonać. Podobnie w aplikacjach wiersza poleceń w języku C# można przekazywać parametry, które definiują zachowanie programu w czasie wykonywania.

Na przykład, jeśli uruchamiasz aplikację konsolową do przetwarzania plików, możesz chcieć określić ścieżkę lub tryb pliku poprzez wprowadzanie danych z wiersza poleceń — zamiast modyfikować kod.

Konfiguracja projektu konsolowego

Tim rozpoczyna pracę w Visual Studio od podstawowego projektu aplikacji konsolowej .NET 8. Domyślny kod PRINTuje jedynie komunikat typu "Naciśnij klawisz Return, aby wyjść", wykorzystując instrukcję Console.ReadLine(), aby przed zamknięciem poczekać na wprowadzenie danych przez użytkownika.

Aby obsłużyć dane wejściowe z wiersza poleceń, Tim wprowadza tablicę args, która przechowuje argumenty przekazane do aplikacji podczas jej uruchomienia. Chociaż nowoczesne aplikacje konsolowe w języku C# używają instrukcji najwyższego poziomu, w tle nadal mają punkt wejścia zdefiniowany jako:

static void Main(string[] args)

static void Main(string[] args)

Sub Main(args As String())

Sub Main(args As String())

lub czasami:

static int Main(string[] args)

static int Main(string[] args)

Shared Function Main(ByVal args() As String) As Integer

Shared Function Main(ByVal args() As String) As Integer

Te sygnatury reprezentują metodę główną – punkt wejścia, w którym rozpoczyna się wykonywanie. Parametr args to tablica ciągów (string[]), zawierająca wszystkie argumenty podane z wiersza poleceń.

Tim pokazuje iterację nad tablicą args przy użyciu pętli foreach:

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

foreach (var arg in args)
{
    Console.WriteLine(arg);
}

For Each arg In args
    Console.WriteLine(arg)
Next

For Each arg In args
    Console.WriteLine(arg)
Next

W tym przypadku var arg reprezentuje każdy argument typu string w tablicy args, a program wyświetla je w osobnych wierszach w konsoli.

Tim zauważa, że chociaż instrukcje najwyższego poziomu ukrywają standardowy kod, taki jak klasa Program i metoda Main, wszystko nadal działa tak samo — tablica args jest zawsze dostępna i gotowa do przechwytywania argumentów wiersza poleceń.

Uruchamianie aplikacji konsolowej

Następnie Tim pokazuje, jak przetestować tę funkcję. Uruchomienie programu w normalny sposób w Visual Studio nie spowoduje wyświetlenia żadnych zmian, ponieważ nie podano żadnych danych wejściowych w wierszu poleceń.

Aby przeprowadzić prawidłowe testy, ręcznie modyfikuje proces wykonywania: otwiera Eksploratora plików, przechodzi do folderu bin → Debug → net8.0 projektu i uruchamia okno terminala z tej ścieżki.

Następnie używa następującego polecenia:

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

ConsoleArgs.exe "hello world" -t timing

To polecenie ilustruje kilka kluczowych kwestii:

• Cytowane "hello world" traktowane jest jako jeden argument typu string, a nie jako dwa oddzielne słowa.

• Flaga -t i słowo timing są traktowane jako dwa dodatkowe argumenty.

Po uruchomieniu na konsoli wyświetla się:

hello world  
-t  
timing

hello world  
-t  
timing

hello world  
-t  
timing

hello world  
-t  
timing

Każdy argument linii reprezentuje jeden element w tablicy args. Tim wyjaśnia, że potwierdza to prawidłowe użycie argumentów wiersza poleceń — aplikacja konsolowa pomyślnie odebrała i wyświetliła wszystkie argumenty przekazane podczas wykonywania.

Wspomina, że programiści mogą również używać .NET run zamiast ścieżki wykonywalnej podczas uruchamiania z katalogu projektu:

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

dotnet run -- "hello world" -t timing

Podwójny myślnik (--) informuje platformę .NET, aby traktowała wszystko, co znajduje się po nim, jako parametry wiersza poleceń dla danego programu, a nie dla samego interfejsu CLI platformy .NET.

Obsługa i analizowanie argumentów wiersza poleceń

Teraz, gdy potrafimy już odczytywać argumenty, Tim omawia inteligentne obsługiwanie argumentów wiersza poleceń.

Na przykład, jeśli -t jest flagą, która oczekuje wartości, program musi wiedzieć, że następny argument typu string jest jej wartością. Tim pokazuje, że można to ręcznie przeanalizować, sprawdzając indeksy w tablicy args:

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

for (int i = 0; i < args.Length; i++)
{
    if (args[i] == "-t")
    {
        var value = args[i + 1];
        Console.WriteLine($"Timing parameter: {value}");
    }
}

For i As Integer = 0 To args.Length - 1
    If args(i) = "-t" Then
        Dim value = args(i + 1)
        Console.WriteLine($"Timing parameter: {value}")
    End If
Next

For i As Integer = 0 To args.Length - 1
    If args(i) = "-t" Then
        Dim value = args(i + 1)
        Console.WriteLine($"Timing parameter: {value}")
    End If
Next

Takie podejście pozwala obsługiwać argumenty nazwane, typy numeryczne, a nawet flagi trybu rozbudowanego. Tim zauważa, że programiści często używają instrukcji switch, a nawet zewnętrznej dokumentacji i bibliotek do bardziej zaawansowanego parsowania argumentów, ale przestrzeń nazw System i tablica args zapewniają już wszystko, co jest potrzebne w podstawowych przypadkach.

Rozszerzenie na aplikację Windows Forms

Po zaprezentowaniu aplikacji konsolowych Tim przechodzi do aplikacji Windows Forms (WinForms).

W wygenerowanym kodzie plik Program.cs zawiera metodę static void Main(), ale nie przyjmuje ona jeszcze parametrów. Aby włączyć argumenty wiersza poleceń, Tim ręcznie modyfikuje metodę Main, dodając do niej parametr args:

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

[STAThread]
static void Main(string[] args)
{
    ApplicationConfiguration.Initialize();
    Application.Run(new Form1(args.FirstOrDefault() ?? "default"));
}

<STAThread>
Shared Sub Main(args As String())
    ApplicationConfiguration.Initialize()
    Application.Run(New Form1(If(args.FirstOrDefault(), "default")))
End Sub

<STAThread>
Shared Sub Main(args As String())
    ApplicationConfiguration.Initialize()
    Application.Run(New Form1(If(args.FirstOrDefault(), "default")))
End Sub

Wyjaśnia, że args.FirstOrDefault() pobiera pierwszy parametr wejściowy z tablicy args (lub zwraca "default", jeśli nie podano żadnego argumentu).

Następnie, w klasie Form1, Tim aktualizuje konstruktor, aby akceptował argument typu string:

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

public Form1(string name)
{
    InitializeComponent();
    displayName.Text = name;
}

Public Sub New(name As String)
    InitializeComponent()
    displayName.Text = name
End Sub

Public Sub New(name As String)
    InitializeComponent()
    displayName.Text = name
End Sub

W tym przypadku displayName jest etykietą zdefiniowaną w Windows Forms Designer i wyświetla teraz argument przekazany przez wiersz poleceń.

Gdy uruchamia program bez argumentów, etykieta wyświetla "default". Gdy uruchamia go ponownie z:

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

WinFormsArgs.exe "Hello World"

W oknie formularza wyświetla się komunikat "Hello World".

Tim wyjaśnia, że technika ta pozwala aplikacjom Windows Forms obsługiwać argumenty wiersza poleceń, podobnie jak aplikacje konsolowe — dając użytkownikom możliwość dynamicznej zmiany zachowania podczas uruchamiania.

Praktyczne zastosowania argumentów wiersza poleceń (7:18)

Na zakończenie Tim omawia, jak wszechstronne mogą stać się narzędzia wiersza poleceń dzięki tej funkcji. Programiści mogą używać argumentów wiersza poleceń do:

• Uruchamiaj aplikacje w różnych trybach (na przykład* tryb ciemny vs tryb jasny*).

• Podaj ścieżki do plików lub opcje konfiguracyjne podczas uruchamiania.

• Włącz tryb szczegółowy lub funkcje debugowania za pomocą prostych przełączników, takich jak -v lub --debug.

• Utwórz skróty, które przekazują określone argumenty dla różnych przepływów pracy.

Projektując główną metodę tak, aby akceptowała argumenty typu string, można w łatwy sposób zwiększyć elastyczność i możliwości adaptacyjne aplikacji — bez konieczności stosowania dodatkowych okien dialogowych do wprowadzania danych przez użytkownika lub plików konfiguracyjnych.

Podsumowanie (8:15)

Jego wyjaśnienie oparte na przykładach pokazuje, że obsługa argumentów wiersza poleceń w języku C# nie jest skomplikowana — chodzi po prostu o zrozumienie, że każda aplikacja ma punkt wejścia (Main), do którego argumenty przekazane z wiersza poleceń docierają jako tablica ciągów znaków.

Niezależnie od tego, czy pracujesz z aplikacjami konsolowymi, czy aplikacjami Windows Forms, ta koncepcja umożliwia Twoim programom dynamiczne reagowanie na polecenia, wartości i parametry określone podczas uruchamiania.

Podsumowanie

Film Tima Coreya stanowi przejrzysty, praktyczny przewodnik po prawidłowym użyciu argumentów wiersza poleceń w języku C#. Dzięki zrozumieniu działania parametru args w metodzie Main programiści mogą z łatwością tworzyć, analizować i wykorzystywać argumenty w celu uzyskania bardziej niezawodnych i konfigurowalnych aplikacji.

Kiedy więc następnym razem będziesz tworzyć projekt w języku C#, pamiętaj, że argumenty wiersza poleceń to nie tylko techniczna składnia — to pomost między Twoim programem a jego użytkownikami, który nadaje Twojemu kodowi większą moc, elastyczność i praktyczną użyteczność.