Konstruktory konfiguracji dla platformy ASP.NET

Autorzy Stephen Molloy i Rick Anderson

Konstruktory konfiguracji zapewniają nowoczesne i Agile mechanizm dla aplikacji ASP.NET, aby uzyskać wartości konfiguracyjne ze źródeł zewnętrznych.

Konstruktory konfiguracji:

• Są dostępne w .NET Framework 4.7.1 i nowszych.
• Zapewnianie elastycznego mechanizmu odczytywania wartości konfiguracyjnych.
• Należy zająć się niektórymi podstawowymi potrzebami aplikacji, które są przenoszone do kontenera i środowiska ukierunkowanego na chmurę.
• Może służyć do ulepszania ochrony danych konfiguracji przez rysowanie ze źródeł, które były wcześniej niedostępne (na przykład Azure Key Vault i zmienne środowiskowe) w systemie konfiguracji .NET.

Konstruktory konfiguracji klucza/wartości

Typowym scenariuszem, który może być obsługiwany przez konstruktory konfiguracji, jest zapewnienie podstawowego mechanizmu wymiany klucza/wartości dla sekcji konfiguracyjnych, które są zgodne ze wzorcem klucz/wartość. Koncepcja .NET Framework ConfigurationBuilders nie jest ograniczona do określonych sekcji konfiguracyjnych ani wzorców. Jednak wiele konstruktorów konfiguracji w programie Microsoft.Configuration.ConfigurationBuilders (GitHub, NuGet) pracuje w obrębie wzorca klucz/wartość.

Ustawienia konstruktorów konfiguracji klucza/wartości

Następujące ustawienia mają zastosowanie do wszystkich konstruktorów konfiguracji klucza/wartości w programie Microsoft.Configuration.ConfigurationBuilders .

Tryb

Konstruktory konfiguracji używają zewnętrznego źródła informacji o klucz/wartość, aby wypełnić wybrane elementy klucza/wartości systemu konfiguracyjnego. W <appSettings/> <connectionStrings/> poszczególnych sekcjach i są uzyskiwane specjalne podejście od konstruktorów konfiguracji. Konstruktorzy pracują w trzech trybach:

• Strict — Tryb domyślny. W tym trybie Konstruktor konfiguracji działa tylko w przypadku dobrze znanych sekcji konfiguracji klucz/wartość. Strict Tryb wylicza każdy klucz w sekcji. Jeśli w źródle zewnętrznym zostanie znaleziony pasujący klucz:

  • Konstruktory konfiguracji zastępują wartość w sekcji konfiguracji w wyniku wartością z zewnętrznego źródła.

• Greedy — Ten tryb jest ściśle powiązany z Strict trybem. Zamiast ograniczać się do kluczy, które już istnieją w oryginalnej konfiguracji:

  • Konstruktory konfiguracji dodaje wszystkie pary klucz/wartość ze źródła zewnętrznego do sekcji konfiguracji w wyniku.

• Expand -Działa na nieprzetworzonym kodzie XML przed przeanalizowaniem go do obiektu sekcji konfiguracji. Można go traktować jako rozszerzenie tokenów w ciągu. Każda część nieprzetworzonego ciągu XML zgodna ze wzorcem ${token} jest kandydatem do rozwinięcia tokenu. Jeśli w zewnętrznym źródle nie zostanie znaleziona odpowiednia wartość, token nie zostanie zmieniony. Konstruktory w tym trybie nie są ograniczone do <appSettings/> sekcji i <connectionStrings/> .

Następujące znaczniki z web.config umożliwiają EnvironmentConfigBuilder w Strict trybie:

