2. 程式人生 > >.NET Core 3.0之Configuration原始碼探究(一)

.NET Core 3.0之Configuration原始碼探究(一)

阿新 • • 發佈：2019-05-13

Configuration總體介紹

微軟在.NET Core裡設計出了全新的配置體系，並以非常靈活、可擴充套件的方式實現。從其原始碼來看，其執行機制大致是，根據其Source，建立一個Builder例項，並會向其新增Provider，在我們使用配置資訊的時候，會從記憶體中獲取相應的Provider例項。

.NET Core採用了統一的呼叫方式來載入不同型別的配置資訊，並通過統一的抽象介面IConfigurationSource對配置源進行管理，這也是剛剛所說的靈活。而其擴充套件性就是我們可以自己自定義新的Provider例項，而不會改變其原來的呼叫方式。接下來的文章將會基於Consul，擴充套件一個新的Provider例項。

在ASP.NET Core 中，我們的應用配置是基於IConfigurationProvider的鍵值對。 我們先看一下思維導圖：

基於上圖，我們可以看到主要有鍵值對源有多種，分別是：

 

環境變數

命令列引數

各種形式的配置檔案

記憶體物件

使用者自定義擴充套件源

 

核心物件

在介紹.NET Core配置功能之前，先簡要說明一下Microsoft.Extensions.Configuration.Abstractions，該元件抽象了.NET Core的配置功能，並對自定義擴充套件制定了新的標準。以下介紹的四個核心物件全部來自於該元件。

IConfiguration

該介面表示一組鍵/值應用程式配置屬性，應用程式使用配置時的入口物件，.NET Core對其有多種擴充套件，其派生類包括位於統一類庫的IConfigurationSection，以及Microsoft.Extensions.Configuration類庫中的ConfigurationRoot、ConfigurationSection、IConfigurationRoot。我們可以通過DI獲取IConfiguration例項。

它主要有以下三個方法：

  • GetChildren()：獲取直接子配置子節
  • GetReloadToken()：返回一個IChangeToken，可用於確定何時重新載入配置
  • GetSection(String)：獲取指定鍵的子節點

我們來看一下原始碼：

   1:  /// <summary>
   2:      /// Represents a set of key/value application configuration properties.
   3:      /// </summary>
   4:      public interface IConfiguration
   5:      {
   6:          /// <summary>
   7:          /// Gets or sets a configuration value.
   8:          /// </summary>
   9:          /// <param name="key">The configuration key.</param>
  10:          /// <returns>The configuration value.</returns>
  11:          string this[string key] { get; set; }
  12:   
  13:          /// <summary>
  14:          /// Gets a configuration sub-section with the specified key.
  15:          /// </summary>
  16:          /// <param name="key">The key of the configuration section.</param>
  17:          /// <returns>The <see cref="IConfigurationSection"/>.</returns>
  18:          /// <remarks>
  19:          ///     This method will never return <c>null</c>. If no matching sub-section is found with the specified key,
  20:          ///     an empty <see cref="IConfigurationSection"/> will be returned.
  21:          /// </remarks>
  22:          IConfigurationSection GetSection(string key);
  23:   
  24:          /// <summary>
  25:          /// Gets the immediate descendant configuration sub-sections.
  26:          /// </summary>
  27:          /// <returns>The configuration sub-sections.</returns>
  28:          IEnumerable<IConfigurationSection> GetChildren();
  29:   
  30:          /// <summary>
  31:          /// Returns a <see cref="IChangeToken"/> that can be used to observe when this configuration is reloaded.
  32:          /// </summary>
  33:          /// <returns>A <see cref="IChangeToken"/>.</returns>
  34:          IChangeToken GetReloadToken();
  35:      }

