ASP.NET Core configuration tutorial - reading configuration information

When it comes to the word "configuration", I think most .NET developers will immediately think of two special files, which are app.config and web.config that we are all too familiar with. For many years We are accustomed to defining structured configuration information in these two files. When it comes to .NET Core, many things we take for granted have changed, including the way to define configurations. In general, the new configuration system is more lightweight and has better scalability. Its biggest feature is that it supports diverse data sources. We can use memory variables as the data source for configuration, or directly configure and define them in persistent files or even databases.

Since many people have never been exposed to this newly designed configuration system, in order to give everyone a sensory understanding of it, we will first experience it from a programming perspective. The API for configuration involves three objects, which are Configuration, ConfigurationBuilder and ConfigurationProvider. The configuration model has corresponding interfaces to represent them. The relationship between these three objects is very clear. The Configuration object carries the configuration information used in the programming process, and the ConfigurationProvider is the provider of the original data source of the configuration information. The communication between the two is completed by the ConfigurationBuilder, which uses the ConfigurationProvider to extract Source data is converted into a Configuration object.

1. Read the configuration in the form of key-value pairs
Although in most cases the configuration information has a structured hierarchical relationship as a whole, the "atomic" configuration items are It is embodied in the simplest form of "key-value pairs", and the keys and values ​​are both strings. Next, we will use a simple example to demonstrate how to read the configuration in the form of key-value pairs. We create a console application for ASP.NET Core and add dependency on the NuGet package "Microsoft.Extensions.Configuration" in project.json as follows. The configuration model is implemented in this package.

{
  ...
   "dependencies": {
   "Microsoft.Extensions.Configuration": "1.0.0-rc1-final"
  },
 }

Assume that our application needs to set the date/time display format through configuration. For this purpose, we define the following DateTimeFormatSettings class. Its four properties reflect the DateTime object. Four display formats (long date/time and short date/time respectively).

public class DateTimeFormatSettings
 {
    public string LongDatePattern { get; set; }
    public string LongTimePattern { get; set; }
    public string ShortDatePattern { get; set; }
   public string ShortTimePattern { get; set; }
   //其他成员
 }

We hope to control the date/time display format reflected by the four properties of DateTimeFormatSettings through configuration, so we define a constructor for it. As shown in the following code snippet, the constructor has a parameter of type IConfiguration interface, which formally carries the Configuration object of related configuration information. We call the index of the Configuration object and specify the Key of the corresponding configuration item to get its Value.

public class DateTimeFormatSettings
  {
   //其他成员
   public DateTimeFormatSettings (IConfiguration configuration)
    {
      this.LongDatePattern   = configuration["LongDatePattern"];
     this.LongTimePattern   = configuration["LongTimePattern"];
     this.ShortDatePattern  = configuration["ShortDatePattern"];
      this.ShortTimePattern  = configuration["ShortTimePattern"];
   }
 }

To create a DateTimeFormatSettings object that reflects the current configuration, we must get the Configuration object that carries relevant configuration information. As we said above, the Configuration object is created by ConfigurationBuilder, and the original configuration information is read through the corresponding ConfigurationProvider, so the correct programming way to create a Configuration object is to first create a ConfigurationBuilder object and then add it One or more ConfigurationProvider objects, and finally use ConfigurationBuilder to create the Configuration object we need.

According to the above programming model, we wrote the following program in a console application. We created an object of type ConfigurationBuilder, and the ConfigurationProvider added by calling its Add method is an object of type MemoryConfigurationProvider. As the name suggests, MemoryConfigurationProvider uses objects in memory to provide original configuration information. Specifically, these original configuration information are stored in a collection whose element type is KeyValuePair708d620c35cc3f2d1dd0b997d136c07a. We finally call the Build method of ConfigurationBuilder to obtain the Configuration required to create a DateTimeFormatSettings object.

public class Program
 {
    public static void Main(string[] args)
    {
      Dictionary source = new Dictionary
      {
        ["LongDatePattern"]   = "dddd, MMMM d, yyyy",
        ["LongTimePattern"]   = "h:mm:ss tt",
        ["ShortDatePattern"]  = "M/d/yyyy",
        ["ShortTimePattern"]  = "h:mm tt"
      };
      IConfiguration configuration = new ConfigurationBuilder()
          .Add(new MemoryConfigurationProvider(source))
          .Build();
   
      DateTimeFormatSettings settings = new DateTimeFormatSettings(configuration);
      Console.WriteLine("{0,-16}: {1}", "LongDatePattern", settings.LongDatePattern);
      Console.WriteLine("{0,-16}: {1}", "LongTimePattern", settings.LongTimePattern);
      Console.WriteLine("{0,-16}: {1}", "ShortDatePattern", settings.ShortDatePattern);
      Console.WriteLine("{0,-16}: {1}", "ShortTimePattern", settings.ShortTimePattern);
   }
 }

