Entity Framework - Code First - Impossibile archiviare l'elenco <String>

Ho scritto una lezione del genere:

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"
        };
    }
}

e

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

Dopo il codice di esecuzione:

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

i miei dati vengono salvati ma solo il file Id. Non ho tabelle né relazioni applicabili all'elenco delle stringhe .

Che cosa sto facendo di sbagliato? Ho provato anche a fare degli archi virtual ma non è cambiato nulla.

Grazie per l'aiuto.

Entity Framework non supporta le raccolte di tipi primitivi. È possibile creare un'entità (che verrà salvata in una tabella diversa) o eseguire un'elaborazione di stringhe per salvare l'elenco come stringa e popolare l'elenco dopo che l'entità è stata materializzata.

EF Core 2.1 e versioni successive:

Proprietà:

public string[] Strings { get; set; }

OnModelCreating:

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

Questa risposta si basa su quelle fornite da @Sasan e @CAD bloke .

Funziona solo con EF Core 2.1+ (non compatibile con .NET Standard) (Newtonsoft JsonConvert)

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

Usando la configurazione fluente di EF Core serializziamo / deserializziamo il Listto / from JSON.

Perché questo codice è il mix perfetto di tutto ciò per cui potresti lottare:

• Il problema con la risposta originale di Sasn è che si trasformerà in un grande pasticcio se le stringhe nell'elenco contengono virgole (o qualsiasi carattere scelto come delimitatore) perché trasformerà una singola voce in più voci ma è la più facile da leggere e molto conciso.
• Il problema con la risposta del tizio CAD è che è brutta e richiede la modifica del modello, il che è una cattiva pratica di progettazione (vedere il commento di Marcell Toth sulla risposta di Sasan ). Ma è l'unica risposta sicura per i dati.

So che questa è una vecchia domanda e Pawel ha dato la risposta corretta , volevo solo mostrare un esempio di codice su come eseguire un'elaborazione di stringhe ed evitare una classe extra per l'elenco di un tipo primitivo.

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 in soccorso.

Puoi serializzarlo in JSON per persistere nel database e deserializzarlo per ricostituire la raccolta .NET. Questo sembra funzionare meglio di quanto mi aspettassi con Entity Framework 6 e SQLite. So che l'hai chiesto, List<string>ma ecco un esempio di una collezione ancora più complessa che funziona perfettamente.

Ho etichettato la proprietà persistente con [Obsolete]così sarebbe molto ovvio per me che "questa non è la proprietà che stai cercando" nel normale corso della codifica. La proprietà "reale" è contrassegnata con [NotMapped]così Entity framework la ignora.

(tangente non correlata): potresti fare lo stesso con tipi più complessi, ma devi chiederti se hai appena reso troppo difficile per te stesso interrogare le proprietà di quell'oggetto? (sì, nel mio caso).

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);
    }
}

Solo per semplificare -

Entity Framework non supporta le primitive. Puoi creare una classe per racchiuderla o aggiungere un'altra proprietà per formattare l'elenco come una stringa:

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

Ovviamente Pawel ha dato la risposta giusta . Ma l'ho trovato in questo post che da EF 6+ è possibile salvare proprietà private. Quindi preferirei questo codice, perché non sei in grado di salvare le stringhe in modo sbagliato.

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"
        };
    }
}

Un po 'tweaking @Mathieu Viales 's risposta , ecco un frammento di .NET compatibile standard utilizzando il nuovo serializzatore System.Text.Json eliminando così la dipendenza 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));

Nota che mentre il secondo argomento in entrambi Serialize()e Deserialize()è in genere facoltativo, riceverai un errore:

Un albero delle espressioni non può contenere una chiamata o una chiamata che utilizza argomenti opzionali

L'impostazione esplicita di quello al valore predefinito (null) per ciascuno lo cancella.

È possibile utilizzare questo ScalarCollectioncontenitore che delimita un array e fornisce alcune opzioni di manipolazione ( Gist ):

Utilizzo:

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

Codice:

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);
  }
}