通常我們要求配置檔案要有足夠的靈活性，尤其是我們所擴充套件的配置資訊存放在了其他伺服器，當修改的時候我們很需要一套監控功能，以及時靈活的應對配置資訊的修改。現在.NET Core為我們提供了這樣一個功能，我們只需要自定義少量程式碼即可完成配置資訊的同步。這個方法就是GetReloadToken()，其返回值是IChangeToken。此處對配置資訊的同步只做一個引子，後面的文章會詳細說明。

由於ConfigurationRoot、ConfigurationSection聚集於IConfiguration介面，此處也對這兩個類進行討論，方便我們對.NET Core的配置功能有個更加形象的印象。這兩個介面，本質上就是.NET Core關於配置資訊的讀取方式。

XML是使用比較廣泛的一種資料結構，我們在配置XML時，一般會使用根節點、父節點、子節點之類的術語，此處也一樣。

ConfigurationRoot是配置的根節點，也實現了IConfigurationRoot，此介面只有一個方法，其主要功能就是實現對配置資訊的重新載入，另外還包括一個IConfigurationProvider型別的集合屬性。其原始碼如下

   1:  /// <summary>
   2:  /// Represents the root of an <see cref="IConfiguration"/> hierarchy.
   3:  /// </summary>
   4:  public interface IConfigurationRoot : IConfiguration
   5:  {
   6:      /// <summary>
   7:      /// Force the configuration values to be reloaded from the underlying <see cref="IConfigurationProvider"/>s.
   8:      /// </summary>
   9:      void Reload();
  10:   
  11:      /// <summary>
  12:      /// The <see cref="IConfigurationProvider"/>s for this configuration.
  13:      /// </summary>
  14:      IEnumerable<IConfigurationProvider> Providers { get; }
  15:  }

下面是ConfigurationRoot關於Reload()方法的實現

   1:  /// <summary>
   2:  /// Force the configuration values to be reloaded from the underlying sources.
   3:  /// </summary>
   4:  public void Reload()
   5:  {
   6:      foreach (var provider in _providers)
   7:      {
   8:          provider.Load();
   9:      }
  10:   
  11:      RaiseChanged();
  12:  }

通過原始碼我們知道，如果呼叫了Reload()方法，所有型別的Provider都會重新載入。

前面有ConfigurationRoot表示配置的根節點，那麼ConfigurationSection則表示非跟節點，畢竟父節點、子節點都是相對，所以此處使用非根節點。ConfigurationSection繼承於IConfigurationSection，該介面只有三個只讀屬性，分別表示配置資訊的Key、Value以及路徑資訊，需要指出的是，此處的路徑資訊主要指從根節點到當前節點的路徑，以表示當前節點的位置，類似於A:B:C可以表示節點C的位置，其中A、B、C都是ConfigurationSection的Key。以下是ConfigurationSection的原始碼

   1:  /// <summary>
   2:  /// Represents a section of application configuration values.
   3:  /// </summary>
   4:  public interface IConfigurationSection : IConfiguration
   5:  {
   6:      /// <summary>
   7:      /// Gets the key this section occupies in its parent.
   8:      /// </summary>
   9:      string Key { get; }
  10:   
  11:      /// <summary>
  12:      /// Gets the full path to this section within the <see cref="IConfiguration"/>.
  13:      /// </summary>
  14:      string Path { get; }
  15:   
  16:      /// <summary>
  17:      /// Gets or sets the section value.
  18:      /// </summary>
  19:      string Value { get; set; }
  20:  }

IConfigurationBuilder

該介面主要用於建立IConfigurationProvider，其派生類包括Microsoft.Extensions.Configuration.ConfigurationBuilder。其成員包括

兩個只讀屬性：

  • Properties：獲取可用於在IConfigurationBuilder之間共享資料的鍵/值集合
  • Sources：該屬性用於快取不同的配置源，以用於相對應的Provider的建立

兩個方法：

  • Add(IConfigurationSource source)：新增IConfigurationSource，並新增到屬性中Sources中
  • Build()：該方法遍歷Sources屬性，並呼叫IConfigurationSource的Build()方法，通過獲取Provider集合，最終建立IConfigurationRoot物件

