C#-Befehlszeilenargumente

In C# beginnt die Programmausführung mit der main()-Methode. Die main()-Methode akzeptiert keine Argumente von anderen Methoden, akzeptiert jedoch Argumente, die ihr vom Benutzer über die Befehlszeile übergeben werden. Diese Argumente werden als Befehlszeilenargumente bezeichnet. Im Folgenden finden Sie einige wichtige Punkte zu Befehlszeilenargumenten in C#:

• Die main()-Methode akzeptiert Argumente, die vom Benutzer in einem Array vom Typ Strings übergeben werden.
• Es akzeptiert Argumente während der Ausführung des Programms.
• Benutzer können diese Argumente vom Typ String mithilfe der Convert-Klasse oder der Parse()-Methode in andere Typen in C# konvertieren.

Syntax mit Erklärung

Die Syntax der Main()-Methode, die Befehlszeilenargumente entgegennimmt, lautet wie folgt:

static void Main(string[] args)
{
//user code
}

In der obigen Syntax ist „static“ das Schlüsselwort, das angibt, dass die Main()-Methode ohne Instanz ausgeführt werden kann. „void“ ist der Rückgabetyp. „Main“ gibt an, dass dies unsere Main()-Methode des Programms ist, und „string[]“ ist der Typ der an die Methode übergebenen Argumente. „args“ ist der benutzerdefinierte Name, der den Argumenten gegeben wird.

Wie funktioniert das Befehlszeilenargument in C#?

Befehlszeilenargumente werden als Array von Typzeichenfolgen an die Main()-Methode übergeben, sodass wir beim Ausführen unseres Programms n Parameter übergeben können.

Beispiel:

public static void Main(string[] args)
{
//user code
}

Wenn wir die Parameter an die obige Main()-Methode übergeben, werden sie von der Variablen „args“ erfasst, einem Array vom Typ „String“. Dann können wir über die Indexposition auf das einzelne Argument aus diesem Array zugreifen.

Zuvor hat jedes übergebene Element den Typ „String“, der später mithilfe der Convert-Klasse oder der von C# bereitgestellten Parse()-Methode in den erforderlichen Datentyp geändert werden kann, wie in den folgenden Beispielen gezeigt:

long num = long.Parse(args[0]);

Die obige Anweisung konvertiert das an der Indexnummer 0 vorhandene Argument mithilfe der Parse()-Methode in einen äquivalenten „long“-Wert und speichert es dann in der Variablen „num“, die vom Typ „long“ ist.

int num = Convert.ToInt32(args[1]);

Diese Anweisung konvertiert das an Indexnummer 1 vorhandene Argument in eine entsprechende 32-Bit-Ganzzahl mit Vorzeichen und speichert es dann in der Variablen „num“, die vom Typ „int“ ist.

Wir können auch die Existenz der Befehlszeilenargumente überprüfen, d. h. um zu überprüfen, ob die Argumente an die Main()-Methode übergeben werden oder nicht, indem wir die Eigenschaft „Length“ verwenden, wie unten gezeigt:

if (args.Length > 0)
{
System.Console.WriteLine("Arguments passed");
}
else
{
System.Console.WriteLine("Arguments are not passed");
}

Um bei einer Windows Forms-Anwendung Befehlszeilenargumente in der Main()-Methode zu aktivieren, müssen wir die Signatur der Main()-Methode in der Datei „program.cs“ ändern. Dies liegt daran, dass der Windows Forms-Designer den Code generiert, der die Main()-Methode ohne Eingabeparameter enthält.

Wenn Sie im Visual Studio mit C# arbeiten, gibt es eine gute Möglichkeit, Befehlszeilenargumente für eine Main()-Methode im Visual Studio einzugeben. Im Folgenden finden Sie einige Schritte hierfür:

1. Klicken Sie mit der rechten Maustaste auf Ihr Projekt, das die main()-Methode des Projektmappen-Explorers enthält.
2. Klicken Sie auf „Eigenschaften“
3. Gehen Sie im Eigenschaftenfenster zur Registerkarte „Debuggen“
4. In Debug wird es ein Textfeld mit der Aufschrift „Befehlszeilenargumente“ geben.

