web-dev-qa-db-fra.com

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

J'ai un auto-hébergé . NET Core Console Application.

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?

c#console-application.net-core
40
Daniel

Toutes les applications .NET Core Sont composées de bibliothèques et de packages indépendants bien conçus que vous êtes libre de référencer et d'utiliser dans tout type d'application. Il se trouve qu'une application Asp.net core Est préconfigurée pour référencer beaucoup de ces bibliothèques et expose un point de terminaison http.

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

21
Arash Motamedi

J'ai donc trouvé 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();
}
57
Daniel

Une autre manière serait d'utiliser HostBuilder de Microsoft.Extensions.Hosting paquet.

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();
}
4
Raj