ConfigurationBuilder原始碼如下

   1:  /// <summary>
   2:      /// Used to build key/value based configuration settings for use in an application.
   3:      /// </summary>
   4:      public class ConfigurationBuilder : IConfigurationBuilder
   5:      {
   6:          /// <summary>
   7:          /// Returns the sources used to obtain configuration values.
   8:          /// </summary>
   9:          public IList<IConfigurationSource> Sources { get; } = new List<IConfigurationSource>();
  10:   
  11:          /// <summary>
  12:          /// Gets a key/value collection that can be used to share data between the <see cref="IConfigurationBuilder"/>
  13:          /// and the registered <see cref="IConfigurationProvider"/>s.
  14:          /// </summary>
  15:          public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();
  16:   
  17:          /// <summary>
  18:          /// Adds a new configuration source.
  19:          /// </summary>
  20:          /// <param name="source">The configuration source to add.</param>
  21:          /// <returns>The same <see cref="IConfigurationBuilder"/>.</returns>
  22:          public IConfigurationBuilder Add(IConfigurationSource source)
  23:          {
  24:              if (source == null)
  25:              {
  26:                  throw new ArgumentNullException(nameof(source));
  27:              }
  28:   
  29:              Sources.Add(source);
  30:              return this;
  31:          }
  32:   
  33:          /// <summary>
  34:          /// Builds an <see cref="IConfiguration"/> with keys and values from the set of providers registered in
  35:          /// <see cref="Sources"/>.
  36:          /// </summary>
  37:          /// <returns>An <see cref="IConfigurationRoot"/> with keys and values from the registered providers.</returns>
  38:          public IConfigurationRoot Build()
  39:          {
  40:              var providers = new List<IConfigurationProvider>();
  41:              foreach (var source in Sources)
  42:              {
  43:                  var provider = source.Build(this);
  44:                  providers.Add(provider);
  45:              }
  46:              return new ConfigurationRoot(providers);
  47:          }
  48:      }

此處令人感慨頗多，我們最終呼叫 ConfigurationRoot 的建構函式，究其原因是Provider提供了統一的資料訪問方式，不管是基於何種型別的Provider，我們都可以呼叫其Load()方法載入配置項。此外，IConfigurationBuilder本身有很多的擴充套件方法來註冊資料來源，比如AddJsonFile()擴充套件方法。我們來看一下，我們常見的寫法，

   1:  var builder = new ConfigurationBuilder()
   2:   
   3:              .SetBasePath(env.ContentRootPath)
   4:   
   5:              .AddJsonFile("appsettings1.json", false, true)
   6:   
   7:              .AddJsonFile("appsettings2.json", false, true);
   8:   
   9:  Configuration = builder.Build();

IConfigurationSource

該介面表示應用程式配置的鍵值對。其派生類包括Microsoft.Extensions.Configuration.ChainedConfigurationSource、Microsoft.Extensions.Configuration.Memory.MemoryConfigurationSource。另外該派生類還會在檔案類配置場景下依賴Microsoft.Extensions.Configuration.FileExtensions元件。

它是所有配置源的抽象表示，包括JSON、XML、INI、環境變數等等。通過上文我們也知道了，IConfigurationBuilder會註冊多個IConfigurationSource例項。它只有一個方法，就是Build()方法，並返回IConfigurationProvider，由此可見，IConfigurationProvider的建立依賴於IConfigurationSource，這也是一一對應的關係。所有不同的源最終都會轉化成統一的鍵值對錶示。

