Entity Framework - Code First - Impossible de stocker la liste <String>

J'ai écrit une telle classe:

class Test
{
    [Key]
    [DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }
    [Required]
    public List<String> Strings { get; set; }

    public Test()
    {
        Strings = new List<string>
        {
            "test",
            "test2",
            "test3",
            "test4"
        };
    }
}

et

internal class DataContext : DbContext
{
    public DbSet<Test> Tests { get; set; }
}

Après l'exécution du code:

var db = new DataContext();
db.Tests.Add(new Test());
db.SaveChanges();

mes données sont enregistrées mais juste le fichier Id. Je n'ai pas de tables ni de relations applicables à la liste des chaînes .

Qu'est-ce que je fais mal? J'ai aussi essayé de faire des cordes virtual mais cela n'a rien changé.

Merci de votre aide.

Entity Framework ne prend pas en charge les collections de types primitifs. Vous pouvez créer une entité (qui sera enregistrée dans une table différente) ou effectuer un traitement de chaîne pour enregistrer votre liste sous forme de chaîne et remplir la liste une fois l'entité matérialisée.

EF Core 2.1+:

Propriété:

public string[] Strings { get; set; }

OnModelCreating:

modelBuilder.Entity<YourEntity>()
            .Property(e => e.Strings)
            .HasConversion(
                v => string.Join(',', v),
                v => v.Split(',', StringSplitOptions.RemoveEmptyEntries));

Cette réponse est basée sur celles fournies par @Sasan et @CAD bloke .

Fonctionne uniquement avec EF Core 2.1+ (non compatible avec .NET Standard) (Newtonsoft JsonConvert )

builder.Entity<YourEntity>().Property(p => p.Strings)
    .HasConversion(
        v => JsonConvert.SerializeObject(v),
        v => JsonConvert.DeserializeObject<List<string>>(v));

En utilisant la configuration fluide EF Core, nous sérialisons / désérialisons le List vers / depuis JSON.

Pourquoi ce code est le mélange parfait de tout ce que vous pouvez rechercher:

• Le problème avec la réponse originale de Sasn est qu'elle se transformera en gros désordre si les chaînes de la liste contiennent des virgules (ou tout caractère choisi comme délimiteur) car cela transformera une seule entrée en plusieurs entrées, mais c'est la plus facile à lire et le plus concis.
• Le problème avec la réponse de type CAO est qu'elle est moche et nécessite que le modèle soit modifié, ce qui est une mauvaise pratique de conception (voir le commentaire de Marcell Toth sur la réponse de Sasan ). Mais c'est la seule réponse qui soit sûre pour les données.

Je sais que c'est une vieille question, et Pawel a donné la bonne réponse , je voulais juste montrer un exemple de code sur la façon de traiter des chaînes et éviter une classe supplémentaire pour la liste d'un type primitif.

public class Test
{
    public Test()
    {
        _strings = new List<string>
        {
            "test",
            "test2",
            "test3",
            "test4"
        };
    }

    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    private List<String> _strings { get; set; }

    public List<string> Strings
    {
        get { return _strings; }
        set { _strings = value; }
    }

    [Required]
    public string StringsAsString
    {
        get { return String.Join(',', _strings); }
        set { _strings = value.Split(',').ToList(); }
    }
}

JSON.NET à la rescousse.

Vous le sérialisez en JSON pour qu'il persiste dans la base de données et le désérialisez pour reconstituer la collection .NET. Cela semble fonctionner mieux que ce à quoi je m'attendais avec Entity Framework 6 et SQLite. Je sais que vous avez demandé List<string>mais voici un exemple de collection encore plus complexe qui fonctionne très bien.

J'ai marqué la propriété persistante avec [Obsolete]donc il serait très évident pour moi que "ce n'est pas la propriété que vous recherchez" dans le cours normal du codage. La propriété "real" est étiquetée avec [NotMapped]donc Entity Framework l'ignore.

(tangente non liée): Vous pourriez faire la même chose avec des types plus complexes, mais vous devez vous demander si vous avez simplement rendu l'interrogation des propriétés de cet objet trop difficile pour vous? (oui, dans mon cas).

using Newtonsoft.Json;
....
[NotMapped]
public Dictionary<string, string> MetaData { get; set; } = new Dictionary<string, string>();