In order to verify the relationship between the DateTimeFormatSettings object created according to the configuration and the configuration original data, we output its four properties on the console. When this program is executed, it will produce the output shown below on the console. It can be seen that it is a true reflection of the configuration we provided.
LongDatePattern: dddd, MMMM d, yyyy
LongTimePattern: h:mm:ss tt
ShortDatePattern: M/d/yyyy
ShortTimePattern: h:mm tt

2. Read Take structured configuration
Most of the configurations involved in real projects have a structured hierarchical structure, so the Configuration object in the configuration model also has such a structure. A structured configuration has a tree hierarchy, and a Configuration object represents a node that makes up the configuration tree. This configuration tree can be represented by the Configuration object as the root node. Atomic configuration items embodied as key-value pairs generally exist in Configuration objects as leaf nodes. The Configuration of non-leaf nodes contains a set of child nodes, and each child node is also a Configuration object.

接下来我们同样以实例的方式来演示如何定义并读取具有层次化结构的配置。我们依然沿用上一节的应用场景，现在我们不仅仅需要设置日期/时间的格式，还需要设置其他数据类型的格式，比如表示货币的Decimal类型。为此我们定义了如下一个CurrencyDecimalFormatSettings类，它的属性Digits和Symbol分别表示小数位数和货币符号，一个CurrencyDecimalFormatSettings对象依然是利用一个表示配置的Configuration对象来创建的。

{
   public int   Digits { get; set; }
 public string Symbol { get; set; }
  
   public CurrencyDecimalFormatSettings(IConfiguration configuration)
  {
    this.Digits = int.Parse(configuration["Digits"]);
     this.Symbol = configuration["Symbol"];
  }
}

我们定义了另一个名为FormatSettings的类型来表示针对不同数据类型的格式设置。如下面的代码片段所示，它的两个属性DateTime和CurrencyDecimal分别表示针对日期/时间和货币数字的格式设置。FormatSettings依然具有一个参数类型为IConfiguration接口的构造函数，它的两个属性均在此构造函数中被初始化。值得注意的是初始化这两个属性采用的是当前Configuration的“子配置节”，通过指定配置节名称调用GetSection方法获得。

public class FormatSettings
{
  public DateTimeFormatSettings      DateTime { get; set; }
   public CurrencyDecimalFormatSettings   CurrencyDecimal { get; set; }
   
   public FormatSettings(IConfiguration configuration)
    {
      this.DateTime = new DateTimeFormatSettings(configuration.GetSection("DateTime"));
      this.CurrencyDecimal = new CurrencyDecimalFormatSettings(configuration.GetSection("CurrencyDecimal"));
    }
}

在我们上面演示的实例中，我们通过以一个MemoryConfigurationProvider对象来提供原始的配置信息。由于承载原始配置信息的是一个元素类型为KeyValuePair708d620c35cc3f2d1dd0b997d136c07a的集合，所以原始配置在物理存储上并不具有树形化的层次结构，那么它如何能够最终提供一个结构化的Configuration对象呢？其实很简单，虽然MemoryConfigurationProvider对象只能将配置信息存储为简单的“数据字典”，但是如果将Configuration对象在配置树中体现的路径作为Key，这个数据字典在逻辑上实际上就具有了一棵树的结构。实际上MemoryConfigurationProvider就是这么做的，这体现在我们如下所示的程序之中。

class Program
 {
   static void Main(string[] args)
   {
     Dictionary source = new Dictionary
     {
       ["Format:DateTime:LongDatePattern"]   = "dddd, MMMM d, yyyy",
       ["Format:DateTime:LongTimePattern"]   = "h:mm:ss tt",
       ["Format:DateTime:ShortDatePattern"]   = "M/d/yyyy",
       ["Format:DateTime:ShortTimePattern"]   = "h:mm tt",
  
       ["Format:CurrencyDecimal:Digits"]   = "2",
       ["Format:CurrencyDecimal:Symbol"]   = "$",
     };
     IConfiguration configuration = new ConfigurationBuilder()
         .Add(new MemoryConfigurationProvider(source))
         .Build();
  
     FormatSettings settings = new FormatSettings(configuration.GetSection("Format"));
     Console.WriteLine("DateTime:");
     Console.WriteLine("\t{0,-16}: {1}", "LongDatePattern", settings.DateTime.LongDatePattern);
     Console.WriteLine("\t{0,-16}: {1}", "LongTimePattern", settings.DateTime.LongTimePattern);
     Console.WriteLine("\t{0,-16}: {1}", "ShortDatePattern", settings.DateTime.ShortDatePattern);
     Console.WriteLine("\t{0,-16}: {1}\n", "ShortTimePattern", settings.DateTime.ShortTimePattern);
  
     Console.WriteLine("CurrencyDecimal:");
     Console.WriteLine("\t{0,-16}: {1}", "Digits", settings.CurrencyDecimal.Digits);
     Console.WriteLine("\t{0,-16}: {1}", "Symbol", settings.CurrencyDecimal.Symbol);
   }
}