以下為

   1:  /// <summary>
   2:  /// Represents a source of configuration key/values for an application.
   3:  /// </summary>
   4:  public interface IConfigurationSource
   5:  {
   6:      /// <summary>
   7:      /// Builds the <see cref="IConfigurationProvider"/> for this source.
   8:      /// </summary>
   9:      /// <param name="builder">The <see cref="IConfigurationBuilder"/>.</param>
  10:      /// <returns>An <see cref="IConfigurationProvider"/></returns>
  11:      IConfigurationProvider Build(IConfigurationBuilder builder);
  12:  }

以下是MemoryConfigurationSource的原始碼

   1:  /// <summary>
   2:  /// Represents in-memory data as an <see cref="IConfigurationSource"/>.
   3:  /// </summary>
   4:  public class MemoryConfigurationSource : IConfigurationSource
   5:  {
   6:      /// <summary>
   7:      /// The initial key value configuration pairs.
   8:      /// </summary>
   9:      public IEnumerable<KeyValuePair<string, string>> InitialData { get; set; }
  10:   
  11:      /// <summary>
  12:      /// Builds the <see cref="MemoryConfigurationProvider"/> for this source.
  13:      /// </summary>
  14:      /// <param name="builder">The <see cref="IConfigurationBuilder"/>.</param>
  15:      /// <returns>A <see cref="MemoryConfigurationProvider"/></returns>
  16:      public IConfigurationProvider Build(IConfigurationBuilder builder)
  17:      {
  18:          return new MemoryConfigurationProvider(this);
  19:      }
  20:  }

IConfigurationProvider

通過上文的介紹，我們可以知道IConfigurationProvider是統一的對外介面，對使用者提供配置的查詢、重新載入等功能。其派生類包括Microsoft.Extensions.Configuration.ConfigurationProvider、Microsoft.Extensions.Configuration.ChainedConfigurationProvider、Microsoft.Extensions.Configuration.Memory.MemoryConfigurationProvider。另外該派生類還會在檔案類配置場景下依賴Microsoft.Extensions.Configuration.FileExtensions元件。