<configuration>

  <configSections>
    <section name="configBuilders" 
             type="System.Configuration.ConfigurationBuildersSection, 
             System.Configuration, Version=4.0.0.0, Culture=neutral, 
             PublicKeyToken=b03f5f7f11d50a3a"
             restartOnExternalChanges="false" requirePermission="false" />
  </configSections>

  <configBuilders>
    <builders>
      <add name="MyEnvironment"
           type="Microsoft.Configuration.ConfigurationBuilders.EnvironmentConfigBuilder, 
           Microsoft.Configuration.ConfigurationBuilders.Environment, 
           Version=1.0.0.0, Culture=neutral" />
    </builders>
  </configBuilders>

  <appSettings configBuilders="MyEnvironment">
    <add key="ServiceID" value="ServiceID value from web.config" />
    <add key="ServiceKey" value="ServiceKey value from web.config" />
  </appSettings>

  <connectionStrings configBuilders="MyEnvironment">
    <add name="default" connectionString="Data Source=web.config/mydb.db" />
  </connectionStrings>

Poniższy kod odczytuje <appSettings/> i <connectionStrings/> pokazano w poprzednim pliku web.config :

using System;
using System.Configuration;
using System.Web.UI;

namespace MyConfigBuilders
{
    public partial class About : Page
    {
        public string ServiceID { get; set; }
        public string ServiceKey { get; set; }
        public string ConString { get; set; }

        protected void Page_Load(object sender, EventArgs e)
        {
            ServiceID = ConfigurationManager.AppSettings["ServiceID"];
            ServiceKey = ConfigurationManager.AppSettings["ServiceKey"];
            ConString = ConfigurationManager.ConnectionStrings["default"]
                                            ?.ConnectionString;
        }
    }
}

Poprzedni kod ustawi wartości właściwości na:

• Wartości w pliku web.config , jeśli klucze nie są ustawione w zmiennych środowiskowych.
• Wartości zmiennej środowiskowej, jeśli jest ustawiona.

Na przykład ServiceID będzie zawierać:

• "ServiceID wartość z web.config", jeśli zmienna środowiskowa ServiceID nie została ustawiona.
• Wartość ServiceID zmiennej środowiskowej, jeśli jest ustawiona.

Na poniższej ilustracji przedstawiono <appSettings/> klucze/wartości z poprzedniego web.config zestawu plików w edytorze środowiska:

Uwaga: aby zobaczyć zmiany w zmiennych środowiskowych, może być konieczne zamknięcie i ponowne uruchomienie programu Visual Studio.

Obsługa prefiksów

Prefiksy kluczy mogą uprościć ustawienie kluczy, ponieważ:

• Konfiguracja .NET Framework jest złożona i zagnieżdżona.
• Zewnętrzne źródła kluczy/wartości są zwykle podstawowe i płaskie według natury. Na przykład zmienne środowiskowe nie są zagnieżdżone.

Użyj dowolnych z poniższych metod, aby wprowadzić zarówno <appSettings/> , jak i <connectionStrings/> do konfiguracji za pomocą zmiennych środowiskowych:

• Z EnvironmentConfigBuilder w Strict trybie domyślnym i odpowiednimi nazwami kluczy w pliku konfiguracji. Powyższy kod i znacznik przyjmuje takie podejście. Korzystając z tej metody, nie można mieć identycznie nazwanych kluczy w obu <appSettings/> i <connectionStrings/> .
• Użyj dwóch EnvironmentConfigBuilder trybów w Greedy trybie z prefiksami DISTINCT i stripPrefix . Dzięki temu aplikacja może odczytywać <appSettings/> i <connectionStrings/> bez konieczności aktualizować pliku konfiguracji. W następnej sekcji stripPrefix, pokazano, jak to zrobić.
• Użyj dwóch EnvironmentConfigBuilder trybów w Greedy trybie z różnymi prefiksami. W tym podejściu nie można mieć zduplikowanych nazw kluczy, ponieważ nazwy kluczy muszą się różnić prefiksami. Na przykład:

