.NET de Base utilisation de la Configuration à se lier à des Options avec le Tableau

À l'aide de l' .NET de Base Microsoft.Extensions.Configuration est-il possible de se lier à une Configuration à un objet qui contient un tableau?

ConfigurationBinder a une méthode BindArray, donc je suppose que cela fonctionnerait.

Mais quand j'ai essayer j'obtiens une exception:

System.NotSupportedException: ArrayConverter cannot convert from System.String.

Voici mon allégée code:

public class Test
{
   private class ExampleOption
   { 
      public int[] Array {get;set;}
   }

   [Test]
   public void CanBindArray()
   {
       //ARRANGE
       var config =
            new ConfigurationBuilder()
            .AddInMemoryCollection(new List<KeyValuePair<string, string>>
            {
                new KeyValuePair<string, string>("Array", "[1,2,3]")
            })
            .Build();

        var exampleOption= new ExampleOption();

        //ACT
        config.Bind(complexOptions); //throws exception

       //ASSERT
       exampleOption.ShouldContain(1);
   }
}

L'exemple de la propriété "Tableau" est un peu difficile pour les explications 😉 je l'ai corrigé mais il y avait déjà une autre réponse et un commentaire qui je ne pouvais pas correct.

OriginalL'auteur Philip Pittle | 2016-06-15

.net-core asp.net-core c#configuration

18

L'erreur est dans votre définition d'entrée. L'exemple définit une clé "Tableau" pour une valeur de chaîne "[1,2,3]" (dans le C# en fonction InMemoryCollection) et fait l'hypothèse qu'il est analysé JSON style. Ce qui est mauvais. Il n'est pas analysée.

L'encodage de la convention de tableau de valeurs dans le système de configuration est en répétant la clé avec un signe deux-points et d'un indice derrière lui. L'exemple suivant fonctionne comme vous avez l'intention de faire:
```
var config = new ConfigurationBuilder()
        .AddInMemoryCollection(new List<KeyValuePair<string, string>>
        {
            new KeyValuePair<string, string>("Array:0", "1"),
            new KeyValuePair<string, string>("Array:1", "2"),
            new KeyValuePair<string, string>("Array:2", "3")
        })
        .Build();
```
Les points-clés de répéter le schéma se produit également si le fichier JSON est utilisé (ici par un appel supplémentaire à AddJsonFile) ...
```
{
  "mySecondArray":  [1, 2, 3]
}
```
la résultante combinée de configuration contenant les clés qui suivent le même modèle, comme illustré dans l'utilisation de la mémoire ci-dessus:
```
Count = 8
[0]: {[mySecondArray, ]}
[1]: {[mySecondArray:2, 3]}
[2]: {[mySecondArray:1, 2]}
[3]: {[mySecondArray:0, 1]}
[4]: {[Array, ]}
[5]: {[Array:2, 3]}
[6]: {[Array:1, 2]}
[7]: {[Array:0, 1]}
```
Le système de configuration est agnostique pour les formats de stockage comme JSON/INI/XML/... et est essentiellement juste un string->string dictionnaire du côlon faire une hiérarchie à l'intérieur de la clé.

Liaison est alors en mesure d'interpréter une partie de la hiérarchie par conventions et, par conséquent, se lie également les tableaux, les collections, les objets et les dictionnaires. Il est intéressant pour les tableaux, il ne se soucie pas de les chiffres derrière le côlon, mais juste itérer les enfants de la section de configuration (ici "Array") et de prendre les valeurs de l'enfants. Le tri des enfants, prend les numéros de compte, mais aussi, sortes de chaînes comme une deuxième option (OrdinalIgnoreCase).

Yup, c'est totalement fait le tour!
Le système de configuration de ASP.NET est vraiment agréable et utile morceau de technologie aussi à l'extérieur de ASP.NET. Devrait être à tout le monde de la boîte à outils.
Ici Ici! Rapide de la tangente: Avez-vous vu toute la documentation/les blogs sur la façon de câbler jusqu' IOptions à l'aide de la 3ème partie DI? J'ai construit un prototype à l'aide de Ninject, mais pas sûr que j'ai un support complet pour tout, et surtout de ChangeTokens.
Aucune Idée. Je suis faible sur les options de la rubrique.

OriginalL'auteur Thomas
5

Vous pouvez configurer ExampleOptionavec le code dans ConfigureServices méthode:
```
 public void ConfigureServices(IServiceCollection services)
 {
      services.Configure<ExampleOption>(myOptions =>
      {
          myOptions.Array = new int[] { 1, 2, 3 };
      });
 }
```
ou si vous souhaitez utiliser json fichier de configuration

appsettings.json:
```
{
  "ExampleOption": {
     "Array": [1,2,3]
  }
}
```
ConfigureServices:
```
public void ConfigureServices(IServiceCollection services)
{
    services.Configure<ExampleOption>(Configuration.GetSection("ExampleOption"));
}
```
Est-il possible de le faire sans les Options des Extensions? En utilisant seulement ConfigurationBinder? Et quand j'utilise "Array":"[1,2,3]" dans la Configuration de la Mémoire, c'est quand j'ai le ArraryConverter exception que j'ai cité. Dites-vous qu'il fonctionne dans un fichier Json?
je ne sais pas si il existe un moyen de résoudre sans les Options des Extensions, mais dans un fichier json qu'il fonctionne comme prévu.
Merci de répondre ici. Il est bon de savoir que le tableau syntaxe d'initialisation est agréable et simple pour les fichiers Json; mais ne pas s'aligner complètement sur ce que je cherchais dans cette question (à l'aide de AddInMemoryCollection)

OriginalL'auteur adem caglin

Avec les derniers ajouts de langage C# est plus propre d'utiliser les nouvelles syntaxe

var config = new ConfigurationBuilder()
    .AddInMemoryCollection(new Dictionary<string, string>
    {
        { "Array:0", "1" },
        { "Array:1", "2" },
        { "Array:2", "3" },
    })
    .Build();

OriginalL'auteur codevision

Vous devez vous connecter pour publier un commentaire.