以下是Microsoft.Extensions.Configuration.ConfigurationProvider的原始碼：

   1:  /// <summary>
   2:  /// Base helper class for implementing an <see cref="IConfigurationProvider"/>
   3:  /// </summary>
   4:  public abstract class ConfigurationProvider : IConfigurationProvider
   5:  {
   6:      private ConfigurationReloadToken _reloadToken = new ConfigurationReloadToken();
   7:   
   8:      /// <summary>
   9:      /// Initializes a new <see cref="IConfigurationProvider"/>
  10:      /// </summary>
  11:      protected ConfigurationProvider()
  12:      {
  13:          Data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
  14:      }
  15:   
  16:      /// <summary>
  17:      /// The configuration key value pairs for this provider.
  18:      /// </summary>
  19:      protected IDictionary<string, string> Data { get; set; }
  20:   
  21:      /// <summary>
  22:      /// Attempts to find a value with the given key, returns true if one is found, false otherwise.
  23:      /// </summary>
  24:      /// <param name="key">The key to lookup.</param>
  25:      /// <param name="value">The value found at key if one is found.</param>
  26:      /// <returns>True if key has a value, false otherwise.</returns>
  27:      public virtual bool TryGet(string key, out string value)
  28:          => Data.TryGetValue(key, out value);
  29:   
  30:      /// <summary>
  31:      /// Sets a value for a given key.
  32:      /// </summary>
  33:      /// <param name="key">The configuration key to set.</param>
  34:      /// <param name="value">The value to set.</param>
  35:      public virtual void Set(string key, string value)
  36:          => Data[key] = value;
  37:   
  38:      /// <summary>
  39:      /// Loads (or reloads) the data for this provider.
  40:      /// </summary>
  41:      public virtual void Load()
  42:      { }
  43:     
  44:      /// <summary>
  45:      /// Returns the list of keys that this provider has.
  46:      /// </summary>
  47:      /// <param name="earlierKeys">The earlier keys that other providers contain.</param>
  48:      /// <param name="parentPath">The path for the parent IConfiguration.</param>
  49:      /// <returns>The list of keys for this provider.</returns>
  50:      public virtual IEnumerable<string> GetChildKeys(
  51:          IEnumerable<string> earlierKeys,
  52:          string parentPath)
  53:      {
  54:          var prefix = parentPath == null ? string.Empty : parentPath + ConfigurationPath.KeyDelimiter;
  55:   
  56:          return Data
  57:              .Where(kv => kv.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
  58:              .Select(kv => Segment(kv.Key, prefix.Length))
  59:              .Concat(earlierKeys)
  60:              .OrderBy(k => k, ConfigurationKeyComparer.Instance);
  61:      }
  62:   
  63:      private static string Segment(string key, int prefixLength)
  64:      {
  65:          var indexOf = key.IndexOf(ConfigurationPath.KeyDelimiter, prefixLength, StringComparison.OrdinalIgnoreCase);
  66:          return indexOf < 0 ? key.Substring(prefixLength) : key.Substring(prefixLength, indexOf - prefixLength);
  67:      }
  68:   
  69:      /// <summary>
  70:      /// Returns a <see cref="IChangeToken"/> that can be used to listen when this provider is reloaded.
  71:      /// </summary>
  72:      /// <returns></returns>
  73:      public IChangeToken GetReloadToken()
  74:      {
  75:          return _reloadToken;
  76:      }
  77:   
  78:      /// <summary>
  79:      /// Triggers the reload change token and creates a new one.
  80:      /// </summary>
  81:      protected void OnReload()
  82:      {
  83:          var previousToken = Interlocked.Exchange(ref _reloadToken, new ConfigurationReloadToken());
  84:          previousToken.OnReload();
  85:      }
  86:   
  87:      /// <summary>
  88:      /// Generates a string representing this provider name and relevant details.
  89:      /// </summary>
  90:      /// <returns> The configuration name. </returns>
  91:      public override string ToString() => $"{GetType().Name}";
  92:  }

通過原始碼，我們可以知道ConfigurationProvider以字典型別快取了多個Provider物件，有需要的時候，從記憶體中獲取即可，配置的載入通過Load()方法實現，在ConfigurationRoot裡我們介紹了其Reload，並且說明其方法是在迴圈呼叫ConfigurationProvider的Load方法，但是此處只提供了一個虛方法，其目的是要交給其他具體的Provider，比如環境變數、JSON、XML等，這些具體的Provider可以從相應的配置源中獲取配置資訊。所有的子節點KEY通過GetChildKeys方法實現，其重新載入方式通過ConfigurationReloadToken例項完成。

另外需要說明一下，在ConfigurationProvider建構函式裡，對字典進行了初始化，並同時設定了字典Key不受大小寫限制，這是一個需要注意的細節。

Configuration元件結構

通過檢視.NET配置功能的原始碼，所有依賴均基於Microsoft.Extensions.Configuration.Abstractions，在其上有一層實現，即Microsoft.Extensions.Configuration，其內部也多數是抽象實現，並提供了多個虛方法交給其派生元件，比如環境變數、命令列引數、各種檔案型配置等，當然各種檔案型配置還要依賴Microsoft.Extensions.Configuration.FileExtensions元件。

以下是.NET Core 3.0預覽版裡的Configuration各個元件的結構圖：

相關推薦

.NET Core 3.0之Configuration原始碼探究(一)

Configuration總體介紹 微軟在.NET Core裡設計出了全新的配置體系，並以非常靈活、可擴充套件的方式實現。從其原始碼來看，其執行機制大致是，根據其Source，建立一個Builder例項，並會向其新增Provider，在我們使用配置資訊的時候，會從記憶體中獲取相應的Provider例項。 .N

.NET Core 3.0之深入原始碼理解Configuration(二)

檔案型配置基本內容 上一篇文章討論了Configuration的幾個核心物件，本文繼續討論Configuration中關於檔案型配置的相關內容。相比較而言，檔案型配置的使用場景更加廣泛，使用者自定義配置擴充套件也可以基於檔案型配置進行擴充套件。如果需要檢視上一篇文章，可以點選移步。 .NET Core檔案型配

.NET Core 3.0之深入原始碼理解Configuration(三)

寫在前面 上一篇文章討論了檔案型配置的基本內容，本篇內容討論JSON型配置的實現方式，理解了這一種配置型別的實現方式，那麼其他型別的配置實現方式基本可以觸類旁通。看過了上一篇文章的朋友，應該看得出來似曾相識。此圖主要表達了檔案型配置的實現，當然其他配置，包括自定義配置，都會按照這樣的方式去實現。 JSON

.NET Core 3.0之深入原始碼理解Kestrel的整合與應用(一)

  寫在前面 ASP.NET Core 的 Web 伺服器預設採用Kestrel，這是一個基於libuv(一個跨平臺的基於Node.js非同步I/O庫)的跨平臺、輕量級的Web伺服器。 在開始之前，先回顧一下.NET Core 3.0預設的main()方法模板中，我們會呼叫Host.CreateDe

.NET Core 3.0之深入原始碼理解Kestrel的整合與應用(二)

  前言 前一篇文章主要介紹了.NET Core繼承Kestrel的目的、執行方式以及相關的使用，接下來將進一步從原始碼角度探討.NET Core 3.0中關於Kestrel的其他內容，該部分內容，我們無需掌握，依然可以用好Kestrel，本文只是將一些內部的技術點揭露出來，供自己及大家有一個較

.NET Core 3.0之深入原始碼理解HttpClientFactory(一)

寫在前面 建立HttpClient例項的時候，在內部會建立HttpMessageHandler鏈，我們知道HttpMessageHandler是負責建立連線的抽象處理程式，所以HttpClient的維護實際上就是維護HttpMessageHandler的使用，釋放HttpClient並不會及時釋放連線，而通

.NET Core 3.0之深入原始碼理解HttpClientFactory(二)

  寫在前面 上一篇文章討論了通過在ConfigureServices中呼叫services.AddHttpClient()方法，並基於此進一步探討了DefaultHttpClientFactory是如何建立HttpClient例項和HttpMessageHandler例項的，並瞭解了Defau

.NET Core 3.0之深入原始碼理解Host(二)

  寫在前面 停了近一個月的技術部落格，隨著正式脫離996的魔窟，接下來也正式恢復了。本文從原始碼角度進一步討論.NET Core 3.0 中關於Host擴充套件的一些技術點，主要討論Long Run Program的建立與守護。 關於Host，我們最容易想到的就是程式的啟動與停止，而其中隱藏著非常

.NET Core 3.0之深入原始碼理解ObjectPool（一）

寫在前面 物件池是一種比較常用的提高系統性能的軟體設計模式，它維護了一系列相關物件列表的容器物件，這些物件可以隨時重複使用，物件池節省了頻繁建立物件的開銷。 它使用取用/歸還-重複取用的操作模式，如下圖所示： 本文將主要介紹物件池的基本概念、物件池的優勢及其工作機制，下一篇文件將從原始碼角度介紹.NET

.NET Core 3.0之深入原始碼理解ObjectPool（二）

寫在前面 前文主要介紹了ObjectPool的一些理論基礎，本文主要從原始碼角度理解Microsoft.Extensions.ObjectPool是如何實現的。下圖為其三大核心元件圖： 核心元件 ObjectPool ObjectPool是一個泛型抽象類，裡面只有兩個抽象方法，Get和Return。它從底

.NET Core 3.0之深入原始碼理解HealthCheck（一）

寫在前面 我們的系統可能因為正在部署、服務異常終止或者其他問題導致系統處於非健康狀態，這個時候我們需要知道系統的健康狀況，而健康檢查可以幫助我們快速確定系統是否處於正常狀態。一般情況下，我們會提供公開的HTTP介面，用於專門化健康檢查。 NET Core提供的健康檢查庫包括Microsoft.Extensio

.NET Core 3.0之建立基於Consul的Configuration擴充套件元件

寫在前面 經過前面三篇關於.NET Core Configuration的文章之後，本篇文章主要討論如何擴充套件一個Configuration元件出來。如果前面三篇文章沒有看到，可以點選如下地址訪問 .NET Core 3.0之深入原始碼理解Configuration(一) .NET C

.NET Core 3.0 之初識Host原始碼

寫在前面 ASP .NET Core中的通用主機構建器是在v2.1中引入的，應用在啟動時構建主機，主機作為一個物件用於封裝應用資源以及應用程式啟動和生存期管理。其主要功能包括配置初始化(包括載入配置以及配置轉換為通用的鍵值對格式)，建立託管環境和Host通用上下文、依賴注入等。 在.NET Core 3.

net core 3.0 之Grpc新特性小試牛刀

  　　相信微服務大傢伙都有聽說和知道，好處弊端咱也不多說了，Grpc算是一個比較全面的微服務框架，也得到微軟的支援 　　總結下來就是，跨平臺，可靠，通訊快，擴充套件性強，網路消耗小，模板多語言通用  　　 　　光說好處，沒有弊端嗎，自然是有的 　　最大的問題可能就是無法直接通過瀏覽器呼叫

.NET Core 3.1之深入原始碼理解HealthCheck（二）

寫在前面前文討論了HealthCheck的理論部分，本文將討論有關HealthCheck的應用內容。可以監視記憶體、磁碟和其他物理伺服器資源的使用情況來了解是否處於正常狀態。執行狀況檢查可以測試應用的依賴項（如資料庫和外部服務終結點）以確認是否可用和正常工作。執行狀況探測可以由容器業務流程協調程式和負載均衡器

.NET Core 3.0深入原始碼理解HttpClientFactory之實戰

  寫在前面 前面兩篇文章透過原始碼角度，理解了HttpClientFactory的內部實現，當我們在專案中使用時，總會涉及以下幾個問題： HttpClient超時處理以及重試機制 HttpClient熔斷器模式的實現 HttpClient日誌記錄與追蹤鏈 接下來我們將從使用角度對上述問題作出說

這就是你想要的 C#8.0 和.NET Core 3.0

      C# 的下一個主要版本是 8.0。我們已經為它工作了很長一段時間，即使我們構建併發布了次要版本 C# 7.1, 7.2 和 7.3，我仍然對 8.0 將帶來的新特性感到非常興奮。 目前的計劃是 C# 8.0 將與 .NET Core 3.

ASP.NET Core 3.0 實戰：構建多版本 API 介面

第一次在部落格寫分享，請多多捧場，如有歧義請多多包含！ 因為業務需求發展需要，所以API介面的變更升級是必不可少的事情，而原有的介面是不可能馬上停止使用的。例如：Login介面為例，1.0版本之返回使用者的基本資訊，而2.0版本的迭代下，要把使用者祖宗十八代資訊都要返回到客戶端，這時候1.

ASP.NET Core 3.0 實戰：構建多版本 API 接口

版本信息 include swaggerui 各類 val 業務 oca head sem 第一次在博客寫分享，請多多捧場，如有歧義請多多包含！ 因為業務需求發展需要，所以API接口的變更升級是必不可少的事情，而原有的接口是不可能馬上停止使用的。例如：Login接口為例，

ASP.NET Core 3.0：將會擁有更少的依賴

在ASP.NET Core專案中，我們使用一個叫做Microsoft.AspNetCore.App的綜合包。它也被稱為ASP.NET Core Shared Framework，在ASP.NET Core Shared Framework之中包含了很多依賴項，它能滿足一般應用的需求。但是如果你檢視它的依賴項，