<configuration>

  <configSections>
    <section name="configBuilders"
             type="System.Configuration.ConfigurationBuildersSection, 
             System.Configuration, Version=4.0.0.0, Culture=neutral, 
             PublicKeyToken=b03f5f7f11d50a3a"
             restartOnExternalChanges="false" requirePermission="false" />
  </configSections>

  <configBuilders>
    <builders>
      <add name="AS_Environment" mode="Greedy" prefix="AppSetting_"
           type="Microsoft.Configuration.ConfigurationBuilders.EnvironmentConfigBuilder, 
           Microsoft.Configuration.ConfigurationBuilders.Environment" />
      <add name="CS_Environment" mode="Greedy" prefix="ConnStr_"
           type="Microsoft.Configuration.ConfigurationBuilders.EnvironmentConfigBuilder, 
           Microsoft.Configuration.ConfigurationBuilders.Environment" />
    </builders>
  </configBuilders>

  <appSettings configBuilders="AS_Environment">
    <add key="AppSetting_ServiceID" value="ServiceID value from web.config" />
    <add key="AppSetting_default" value="AppSetting_default value from web.config" />
  </appSettings>

  <connectionStrings configBuilders="CS_Environment">
    <add name="ConnStr_default" connectionString="Data Source=web.config/mydb.db" />
  </connectionStrings>

Przy poprzedzającym znaczniku można użyć tego samego prostego źródła klucza/wartości, aby wypełnić konfigurację dla dwóch różnych sekcji.

Na poniższej ilustracji przedstawiono <appSettings/> i <connectionStrings/> klucze/wartości z poprzedniego web.config zestawu plików w edytorze środowiska:

Poniższy kod odczytuje <appSettings/> <connectionStrings/> klucze i/wartości zawarte w poprzednim pliku web.config :

public partial class Contact : Page
{
    public string ServiceID { get; set; }
    public string AppSetting_default { get; set; }
    public string ConString { get; set; }

    protected void Page_Load(object sender, EventArgs e)
    {
        ServiceID = ConfigurationManager.AppSettings["AppSetting_ServiceID"];
        AppSetting_default = ConfigurationManager.AppSettings["AppSetting_default"];
        ConString = ConfigurationManager.ConnectionStrings["ConnStr_default"]
                                     ?.ConnectionString;
    }
}

Poprzedni kod ustawi wartości właściwości na:

• Wartości w pliku web.config , jeśli klucze nie są ustawione w zmiennych środowiskowych.
• Wartości zmiennej środowiskowej, jeśli jest ustawiona.

Na przykład przy użyciu poprzedniego pliku web.config , klucze/wartości w poprzednim obrazie edytora środowiska i Poprzedni kod są ustawione następujące wartości:

stripPrefix

stripPrefix: wartość logiczna, wartość domyślna to false .

Poprzedzające znaczniki XML oddzielają ustawienia aplikacji od parametrów połączenia, ale wymagają wszystkich kluczy w pliku web.config , aby użyć określonego prefiksu. Na przykład AppSetting należy dodać prefiks do ServiceID klucza ("AppSetting_ServiceID"). W przypadku stripPrefix , prefiks nie jest używany w pliku web.config . Prefiks jest wymagany w źródle Configuration Builder (na przykład w środowisku). Oczekujemy, że większość deweloperów będzie korzystać z programu stripPrefix .

Aplikacje zwykle przełączają się na prefiks. Poniższy web.config przykładek prefiksu:

