Entity Framework - Code First - Liste <String> kann nicht gespeichert werden

Ich habe eine solche Klasse geschrieben:

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

und

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

Nach dem Ausführen von Code:

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

Meine Daten werden gespeichert, aber nur die Id. Ich habe keine Tabellen oder Beziehungen, die für die Strings- Liste gelten.

Was mache ich falsch? Ich habe auch versucht, Strings zu machen, virtualaber es hat nichts geändert.

Danke für Ihre Hilfe.

Entity Framework unterstützt keine Sammlungen primitiver Typen. Sie können entweder eine Entität erstellen (die in einer anderen Tabelle gespeichert wird) oder eine Zeichenfolgenverarbeitung durchführen, um Ihre Liste als Zeichenfolge zu speichern und die Liste zu füllen, nachdem die Entität materialisiert wurde.

EF Core 2.1+:

Eigentum:

public string[] Strings { get; set; }

OnModelCreating:

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

Diese Antwort basiert auf denen von @Sasan und @CAD .

Funktioniert nur mit EF Core 2.1+ (nicht .NET Standard-kompatibel) (Newtonsoft JsonConvert)

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

Unter Verwendung der fließenden EF Core-Konfiguration serialisieren / deserialisieren wir das Listzu / von JSON.

Warum dieser Code die perfekte Mischung aus allem ist, was Sie anstreben könnten:

• Das Problem mit Sasns ursprünglicher Antwort ist, dass es zu einem großen Durcheinander wird, wenn die Zeichenfolgen in der Liste Kommas (oder ein beliebiges als Trennzeichen ausgewähltes Zeichen) enthalten, da ein einzelner Eintrag in mehrere Einträge umgewandelt wird, aber am einfachsten zu lesen ist am prägnantesten.
• Das Problem mit der Antwort von CAD-Typen ist, dass sie hässlich ist und eine Änderung des Modells erfordert, was eine schlechte Konstruktionspraxis darstellt (siehe Marcell Toths Kommentar zu Sasans Antwort ). Aber es ist die einzige Antwort, die datensicher ist.

Ich weiß, dass dies eine alte Frage ist, und Pawel hat die richtige Antwort gegeben . Ich wollte nur ein Codebeispiel für die Verarbeitung von Zeichenfolgen zeigen und eine zusätzliche Klasse für die Liste eines primitiven Typs vermeiden.

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 zur Rettung.

Sie serialisieren es in JSON, um in der Datenbank zu bleiben, und deserialisieren es, um die .NET-Sammlung wiederherzustellen. Dies scheint mit Entity Framework 6 und SQLite besser zu funktionieren, als ich erwartet hatte. Ich weiß, dass Sie danach gefragt haben, List<string>aber hier ist ein Beispiel für eine noch komplexere Sammlung, die einwandfrei funktioniert.

Ich habe die persistierte Eigenschaft mit markiert, [Obsolete]sodass es für mich sehr offensichtlich ist, dass "dies nicht die Eigenschaft ist, nach der Sie suchen" im normalen Verlauf der Codierung. Die "echte" Eigenschaft ist mit gekennzeichnet, [NotMapped]sodass das Entity-Framework sie ignoriert.

(nicht verwandte Tangente): Sie könnten dasselbe mit komplexeren Typen tun, aber Sie müssen sich fragen, haben Sie es sich nur zu schwer gemacht, die Eigenschaften dieses Objekts abzufragen? (Ja, in meinem Fall).

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

Nur zur Vereinfachung -

Das Entity Framework unterstützt keine Grundelemente. Sie erstellen entweder eine Klasse zum Umschließen oder fügen eine weitere Eigenschaft hinzu, um die Liste als Zeichenfolge zu formatieren:

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

Natürlich hat Pawel die richtige Antwort gegeben . Aber ich habe in diesem Beitrag festgestellt, dass es seit EF 6+ möglich ist, private Immobilien zu speichern. Daher würde ich diesen Code bevorzugen, da Sie die Zeichenfolgen nicht falsch speichern können.

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

Ein wenig zwicken @Mathieu Viales ‚s Antwort , hier ist ein .NET - Standard kompatibel Schnipsel des neuen System.Text.Json Serializer mit damit die Abhängigkeit von Newtonsoft.Json beseitigen.

using System.Text.Json;

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

Beachten Sie, dass das zweite Argument in beiden Serialize()und Deserialize()normalerweise optional ist, Sie jedoch eine Fehlermeldung erhalten:

Ein Ausdrucksbaum darf keinen Aufruf oder Aufruf enthalten, der optionale Argumente verwendet

Wenn Sie dies explizit auf den Standardwert (null) setzen, wird dies gelöscht.

Sie können diesen ScalarCollectionContainer verwenden, der ein Array begrenzt und einige Manipulationsoptionen bietet ( Gist ):

Verwendung:

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