/// <summary> <see cref="MetaData"/> for database persistence. </summary>
[Obsolete("Only for Persistence by EntityFramework")]
public string MetaDataJsonForDb
{
    get
    {
        return MetaData == null || !MetaData.Any()
                   ? null
                   : JsonConvert.SerializeObject(MetaData);
    }

    set
    {
        if (string.IsNullOrWhiteSpace(value))
           MetaData.Clear();
        else
           MetaData = JsonConvert.DeserializeObject<Dictionary<string, string>>(value);
    }
}

Juste pour simplifier -

Le cadre d'entité ne prend pas en charge les primitives. Vous créez une classe pour l'encapsuler ou ajoutez une autre propriété pour mettre en forme la liste sous forme de chaîne:

public ICollection<string> List { get; set; }
public string ListString
{
    get { return string.Join(",", List); }
    set { List = value.Split(',').ToList(); }
}

Bien sûr, Pawel a donné la bonne réponse . Mais j'ai trouvé dans cet article que depuis EF 6+, il est possible de sauvegarder des propriétés privées. Je préférerais donc ce code, car vous ne pouvez pas enregistrer les chaînes de manière incorrecte.

public class Test
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int Id { get; set; }

    [Column]
    [Required]
    private String StringsAsStrings { get; set; }

    public List<String> Strings
    {
        get { return StringsAsStrings.Split(',').ToList(); }
        set
        {
            StringsAsStrings = String.Join(",", value);
        }
    }
    public Test()
    {
        Strings = new List<string>
        {
            "test",
            "test2",
            "test3",
            "test4"
        };
    }
}

Tordant légèrement @Mathieu Viales de » la réponse , voici un extrait standard .NET compatible à l' aide de la nouvelle sérialiseur System.Text.Json éliminant ainsi la dépendance à l' égard Newtonsoft.Json.

using System.Text.Json;

builder.Entity<YourEntity>().Property(p => p.Strings)
    .HasConversion(
        v => JsonSerializer.Serialize(v, default),
        v => JsonSerializer.Deserialize<List<string>>(v, default));

Notez que bien que le deuxième argument dans les deux Serialize()et Deserialize()soit généralement facultatif, vous obtiendrez une erreur:

Une arborescence d'expression ne peut pas contenir un appel ou une invocation qui utilise des arguments facultatifs

Définir explicitement cela sur la valeur par défaut (null) pour chacun efface cela.

Vous pouvez utiliser ce ScalarCollectionconteneur qui limite un tableau et fournit des options de manipulation ( Gist ):

Usage:

public class Person
{
    public int Id { get; set; }
    //will be stored in database as single string.
    public SaclarStringCollection Phones { get; set; } = new ScalarStringCollection();
}

Code:

using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;

namespace System.Collections.Specialized
{
#if NET462
  [ComplexType]
#endif
  public abstract class ScalarCollectionBase<T> :
#if NET462
    Collection<T>,
#else
    ObservableCollection<T>
#endif
  {
    public virtual string Separator { get; } = "\n";
    public virtual string ReplacementChar { get; } = " ";
    public ScalarCollectionBase(params T[] values)
    {
      if (values != null)
        foreach (var item in Items)
          Items.Add(item);
    }

#if NET462
    [Browsable(false)]
#endif
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Obsolete("Not to be used directly by user, use Items property instead.")]
    public string Data
    {
      get
      {
        var data = Items.Select(item => Serialize(item)
          .Replace(Separator, ReplacementChar.ToString()));
        return string.Join(Separator, data.Where(s => s?.Length > 0));
      }
      set
      {
        Items.Clear();
        if (string.IsNullOrWhiteSpace(value))
          return;

        foreach (var item in value
            .Split(new[] { Separator }, 
              StringSplitOptions.RemoveEmptyEntries).Select(item => Deserialize(item)))
          Items.Add(item);
      }
    }

    public void AddRange(params T[] items)
    {
      if (items != null)
        foreach (var item in items)
          Add(item);
    }

    protected abstract string Serialize(T item);
    protected abstract T Deserialize(string item);
  }

  public class ScalarStringCollection : ScalarCollectionBase<string>
  {
    protected override string Deserialize(string item) => item;
    protected override string Serialize(string item) => item;
  }

  public class ScalarCollection<T> : ScalarCollectionBase<T>
    where T : IConvertible
  {
    protected override T Deserialize(string item) =>
      (T)Convert.ChangeType(item, typeof(T));
    protected override string Serialize(T item) => Convert.ToString(item);
  }
}