<configuration>

  <configSections>
    <section name="configBuilders"
             type="System.Configuration.ConfigurationBuildersSection, 
             System.Configuration, Version=4.0.0.0, Culture=neutral, 
             PublicKeyToken=b03f5f7f11d50a3a"
             restartOnExternalChanges="false" requirePermission="false" />
  </configSections>

  <configBuilders>
    <builders>
      <add name="AS_Environment" mode="Greedy" prefix="AppSetting_" 
           stripPrefix="true"
           type="Microsoft.Configuration.ConfigurationBuilders.EnvironmentConfigBuilder, 
           Microsoft.Configuration.ConfigurationBuilders.Environment, 
           Version=1.0.0.0, Culture=neutral" />
      <add name="CS_Environment" mode="Greedy" prefix="ConnStr_" 
           stripPrefix="true"
            type="Microsoft.Configuration.ConfigurationBuilders.EnvironmentConfigBuilder, 
           Microsoft.Configuration.ConfigurationBuilders.Environment, 
           Version=1.0.0.0, Culture=neutral" />
    </builders>
  </configBuilders>

  <appSettings configBuilders="AS_Environment">
    <add key="ServiceID" value="ServiceID value from web.config" />
    <add key="default" value="AppSetting_default value from web.config" />
  </appSettings>

  <connectionStrings configBuilders="CS_Environment">
    <add name="default" connectionString="Data Source=web.config/mydb.db" />
  </connectionStrings>

W poprzednim pliku web.config default klucz znajduje się zarówno w, <appSettings/> jak i <connectionStrings/> .

Na poniższej ilustracji przedstawiono <appSettings/> i <connectionStrings/> klucze/wartości z poprzedniego web.config zestawu plików w edytorze środowiska:

Poniższy kod odczytuje <appSettings/> <connectionStrings/> klucze i/wartości zawarte w poprzednim pliku web.config :

public partial class About2 : Page
{
    public string ServiceID { get; set; }
    public string AppSetting_default { get; set; }
    public string ConString { get; set; }

    protected void Page_Load(object sender, EventArgs e)
    {
        ServiceID = ConfigurationManager.AppSettings["ServiceID"];
        AppSetting_default = ConfigurationManager.AppSettings["default"];
        ConString = ConfigurationManager.ConnectionStrings["default"]
                                        ?.ConnectionString;
    }
}

Poprzedni kod ustawi wartości właściwości na:

• Wartości w pliku web.config , jeśli klucze nie są ustawione w zmiennych środowiskowych.
• Wartości zmiennej środowiskowej, jeśli jest ustawiona.

Na przykład przy użyciu poprzedniego pliku web.config , klucze/wartości w poprzednim obrazie edytora środowiska i Poprzedni kod są ustawione następujące wartości:

tokenPattern

tokenPattern: Ciąg, wartość domyślna to @"\$\{(\w+)\}"

ExpandZachowanie konstruktorów przeszukuje nieprzetworzony kod XML pod kątem tokenów, które wyglądają następująco ${token} . Wyszukiwanie jest wykonywane z domyślnym wyrażeniem regularnym @"\$\{(\w+)\}" . Zestaw znaków, który jest zgodny, \w jest bardziej rygorystyczny niż XML i wiele źródeł konfiguracji Zezwalaj. Użyj tokenPattern @"\$\{(\w+)\}" , gdy w nazwie tokenu są wymagane więcej znaków niż.

tokenPatternParametry

• Umożliwia deweloperom zmianę wyrażenia regularnego używanego do dopasowywania tokenu.
• Sprawdzanie poprawności nie jest wykonywane, aby upewnić się, że jest to dobrze sformułowane wyrażenie regularne.
• Musi zawierać grupę przechwytywania. Całe wyrażenie regularne musi być zgodne z całym tokenem. Pierwsze przechwytywanie musi być nazwą tokenu, aby wyszukać w źródle konfiguracji.

Konstruktory konfiguracji w Microsoft.Configuration.ConfigurationBuilders

EnvironmentConfigBuilder

<add name="Environment"
    [mode|prefix|stripPrefix|tokenPattern] 
    type="Microsoft.Configuration.ConfigurationBuilders.EnvironmentConfigBuilder,
    Microsoft.Configuration.ConfigurationBuilders.Environment" />

EnvironmentConfigBuilder:

• Jest najprostszym z konstruktorów konfiguracji.
• Odczytuje wartości ze środowiska.
• Nie ma żadnych dodatkowych opcji konfiguracji.
• nameWartość atrybutu jest dowolny.

