.net Core / Console Applicatin / Configuration / XML

comment configurer une application .net Core 1.0.0 Console pour L'Injection de dépendances, la journalisation et la Configuration?

une grande partie de ce qui a été écrit est déprécié après RC2. (voir problème). Fortunatelly Il ya quelques postes mis à jour avec des informations excelent:

Indispensable .NET - Injection de Dépendance .NET Core

Indispensable .NET - enregistrement .NET Core

je suis venu avec la solution suivante. Je parie qu'il y a des choses qui peuvent être améliorées, veuillez laisser des commentaires afin que je puisse améliorer cette réponse.

Dans mon static void Main, j'ai

• Installation d'injection de Dépendance
• Appeler ConfigureServices
• Instancier mon Application classe à l'aide de DI
• passer de' sync Main 'à' async Application.Exécuter')( (Il fait sens pour moi de passer à async dès que possible, et ne lorsque.)

Sur mon Application Classe:

• j'injecte autant que possible sur le constructeur de classe.
• Capture toute exception sur la méthode Run ().

Voici le code.

using System;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Options;
using Microsoft.Extensions.Configuration;
using System.IO;

public class Program
{
    static void Main(string[] args)
    {
        IServiceCollection serviceCollection = new ServiceCollection();

        ConfigureServices(serviceCollection);

        // Application application = new Application(serviceCollection);
        IServiceProvider serviceProvider = serviceCollection.BuildServiceProvider();

        var app = serviceProvider.GetService<Application>();

        // For async
        Task.Run(() => app.Run()).Wait(); // Exceptions thrown here will be lost! Catch them all at Run()
        // Otherwise use sync as in: app.Run();            
    }

    private static void ConfigureServices(IServiceCollection services)
    {
        ILoggerFactory loggerFactory = new LoggerFactory()
            .AddConsole()
            .AddDebug();

        services.AddSingleton(loggerFactory); // Add first my already configured instance
        services.AddLogging(); // Allow ILogger<T>

        IConfigurationRoot configuration = GetConfiguration();
        services.AddSingleton<IConfigurationRoot>(configuration);

        // Support typed Options
        services.AddOptions();
        services.Configure<MyOptions>(configuration.GetSection("MyOptions"));  

        services.AddTransient<Application>();
    }

    private static IConfigurationRoot GetConfiguration()
    {
        return new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile($"appsettings.json", optional: true)
            .Build();
    }
}

public class MyOptions
{
    public string Name { get; set; }
}

public class Application
{
    ILogger _logger;
    MyOptions _settings;

    public Application(ILogger<Application> logger, IOptions<MyOptions> settings)
    {
        _logger = logger;
        _settings = settings.Value;
    }

    public async Task Run()
    {
        try
        {
            _logger.LogInformation($"This is a console application for {_settings.Name}");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex.ToString());
        }
    }
}
}

Les Applications.fichier json:

{
  "MyOptions": {
    "Name" : "John"
  }
}

Et project.json fichier:

 "dependencies": {
    "Microsoft.Extensions.Configuration": "1.0.0",
    "Microsoft.Extensions.Configuration.FileExtensions": "1.0.0",
    "Microsoft.Extensions.Configuration.Json": "1.0.0",
    "Microsoft.Extensions.DependencyInjection": "1.0.0",
    "Microsoft.Extensions.Logging": "1.0.0",
    "Microsoft.Extensions.Logging.Console": "1.0.0",
    "Microsoft.Extensions.Logging.Debug": "1.0.0",
    "Microsoft.Extensions.Options": "1.0.0",
    "Microsoft.Extensions.PlatformAbstractions": "1.0.0",
    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.0.0",

sur votre question #2: j'ai lu le document et à moins que je ne manque quelque chose, il ne dit pas que vous pouvez écrire configuration. Je ne suis pas sûr que vous puissiez le faire, sauf si vous éditez les fichiers JSON manuellement en utilisant Newtonsoft.JSON.

si a la paire nom/valeur est écrite à la Configuration, elle n'est pas persistée. Ce signifie que la valeur écrite sera perdue lorsque les sources sont lues encore.

pour votre question #3, j'ai inclus une application par défaut.fichier json. Votre configuration doit avoir une Section où ses paramètres correspondent par leur nom aux propriétés publiques de votre les paramètres de la classe.