Complete Guide to Command Line Arguments in C# (With Examples)

Introduction: Understanding Command Line Arguments in C#

In C#, command line arguments offer a simple yet powerful way to pass information into your console applications during execution. They allow you to customize the program behavior without changing the source code, making your applications more flexible and dynamic.

In this guide, we’ll cover everything you need to know about accessing, parsing, and handling command line arguments in C# with clear examples.

1. Accessing Command Line Arguments

Command line arguments are accessed through the args parameter of the Main method. The args array contains all the arguments passed to the program when it is launched.

Each argument is stored as a string in the array.
args[0] is typically the first user-provided argument (not the program name).

Example: Accessing Arguments

static void Main(string[] args)
{
    // Accessing command line arguments
    string firstArgument = args[0];
    string secondArgument = args[1];

    Console.WriteLine("First Argument: " + firstArgument);
    Console.WriteLine("Second Argument: " + secondArgument);
}

2. Providing Command Line Arguments

When running your application, you can provide arguments directly after the program name in the terminal or command prompt.

Example: Passing Arguments

> MyConsoleApp.exe argument1 argument2

In the program:

args[0] will be "argument1".
args[1] will be "argument2".

Tip: In Visual Studio, you can also set command line arguments under Project Properties → Debug → Application Arguments.

3. Handling Different Numbers of Arguments

Since users may provide varying numbers of arguments, it's important to check the number of arguments before accessing them to avoid errors.

You can use args.Length to verify how many arguments were passed.

Example: Handling Variable Arguments

static void Main(string[] args)
{
    if (args.Length >= 2)
    {
        string firstArgument = args[0];
        string secondArgument = args[1];
        Console.WriteLine("Processing: " + firstArgument + " and " + secondArgument);
    }
    else
    {
        Console.WriteLine("Insufficient arguments provided.");
    }
}

4. Parsing Command Line Arguments

Since all command line arguments are passed as strings, you may need to convert them into the appropriate data types for further processing.

Use methods like int.Parse, double.Parse, bool.Parse, or Convert.ToXxx for type conversion.

Example: Parsing an Integer Argument

static void Main(string[] args)
{
    int number = int.Parse(args[0]);
    Console.WriteLine("Parsed number: " + number);
}

Important: Always ensure proper error handling when parsing user input.

5. Handling Invalid Command Line Arguments

User-provided arguments may be missing or incorrectly formatted. To prevent your application from crashing, use exception handling with try-catch blocks.

Example: Safe Parsing with Error Handling

static void Main(string[] args)
{
    try
    {
        int value = int.Parse(args[0]);
        Console.WriteLine("Value entered: " + value);
    }
    catch (FormatException)
    {
        Console.WriteLine("Invalid argument format. Please enter a valid number.");
    }
    catch (IndexOutOfRangeException)
    {
        Console.WriteLine("Insufficient arguments provided. Please provide at least one argument.");
    }
}

In this example:

FormatException is caught if the input can't be parsed into an integer.
IndexOutOfRangeException is caught if no arguments were provided.

Conclusion: Enhance Your Applications with Command Line Arguments

Using command line arguments in C# makes your console applications more versatile and user-configurable without needing to alter the code. By learning to access, parse, and safely handle user input, you can create dynamic and robust programs that adapt to user needs at runtime.

Always remember to:

Validate the number of arguments.
Parse input carefully.
Implement proper error handling to ensure a smooth user experience.

Mastering command line arguments will take your console applications to the next level!

Complete Guide to Command Line Arguments in C# (With Examples)