Uwaga: W środowisku kontenera systemu Windows zmienne ustawione w czasie wykonywania są wstrzykiwane tylko do środowiska procesu EntryPoint. Aplikacje uruchamiane jako usługa lub proces poza elementem EntryPoint nie pobierają tych zmiennych, chyba że są one wprowadzane przez mechanizm w kontenerze. W przypadku / kontenerów opartych naASP.NETIIS bieżąca wersja ServiceMonitor.exe obsługuje tę opcję tylko w ramach tej usługi. Inne warianty kontenerów opartych na systemie Windows mogą wymagać opracowania własnego mechanizmu wstrzykiwania dla procesów poza punktami wejścia.

UserSecretsConfigBuilder

<add name="UserSecrets"
    [mode|prefix|stripPrefix|tokenPattern]
    (userSecretsId="{secret string, typically a GUID}" | userSecretsFile="~\secrets.file")
    [optional="true"]
    type="Microsoft.Configuration.ConfigurationBuilders.UserSecretsConfigBuilder,
    Microsoft.Configuration.ConfigurationBuilders.UserSecrets" />

Ten konstruktor konfiguracji udostępnia funkcję podobną do ASP.NET Core Secret Manager.

UserSecretsConfigBuilder można używać w projektach .NET Framework, ale musi być określony plik tajny. Alternatywnie można zdefiniować UserSecretsId Właściwość w pliku projektu i utworzyć Nieprzetworzony plik tajny we właściwym miejscu do odczytu. Aby zachować zależności zewnętrzne poza projektem, plik tajny jest sformatowany w formacie XML. Formatowanie XML jest szczegółami implementacji i nie powinno się opierać na tym formacie. Jeśli musisz udostępnić secrets.jsw pliku z projektami .NET Core, rozważ użycie SimpleJsonConfigBuilder. SimpleJsonConfigBuilderFormat platformy .NET Core powinien również być traktowany jak szczegóły implementacji, aby zmienić.

Atrybuty konfiguracji dla UserSecretsConfigBuilder :

• userSecretsId — Jest to preferowana metoda identyfikacji pliku tajnego XML. Działa podobnie do programu .NET Core, który używa UserSecretsId właściwości projektu do przechowywania tego identyfikatora. Ciąg musi być unikatowy, nie musi być identyfikatorem GUID. Przy użyciu tego atrybutu należy UserSecretsConfigBuilder szukać w dobrze znanej lokalizacji lokalnej ( %APPDATA%\Microsoft\UserSecrets\<UserSecrets Id>\secrets.xml ) dla pliku tajnego należącego do tego identyfikatora.
• userSecretsFile -Opcjonalny atrybut określający plik zawierający wpisy tajne. Ten ~ znak może być używany na początku do odwoływania się do katalogu głównego aplikacji. Ten atrybut lub userSecretsId atrybut jest wymagany. Jeśli oba są określone, userSecretsFile ma pierwszeństwo.
• optional: Boolean, wartość domyślna true — uniemożliwia wyjątek, jeśli nie można znaleźć pliku tajnego.
• nameWartość atrybutu jest dowolny.

Plik tajny ma następujący format:

<?xml version="1.0" encoding="utf-8" ?>
<root>
  <secrets ver="1.0">
    <secret name="secret key name" value="secret value" />
  </secrets>
</root>

AzureKeyVaultConfigBuilder

<add name="AzureKeyVault"
    [mode|prefix|stripPrefix|tokenPattern]
    (vaultName="MyVaultName" |
     uri="https:/MyVaultName.vault.azure.net")
    [version="secrets version"]
    [preloadSecretNames="true"]
    type="Microsoft.Configuration.ConfigurationBuilders.AzureKeyVaultConfigBuilder,
    Microsoft.Configuration.ConfigurationBuilders.Azure" />

AzureKeyVaultConfigBuilder odczytuje wartości przechowywane w Azure Key Vault.

