Pass command-line arguments to Startup class in ASP.NET Core

Question

I have arguments passed in via the command-line

private static int Main(string[] args)
{
    const string PORT = "12345"    ;

    var listeningUrl = $"http://localhost:{PORT}";

    var builder = new WebHostBuilder()
        .UseStartup<Startup>()
        .UseKestrel()
        .UseUrls(listeningUrl);

    var host = builder.Build();
    WriteLine($"Running on {PORT}");
    host.Run();

    return 0;
}

One of these arguments is a logging output directory. How do I get this value into my Startup class so I can write out to this directory when I receive a request?

I'd like to avoid using a static class. Would a service that supplies the value be the right way? If so, how do I get services injected into my middleware?

DavidG · Accepted Answer · 2017-07-20T16:46:21.677

41

You should be able to use the AddCommandLine() extension. First install the Nuget package Microsoft.Extensions.Configuration.CommandLine and ensure you have the correct import:

using Microsoft.Extensions.Configuration;

Now update your Main method to include the new config:

var config = new ConfigurationBuilder()
    .AddJsonFile("hosting.json", optional: true) //this is not needed, but could be useful
    .AddCommandLine(args)
    .Build();

var builder = new WebHostBuilder()
    .UseConfiguration(config)  //<-- Add this
    .UseStartup<Startup>()
    .UseKestrel()
    .UseUrls(listeningUrl);

Now you treat the command line options as configuration:

dotnet run /MySetting:SomeValue=123

And read in code:

var someValue = Configuration.GetValue<int>("MySetting:SomeValue");

edited Jul 20 '17 at 16:46

answered Jul 20 '17 at 16:20

DavidG

113,891
12
217
223

Great! Do you know what Nuget package it live in? – BanksySan Jul 20 '17 at 16:30
Aye, sounds reasonable but it's not in there. – BanksySan Jul 20 '17 at 16:31
1

I've got that, got a `using Microsoft.Extensions.Configuration.CommandLine;` at the top but still no `AddCommandLine` method. – BanksySan Jul 20 '17 at 16:33
Package manager claims it is `1.1.2`: `Successfully installed 'Microsoft.Extensions.Configuration.CommandLine 1.1.2'` – BanksySan Jul 20 '17 at 16:34
I actually have both. – BanksySan Jul 20 '17 at 16:35
Thanks. I'll keep having a poke about, might be a VS caching something type thing. – BanksySan Jul 20 '17 at 16:38
Oh hang on, I was slightly wrong, look here https://learn.microsoft.com/en-us/aspnet/core/fundamentals/hosting#overriding-configuration – DavidG Jul 20 '17 at 16:39
Is `Configuration` here a property on the `Startup` class? I can't find it in any assemblies. – BanksySan Jul 20 '17 at 17:45
Oh, I assumed you already had that. You need to inject it. Take a look here https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration – DavidG Jul 20 '17 at 17:51
The eamples on here have the configuration being build in the `Startup` class rather than the `Program`. – BanksySan Jul 20 '17 at 17:53
This function doesn't exist for me even with the package installed. I have Host.CreateDefaultBuilder() method – Ciaran Gallagher Jun 16 '20 at 15:40
Does that also work for command line flags, like `--debug` or `--verbose`? If so, how? – mbx Sep 02 '21 at 14:23
Regarding to `Microsoft.Extensions.Hosting.Host.CreateDefaultBuilder` use the `ConfigureHostConfiguration` method in order to create the configuration builder. – Péter Szilvási Feb 10 '22 at 09:49

score 25 · Answer 2 · edited Jun 05 '20 at 18:19

Dotnet Core 2

You don't need most of the code as in dotnet core 1.0 to achieve this. AddCommandLinearguments are automatically injected when you BuildWebHost using the following syntax

Step 1.

public static IWebHost BuildWebHost(string[] args)
{
    return WebHost.CreateDefaultBuilder(args)
                  .UseStartup<Startup>()
                  .Build();
}

Step 2. Inject configurations to Startup.cs using DI using the following code

