Startup.cs in einer selbst gehosteten .NET Core Console-Anwendung

Question

Ich habe eine selbst gehostete .NET Core Console-Anwendung. Das Netz zeigt Beispiele für ASP.NET Core aber ich habe keinen Webserver. Nur eine einfache Befehlszeilenanwendung.

Ist es möglich, so etwas für Konsolenanwendungen zu tun?

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

Ich möchte ein Startup.cs wie in ASP.NET Core aber auf der Konsole verwenden.

Wie geht das?

Answer 1

Alle .NET Core Anwendungen bestehen aus gut gestalteten unabhängigen Bibliotheken und Paketen, auf die Sie in jeder Art von Anwendung verweisen können. Es kommt einfach vor, dass eine Asp.net core Anwendung vorkonfiguriert ist, um viele dieser Bibliotheken zu referenzieren und einen HTTP-Endpunkt verfügbar macht.

Aber wenn Dependency Injection Sie für Ihre Konsole App benötigen, verweisen Sie einfach auf die entsprechende Bibliothek. Hier ist eine Anleitung: http://andrewlock.net/using-dependency-injection-in-a-net-core-console-application/

Answer 2

Ja, ist es. ASP.NET Core-Anwendungen können entweder - wie in Ihrem Beispiel - selbst gehostet oder auf einem Webserver wie IIS gehostet werden. In .NET Core sind alle Anwendungen Konsolenanwendungen.

Answer 3

So stieß ich auf mit dieser Lösung durch die akzeptierte Antwort inspiriert:

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