c# - ihttpactionresult - Startup.cs en una aplicación de consola central.NET auto-alojada

migrate webapi to asp net core

Question

Tengo una aplicación de consola central .NET auto-alojada.

La web muestra ejemplos para ASP.NET Core pero no tengo un servidor web. Sólo una simple aplicación de línea de comandos.

¿Es posible hacer algo como esto para las aplicaciones de consola?

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

Me gustaría usar un Startup.cs como en ASP.NET Core pero en la consola.

¿Cómo esto?

Answer 1

Así que encontré esta solución, inspirada en la respuesta aceptada:

Programa.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

Otra forma sería usando HostBuilder del paquete Microsoft.Extensions.Hosting .

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 3

Sí lo es. Las aplicaciones ASP.NET Core pueden ser auto hospedadas, como en su ejemplo, o alojadas dentro de un servidor web como IIS. En .NET Core todas las aplicaciones son aplicaciones de consola.

Answer 4

Todas las aplicaciones .NET Core están compuestas de bibliotecas y paquetes independientes bien diseñados que puede consultar y utilizar en cualquier tipo de aplicación. Da la casualidad de que una aplicación Asp.net core viene preconfigurada para hacer referencia a muchas de esas bibliotecas y expone un punto final de http.

Pero si es la inyección de dependencia que necesita para su aplicación de consola, simplemente haga referencia a la biblioteca apropiada. Aquí hay una guía: andrewlock.net/…