public class Startup
{
    private readonly IConfiguration Configuration;

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    ...

}

Step 3. Access your arguments using configurations object.

var seed = Configuration.GetValue<bool>("seed");
Console.WriteLine($"seed: {seed}");

Step 4. Start application with arguments

dotnet run seed=True

score 12 · Answer 3 · answered Apr 19 '18 at 04:46

ASP.NET Core 2 answer:

Change the default Program.cs to be:

using System;
using System.IO;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;

public class Program
{
    public static void Main(string[] args)
    {
        BuildWebHost(args).Run();
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .ConfigureAppConfiguration((hostingContext, config) =>
            {
                config.SetBasePath(Directory.GetCurrentDirectory());
                config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                      .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", optional: true, reloadOnChange: true);
                config.AddEnvironmentVariables();
                config.AddCommandLine(args);
            })
            .UseStartup<Startup>()
            .Build();
}

I removed other bits just to make the configuration explanation easier.

Note the .AddCommandLine(args) line in the configuration builder.

Unlike @BanksySan's answer you DON'T need to create a static property, instead let DI inject the IConfiguration into the startup class.

public class Startup
{
    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    private IConfiguration Configuration { get; }

You can now use the configuration entries from any of the config providers, file, env variables and commandline.

Example:

dotnet run --seed true

    public void Configure(IApplicationBuilder app)
    {
        app.UseExceptionHandler("/Home/Error");

        var seed = Configuration.GetValue<bool>("seed");
        if (seed)
            SeedData.Initialize(app);

        app.UseStaticFiles();
        app.UseMvcWithDefaultRoute();
    }

Hope this helps someone further.

I was able to do the same thing on my Worker.cs class too for when hosting ASP.NET Core in a Windows Service - adding a constructor that takes in the IConfiguration object worked there too. — Ciaran Gallagher, Jun 17 '20 at 08:48

score 6 · Answer 4 · answered Jul 20 '17 at 18:29

DavidG's answer is correct, but there were still some pieces of the puzzle missing for me.

There are two Nuget packages you need:

Microsoft.Extensions.Configuration.Binder
Microsoft.Extensions.Configuration.CommandLine

Because we want the command line arguments, we need to create the configuration in the Main(string[]).

using Microsoft.Extensions.Configuration;

class Program
{
    private static int Main(string[] args)
    {
        const string PORT = "12345";

        var listeningUrl = $"http://localhost:{PORT}";
        var configuration = new ConfigurationBuilder()
                            .AddCommandLine(args)
                            .Build();
        // Set the `static` `Configuration` property on the `Startup` class.
        Startup.Configuration = configuration;

        var builder = new WebHostBuilder()
            .UseStartup<Startup>()
            .UseKestrel()
            .UseSetting("Message", "Hello World")
            .UseUrls(listeningUrl);

        var host = builder.Build();
        WriteLine($"Running on {listeningUrl}");
        host.Run();

        return SUCCESS_EXIT_CODE;
    }
}

The Startup class is:

using Microsoft.Extensions.Configuration;

public class Startup
{
    public static IConfiguration Configuration { get; set; }


    public void Configure(IApplicationBuilder app)
    {
        foreach (var c in Configuration.AsEnumerable())
            Console.WriteLine($"{c.Key,-15}:{c.Value}");
    }
}

Is the command argument are --port 6000 outputDirectory C:\Temp then this will output:

port            :6000
outputDirectory :C:\Temp

Also in Microsoft Docs: https://learn.microsoft.com/en-us/aspnet/core/fundamentals/configuration/?tabs=basicconfiguration#setup-and-use-the-commandline-configuration-provider — Corwin, Feb 13 '18 at 17:55

score 5 · Answer 5 · answered Nov 24 '21 at 16:21

5

If you just need the raw command line arguments passed to the process, or you don't want to add them to the configuration, you can still use the following:

Environment.GetCommandLineArgs();

answered Nov 24 '21 at 16:21

Professor of programming

2,978
3
30
48

Pass command-line arguments to Startup class in ASP.NET Core

5 Answers5

Linked