如上面的代码片段所示，创建MemoryConfigurationProvider对象采用的字典对象包含6个基本的配置项，为了让它们在逻辑上具有一个树形化层次结构，所以的Key实际上体现了每个配置项所在配置节在配置树中的路径，路径采用冒号（“：”）进行分割。改程序执行之后会在控制台上呈现如下所示的输出结果。

DateTime:
    LongDatePattern : dddd, MMMM d, yyyy
    LongTimePattern : h:mm:ss tt
     ShortDatePattern: M/d/yyyy
    ShortTimePattern: h:mm tt
  
 CurrencyDecimal:
    Digits     : 2
    Symbol     : $

三、将结构化配置直接绑定为对象
在真正的项目开发过程中，我们都不会直接使用直接读取的配置，而都倾向于像我们演示的两个实例一样通过创建相应的类型（比如DateTimeFormatSettings、CurrencyDecimalSettings和FormatSettings）来定义一组相关的配置选项（Option），我们将定义配置选项（Option）的这些类型称为Option类型。在上面演示的实例中，为了创建这些封装配置的对象，我们都是采用手工读取配置的形式，如果定义的配置项太多的话，逐条读取配置项其实是一项非常繁琐的工作。

对于一个对象来说，如果我们将它的属性视为它的子节点，一个对象同样具有类似于Configuration对象的树形层次化结构。如果我们根据某个Option类型的结构来定义配置，或者反过来根据配置的结构来定义这个Option类型，那么Option类型的属性成员将与某个配置节具有一一对应的关系，那么原则上我们可以自动将配置信息绑定为一个具体的Option对象。

ASP.NET Core针对配置的Option模型（OptionModel）帮助我们实现了从配置到Option对象之间的绑定，接下来我们就对此做一个简单的演示。Option模型实现在“Microsoft.Extensions.OptionModel”这个NuGet包中，除此之外，我们需要采用依赖注入的方式来使用Option模型，所以我们需要按照如下的方式为应用添加针对相应的依赖。

{
 ...
 "dependencies": {
 "Microsoft.Extensions.OptionsModel"    : "1.0.0-rc1-final",
 "Microsoft.Extensions.DependencyInjection"  : "1.0.0-rc1-final"
 },
}

借助于Option模型的自动绑定机制，我们无需再手工地读取配置信息，所以我们将FormatSettings、DateTimeFormatSettings和CurrencyDecimalSettings的构造函数删除，只保留其属性成员。在作为程序入口的Main方法中，我们采用如下的方式创建这个表示格式设置的FormatSettings对象。

class Program
{
   static void Main(string[] args)
   {
     Dictionary source = new Dictionary
     {
      ["Format:DateTime:LongDatePattern"] = "dddd, MMMM d, yyyy",
      ["Format:DateTime:LongTimePattern"] = "h:mm:ss tt",
      ["Format:DateTime:ShortDatePattern"] = "M/d/yyyy",
       ["Format:DateTime:ShortTimePattern"] = "h:mm tt",
  
       ["Format:CurrencyDecimal:Digits"] = "2",
       ["Format:CurrencyDecimal:Symbol"] = "$",
    };
    IConfiguration configuration = new ConfigurationBuilder()
         .Add(new MemoryConfigurationProvider(source))
         .Build()
         .GetSection("Format"));
  
     IOptions optionsAccessor = new ServiceCollection()
       .AddOptions()
       .Configure(configuration)
      .BuildServiceProvider()
      .GetService>();
  
    FormatSettings settings = optionsAccessor.Value;
  
     Console.WriteLine("DateTime:");
     Console.WriteLine("\t{0,-16}: {1}", "LongDatePattern",settings.DateTime.LongDatePattern);
     Console.WriteLine("\t{0,-16}: {1}", "LongTimePattern",settings.DateTime.LongTimePattern);
     Console.WriteLine("\t{0,-16}: {1}", "ShortDatePattern",settings.DateTime.ShortDatePattern);
     Console.WriteLine("\t{0,-16}: {1}\n", "ShortTimePattern",settings.DateTime.ShortTimePattern);
  
     Console.WriteLine("CurrencyDecimal:");
     Console.WriteLine("\t{0,-16}: {1}", "Digits",settings.CurrencyDecimal.Digits);
     Console.WriteLine("\t{0,-16}: {1}", "Symbol",settings.CurrencyDecimal.Symbol);
   }
 }

如上面的代码片段所示，我们创建一个ServiceCollection对象并调用扩展方法AddOptions注册于针对Option模型的服务。接下来我们调用Configure方法将FormatSettings这个Option类型与对应的Configuration对象进行映射。我们最后利用这个ServiceCollection对象生成一个ServiceProvider，并调用其GetService方法得到一个类型为IOptionsb7508df415eea39e792050f586bf7677的对象，后者的Value属性返回的就是绑定了相关配置的FormatSettings对象。

以上就是本文的全部内容，希望对大家的学习有所帮助。

更多asp.net core实现文件上传功能相关文章请关注PHP中文网！