Introduction
Building useful console applications often requires structured logging, configuration management, and dependency injection. The .NET Generic Host framework provides a powerful foundation to enable these features. Let’s explore how to use GenericHost in a C# console application, with a specific focus on creating a simple command-line parser. This parser will interpret and reprint command parameters while leveraging logging, configuration, and dependency injection.
Benefits of Using GenericHost
- Structured Initialization: Provides a systematic approach to initialize applications.
- Unified Approach: Consistent setup for both console and web applications.
- Extensibility: Easily integrates various libraries and custom configurations.
Step-by-Step Guide
Step 1: Setting Up the Project
First, create a new console application. You can do this using the .NET CLI or Visual Studio.
dotnet new console -n CommandLineParserApp
cd CommandLineParserApp
Step 2: Adding Required NuGet Packages
To use GenericHost, add the Microsoft.Extensions.Hosting package. Additionally, add packages for logging and configuration.
dotnet add package Microsoft.Extensions.Hosting
dotnet add package Microsoft.Extensions.Logging
dotnet add package Microsoft.Extensions.Configuration
dotnet add package Microsoft.Extensions.Configuration.Json
Step 3: Creating the Host
The core of a GenericHost application is the Host class, which initializes and runs the application. Here’s how to set it up:
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;
namespace CommandLineParserApp
{
class Program
{
static async Task Main(string[] args)
{
var host = Host.CreateDefaultBuilder(args)
.ConfigureServices((context, services) =>
{
services.AddSingleton<ICommandLineParser, CommandLineParser>();
})
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddConsole();
})
.Build();
var parser = host.Services.GetRequiredService<ICommandLineParser>();
parser.Parse(args);
await host.RunAsync();
}
}
public interface ICommandLineParser
{
void Parse(string[] args);
}
public class CommandLineParser : ICommandLineParser
{
private readonly ILogger<CommandLineParser> _logger;
public CommandLineParser(ILogger<CommandLineParser> logger)
{
_logger = logger;
}
public void Parse(string[] args)
{
if (args.Length == 0)
{
_logger.LogInformation("No command line arguments provided.");
return;
}
_logger.LogInformation("Parsing command line arguments:");
for (int i = 0; i < args.Length; i++)
{
_logger.LogInformation($"Argument {i + 1}: {args[i]}");
}
}
}
}
Step 4: Adding Configuration
To support configuration, add a JSON configuration file named appsettings.json in the project root with some settings:
{
"Logging": {
"LogLevel": {
"Default": "Information"
}
}
}Update the host builder to include this configuration:
.ConfigureAppConfiguration((context, config) =>
{
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
})
Step 5: Implementing Dependency Injection
In the ConfigureServices method, register your services with the dependency injection container:
.ConfigureServices((context, services) =>
{
services.AddSingleton<ICommandLineParser, CommandLineParser>();
})
Step 6: Enabling Logging
Configure logging in the ConfigureLogging method to use the console provider and set the log level:
.ConfigureLogging(logging =>
{
logging.ClearProviders();
logging.AddConsole();
logging.SetMinimumLevel(LogLevel.Information);
})
Step 7: Running the Application
When you run the application, it will initialize the host, set up logging, configuration, and dependency injection, and then execute the Parse method of the CommandLineParser class.
dotnet run -- arg1 arg2 arg3
Example Output
When you run the application with command-line arguments, you should see log messages indicating the parsed arguments:
info: CommandLineParserApp.CommandLineParser[0]
Parsing command line arguments:
info: CommandLineParserApp.CommandLineParser[0]
Argument 1: arg1
info: CommandLineParserApp.CommandLineParser[0]
Argument 2: arg2
info: CommandLineParserApp.CommandLineParser[0]
Argument 3: arg3
Detailed Explanation
The Host Class
The Host class manages the application’s lifecycle. It provides services for logging, configuration, and dependency injection, which are configured in the CreateHostBuilder method.
Configuration
Configuration is set up using the ConfigureAppConfiguration method. In this example, we add the appsettings.json to the configuration sources, allowing us to manage settings in a structured and flexible manner, common to how its done in WebApp/WebApi.
Dependency Injection
Dependency injection is a design pattern that helps achieve Inversion of Control (IoC) between classes and their dependencies. In the ConfigureServices method, we register services with the IoC container, making them available for injection throughout the application.
Logging
Logging is configured using the ConfigureLogging method. Here, we set the minimum log level to Information, ensuring that information, warning, and error messages are written to the console.
Extending the Application
Let’s extend the command-line parser to support more advanced features like handling different types of arguments and options.
Adding Advanced Argument Parsing
Update the ICommandLineParser interface and CommandLineParser class to support options and flags:
public interface ICommandLineParser
{
void Parse(string[] args);
}
public class CommandLineParser : ICommandLineParser
{
private readonly ILogger<CommandLineParser> _logger;
public CommandLineParser(ILogger<CommandLineParser> logger)
{
_logger = logger;
}
public void Parse(string[] args)
{
if (args.Length == 0)
{
_logger.LogInformation("No command line arguments provided.");
return;
}
_logger.LogInformation("Parsing command line arguments:");
for (int i = 0; i < args.Length; i++)
{
if (args[i].StartsWith("--"))
{
var option = args[i].Substring(2);
_logger.LogInformation($"Option: {option}");
}
else if (args[i].StartsWith("-"))
{
var flag = args[i].Substring(1);
_logger.LogInformation($"Flag: {flag}");
}
else
{
_logger.LogInformation($"Argument {i + 1}: {args[i]}");
}
}
}
}
</code>
Example Usage
Run the application with different types of arguments:
dotnet run -- arg1 -f --option value
Example Output
info: CommandLineParserApp.CommandLineParser[0]
Parsing command line arguments:
info: CommandLineParserApp.CommandLineParser[0]
Argument 1: arg1
info: CommandLineParserApp.CommandLineParser[0]
Flag: f
info: CommandLineParserApp.CommandLineParser[0]
Option: option
info: CommandLineParserApp.CommandLineParser[0]
Argument 2: value
Conclusion
Using the GenericHost in a C# console application provides a flexible foundation for building robust applications. By leveraging built-in features like logging, configuration, and dependency injection, you can create maintainable console applications. The provided example demonstrates the ease of setting up and extending a console application using GenericHost, making it a valuable tool for developers working on various types of projects.
DarthPedro's Blog 