Startup.cs dans une application .NET Core Console auto-hébergée

Question

J'ai une application .NET Core Console auto-hébergée.

Le Web montre des exemples pour ASP.NET Core mais je n’ai pas de serveur Web. Juste une simple application en ligne de commande.

Est-il possible de faire quelque chose comme ça pour les applications console?

 public static void Main(string[] args)
{
    // I don't want a WebHostBuilder. Just a command line

    var host = new WebHostBuilder()
        .UseKestrel()
        .UseContentRoot(Directory.GetCurrentDirectory())
        .UseIISIntegration()
        .UseStartup<Startup>()
        .Build();

    host.Run();
}
 

Je voudrais utiliser un Startup.cs comme dans ASP.NET Core mais sur console.

Comment ça?

Answer 1

Je suis donc tombé sur cette solution, inspirée par la réponse acceptée:

Program.cs

 public class Program
{
    public static void Main(string[] args)
    {
        IServiceCollection services = new ServiceCollection();
        // Startup.cs finally :)
        Startup startup = new Startup();
        startup.ConfigureServices(services);
        IServiceProvider serviceProvider = services.BuildServiceProvider();

        //configure console logging
        serviceProvider
            .GetService<ILoggerFactory>()
            .AddConsole(LogLevel.Debug);

        var logger = serviceProvider.GetService<ILoggerFactory>()
            .CreateLogger<Program>();

        logger.LogDebug("Logger is working!");

        // Get Service and call method
        var service = serviceProvider.GetService<IMyService>();
        service.MyServiceMethod();
    }
}
 

Startup.cs

 public class Startup
{
    IConfigurationRoot Configuration { get; }

    public Startup()
    {
        var builder = new ConfigurationBuilder()
            .AddJsonFile("appsettings.json");

        Configuration = builder.Build();
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddLogging();
        services.AddSingleton<IConfigurationRoot>(Configuration);
        services.AddSingleton<IMyService, MyService>();
    }
}
 

appsettings.json

 {
    "SomeConfigItem": {
        "Token": "8201342s223u2uj328",
        "BaseUrl": "http://localhost:5000"
    }
}
 

MyService.cs

 public class MyService : IMyService
{
    private readonly string _baseUrl;
    private readonly string _token;
    private readonly ILogger<MyService> _logger;

    public MyService(ILoggerFactory loggerFactory, IConfigurationRoot config)
    {
        var baseUrl = config["SomeConfigItem:BaseUrl"];
        var token = config["SomeConfigItem:Token"];

        _baseUrl = baseUrl;
        _token = token;
        _logger = loggerFactory.CreateLogger<MyService>();
    }

    public async Task MyServiceMethod()
    {
        _logger.LogDebug(_baseUrl);
        _logger.LogDebug(_token);
    }
}
 

IMyService.cs

 public interface IMyService
{
    Task MyServiceMethod();
}
 

Answer 2

Tous .NET Core des applications sont composées de bien conçus de librairies indépendantes et les paquets, vous êtes libre de référence et l'utilisation dans tout type d'application. Il arrive qu'un Asp.net core application est livré préconfiguré pour faire référence à un grand nombre de ces bibliothèques et expose un point de terminaison http.

Mais si c'est de l'Injection de Dépendances dont vous avez besoin pour votre application console, il suffit de référence de la bibliothèque appropriée. Voici un guide: http://andrewlock.net/using-dependency-injection-in-a-net-core-console-application/

Answer 3

Une autre façon serait d'utiliser HostBuilder de Microsoft.Extensions.Hosting package.

 public static async Task Main(string[] args)
{
    var builder = new HostBuilder()
        .ConfigureAppConfiguration((hostingContext, config) =>
        {
            config.SetBasePath(Directory.GetCurrentDirectory());
            config.AddJsonFile("appsettings.json", true);
            if (args != null) config.AddCommandLine(args);
        })
        .ConfigureServices((hostingContext, services) =>
        {
            services.AddHostedService<MyHostedService>();
        })
        .ConfigureLogging((hostingContext, logging) =>
        {
            logging.AddConfiguration(hostingContext.Configuration);
            logging.AddConsole();
        });

    await builder.RunConsoleAsync();
}
 

Answer 4

Oui, ça l'est. Les applications ASP.NET Core peuvent être auto-hébergées - comme dans votre exemple - ou hébergées sur un serveur Web tel que IIS. Dans .NET Core, toutes les applications sont des applications de console.