vaultName jest wymagana (nazwa magazynu lub identyfikator URI magazynu). Inne atrybuty umożliwiają kontrolę nad tym, z którym magazynem ma zostać nawiązane połączenie, ale tylko wtedy, gdy aplikacja nie działa w środowisku, w którym działa program Microsoft.Azure.Services.AppAuthentication . Biblioteka uwierzytelniania usług platformy Azure służy do automatycznego pobierania informacji o połączeniu ze środowiska wykonywania, jeśli jest to możliwe. Można przesłonić automatyczne pobranie informacji o połączeniu, podając parametry połączenia.

• vaultName -Wymagane, jeśli uri nie jest podany. Określa nazwę magazynu w ramach subskrypcji platformy Azure, z którego ma zostać odczytana para klucz/wartość.
• uri — Nawiązuje połączenie z innymi dostawcami Key Vault o określonej uri wartości. Jeśli nie zostanie określony, platforma Azure ( vaultName ) jest dostawcą magazynu.
• version -Azure Key Vault udostępnia funkcję przechowywania wersji dla wpisów tajnych. Jeśli version jest określony, Konstruktor pobiera tylko wpisy tajne pasujące do tej wersji.
• preloadSecretNames -Domyślnie ten Konstruktor bada wszystkie nazwy kluczy w magazynie kluczy po jego zainicjowaniu. Aby uniemożliwić odczytywanie wszystkich wartości klucza, ustaw ten atrybut na false . Ustawienie tej opcji umożliwia false odczytywanie wpisów tajnych pojedynczo. Odczytywanie wpisów tajnych po jednej naraz może być przydatne, jeśli magazyn zezwala na dostęp "Get", ale nie do "list". Uwaga: W przypadku korzystania z Greedy trybu preloadSecretNames musi być true (wartość domyślna).

KeyPerFileConfigBuilder

<add name="KeyPerFile"
    [mode|prefix|stripPrefix|tokenPattern]
    (directoryPath="PathToSourceDirectory")
    [ignorePrefix="ignore."]
    [keyDelimiter=":"]
    [optional="false"]
    type="Microsoft.Configuration.ConfigurationBuilders.KeyPerFileConfigBuilder,
    Microsoft.Configuration.ConfigurationBuilders.KeyPerFile" />

KeyPerFileConfigBuilder to podstawowy Konstruktor konfiguracji, który używa plików katalogu jako źródła wartości. Nazwa pliku jest kluczem, a zawartość jest wartością. Ten konstruktor konfiguracji może być przydatny w przypadku uruchamiania w środowisku organizowania kontenerów. Systemy takie jak Docker Swarm i Kubernetes zapewniają secrets swoje zorganizowane kontenery systemu Windows w tym samym pliku.

Szczegóły atrybutu:

• directoryPath Potrzeb. Określa ścieżkę do przeszukiwania wartości. Wpisy tajne Docker for Windows są domyślnie przechowywane w katalogu C:\ProgramData\Docker\secrets .
• ignorePrefix -Pliki, które zaczynają się od tego prefiksu, są wykluczone. Wartość domyślna to "Ignore.".
• keyDelimiter -Wartość domyślna to null . Jeśli ta wartość jest określona, Konstruktor konfiguracji przechodzi przez wiele poziomów katalogu, tworząc nazwy kluczy przy użyciu tego ogranicznika. Jeśli ta wartość jest równa null , Konstruktor konfiguracji będzie wyglądał tylko na najwyższym poziomie katalogu.
• optional -Wartość domyślna to false . Określa, czy Konstruktor konfiguracji powinien spowodować błędy, jeśli katalog źródłowy nie istnieje.

SimpleJsonConfigBuilder

<add name="SimpleJson"
    [mode|prefix|stripPrefix|tokenPattern]
    jsonFile="~\config.json"
    [optional="true"]
    [jsonMode="(Flat|Sectional)"]
    type="Microsoft.Configuration.ConfigurationBuilders.SimpleJsonConfigBuilder,
    Microsoft.Configuration.ConfigurationBuilders.Json" />