In dieses Textfeld können wir Befehlszeilenargumente eingeben, die jeweils durch ein Leerzeichen getrennt sind. Nachfolgend finden Sie den Screenshot desselben:

Beispiele für C#-Befehlszeilenargumente

Verschiedene Beispiele sind unten aufgeführt:

Beispiel #1

Nehmen Sie beispielsweise zehn ganze Zahlen als Eingabe des Benutzers über Befehlszeilenargumente und prüfen Sie, ob diese Zahlen ungerade und gerade sind.

Code:

using System;
using System.IO;
using System.Collections.Generic;
namespace ConsoleApp4
{
class Program
{
public static void Main(string[] args)
{
List<int> evenArray = new List<int>();
List<int> oddArray = new List<int>();
try
{
//checking if any argument exists
if (args.Length == 0)
{
Console.WriteLine("Please enter numbers to check for odd even!");
return;
}
//accessing arguments using for loop
for (int i = 0; i < args.Length; i++)
{
//checking for odd and even
if ((Convert.ToInt32(args[i]) % 2) == 0)
{
evenArray.Add(Convert.ToInt32(args[i]));
}
else
{
oddArray.Add(Convert.ToInt32(args[i]));
}
}
//displaying all the numbers entered
Console.WriteLine("Numbers entered:");
for (int i = 0; i < args.Length; i++)
{
Console.WriteLine(args[i]);
}
//displaying even numbers entered
Console.WriteLine("\nEven numbers: ");
for (int i = 0; i < evenArray.Count; i++)
{
Console.WriteLine(evenArray[i]);
}
//displaying odd numbers entered
Console.WriteLine("\nOdd numbers: ");
for (int i = 0; i < oddArray.Count; i++)
{
Console.WriteLine(oddArray[i]);
}
Console.ReadLine();
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}

Ausgabe:

Der Screenshot mit dem Befehl zum Ausführen des obigen Programms mit eingegebenen Eingaben und empfangener Ausgabe lautet wie folgt:

Beispiel #2

Zum Beispiel das Übernehmen einer Zahl vom Benutzer über die Befehlszeile und das Berechnen ihrer Fakultät.

Code:

using System;
using System.IO;
using System.Collections.Generic;
namespace ConsoleApp4
{
class Program
{
public static void Main(string[] args)
{
int number;
int factorial;
try
{
//checking if any argument exists
if (args.Length == 0)
{
Console.WriteLine("Please enter a number to calculate " +
"its factorial!");
return;
}
if(args.Length > 1)
{
Console.WriteLine("Please enter only one number.");
return;
}
Console.WriteLine("The number entered is: " + args[0]);
number = Convert.ToInt32(args[0]);
factorial = number;
//calculating factorial of number using 'for' loop
for(int i = number - 1; i >= 1; i--)
{
factorial = factorial * i;
}
Console.WriteLine("Factorial of {0} is {1}: ", args[0], factorial);
Console.ReadLine();
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
}

Ausgabe:

Der Screenshot mit dem Befehl zum Ausführen des oben genannten Programms mit der eingegebenen Nummer und der empfangenen Ausgabe lautet wie folgt:

Hinweis: Wir haben die beiden oben genannten Programme mit der „Entwickler-Eingabeaufforderung für VS 2019“ ausgeführt. Wir können diese Programme auch aus Visual Studio ausführen, indem wir Befehlszeilenargumente über das Textfeld „Befehlszeilenargumente“ in der Option „Debug“ von Visual Studio bereitstellen.

Fazit

Befehlszeilenargumente sind Parameter, die vom Benutzer über die Befehlszeile an die Main()-Methode des Programms übergeben werden. Der Benutzer gibt diese Argumente während der Ausführung des Programms ein. Diese Argumente werden von der Main()-Methode in einem Array vom Typ Strings empfangen.

Das obige ist der detaillierte Inhalt vonC#-Befehlszeilenargumente. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!