Projekty .NET Core często używają plików JSON do konfiguracji. Konstruktor SimpleJsonConfigBuilder umożliwia korzystanie z plików języka JSON platformy .NET Core w .NET Framework. Ten konstruktor konfiguracji zapewnia podstawowe mapowanie ze źródła klucza prostego/wartości do określonych obszarów klucz/wartość konfiguracji .NET Framework. Ten program Configuration Builder nie zapewnia konfiguracji hierarchicznych. Plik kopii zapasowej JSON jest podobny do słownika, a nie złożonego obiektu hierarchicznego. Można użyć wielopoziomowego pliku hierarchicznego. Ten dostawca flatten s głębokości przez dołączenie nazwy właściwości na każdym poziomie przy użyciu : jako ogranicznika.

Szczegóły atrybutu:

• jsonFile Potrzeb. Określa plik JSON, z którego ma zostać odczytany. Ten ~ znak może być używany na początku do odwoływania się do katalogu głównego aplikacji.

• optional -Boolean, wartość domyślna to true . Zapobiega zgłaszaniu wyjątków, jeśli nie można znaleźć pliku JSON.

• jsonMode - [Flat|Sectional]. Wartość domyślna to Flat. Gdy jsonMode ma wartość Flat , plik JSON jest pojedynczym prostym źródłem klucza/wartości. EnvironmentConfigBuilderI AzureKeyVaultConfigBuilder są również pojedynczymi płaskimi źródłami klucz/wartość. Gdy SimpleJsonConfigBuilder jest skonfigurowany w Sectional trybie:

  • Plik JSON jest koncepcyjnie podzielony na najwyższego poziomu do wielu słowników.
  • Każdy słownik jest stosowany tylko do sekcji konfiguracji, która pasuje do dołączonej nazwy właściwości najwyższego poziomu. Na przykład:

    {
        "appSettings" : {
            "setting1" : "value1",
            "setting2" : "value2",
            "complex" : {
                "setting1" : "complex:value1",
                "setting2" : "complex:value2",
            }
        }
    }

Kolejność kompilacji konfiguracji

Zobacz kolejność wykonywania ConfigurationBuilders w repozytorium GitHub /MicrosoftConfigurationBuilders .

Implementowanie niestandardowego konstruktora konfiguracji klucza/wartości

Jeśli konstruktorzy konfiguracji nie spełnią Twoich potrzeb, można napisać ją niestandardową. KeyValueConfigBuilderKlasa bazowa obsługuje tryby podstawienia i większość kwestii związanych z prefiksami. Wdrożenie projektu wymaga tylko:

• Dziedzicz z klasy podstawowej i zaimplementuj podstawowe źródło par klucz/wartość za pomocą GetValue i GetAllValues :
• Dodaj Microsoft.Configuration.ConfigurationBuilders. Base do projektu.

using Microsoft.Configuration.ConfigurationBuilders;
using System.Collections.Generic;

public class MyCustomConfigBuilder : KeyValueConfigBuilder
{
    public override string GetValue(string key)
    {
        // Key lookup should be case-insensitive, because most key/value collections in 
        // .NET Framework config sections are case-insensitive.
        return "Value for given key, or null.";
    }

    public override ICollection<KeyValuePair<string, string>> GetAllValues(string prefix)
    {
        // Populate the return collection.
        return new Dictionary<string, string>() { { "one", "1" }, { "two", "2" } };
    }
}

KeyValueConfigBuilderKlasa bazowa zapewnia większość pracy i spójne zachowanie między konstruktorami konfiguracji klucz/wartość.

Dodatkowe zasoby

• Repozytorium GitHub dla konstruktorów konfiguracji
• Uwierzytelnianie między usługami Azure Key Vault przy użyciu platformy .NET