Entity Framework - Code First - Can't Store List <String>

Napisałem taką klasę:

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

i

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

Po uruchomieniu kodu:

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

moje dane są zapisywane, ale tylko plik Id. Nie mam żadnych tabel ani relacji odnoszących się do listy ciągów .

Co ja robię źle? Próbowałem też stworzyć Strings, virtual ale to niczego nie zmieniło.

Dziękuję za pomoc.

Entity Framework nie obsługuje kolekcji typów pierwotnych. Możesz utworzyć encję (która zostanie zapisana w innej tabeli) lub wykonać przetwarzanie na łańcuchach, aby zapisać listę jako ciąg i zapełnić listę po zmaterializowaniu encji.

EF Core 2.1+:

Własność:

public string[] Strings { get; set; }

OnModelCreating:

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

Ta odpowiedź jest oparta na tych dostarczonych przez @Sasan i bloke @CAD .

Działa tylko z EF Core 2.1+ (niezgodnym z .NET Standard) (Newtonsoft JsonConvert)

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

Korzystając z konfiguracji EF Core Fluent, serializujemy / deserializujemy Listdo / z formatu JSON.

Dlaczego ten kod jest idealnym połączeniem wszystkiego, do czego możesz dążyć:

• Problem z oryginalną odpowiedzią Sasn polega na tym, że zmieni się w duży bałagan, jeśli ciągi na liście będą zawierały przecinki (lub dowolny znak wybrany jako separator), ponieważ zamieni pojedynczy wpis w wiele wpisów, ale jest najłatwiejszy do odczytania i najbardziej zwięzłe.
• Problem z odpowiedzią gościa z CAD polega na tym, że jest brzydka i wymaga zmiany modelu, co jest złą praktyką projektową (patrz komentarz Marcella Totha na temat odpowiedzi Sasana ). Ale to jedyna odpowiedź, która jest bezpieczna dla danych.

Wiem, że to stare pytanie, a Paweł udzielił poprawnej odpowiedzi. Chciałem tylko pokazać przykład kodu pokazujący, jak przetwarzać ciągi znaków i uniknąć dodatkowej klasy dla listy typów pierwotnych.

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 na ratunek.

Możesz serializować go do formatu JSON, aby zachować go w bazie danych, i deserializować go w celu ponownego utworzenia kolekcji .NET. Wydaje się, że działa lepiej, niż się spodziewałem w przypadku Entity Framework 6 i SQLite. Wiem, o co prosiłeśList<string> ale oto przykład jeszcze bardziej złożonej kolekcji, która działa dobrze.

Oznaczyłem utrwaloną właściwość, [Obsolete]więc byłoby dla mnie bardzo oczywiste, że „to nie jest właściwość, której szukasz” w normalnym toku kodowania. Właściwość „real” jest oznaczona tagiem, [NotMapped]więc Entity framework ją ignoruje.

(niepowiązana styczna): Możesz zrobić to samo z bardziej złożonymi typami, ale musisz zadać sobie pytanie, czy sprawiłeś, że zapytanie o właściwości tego obiektu było dla siebie zbyt trudne? (tak, w moim przypadku).

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

Tylko dla uproszczenia -

Entity Framework nie obsługuje prymitywów. Możesz utworzyć klasę, aby ją opakować, lub dodać inną właściwość, aby sformatować listę jako ciąg:

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

Oczywiście Paweł udzielił właściwej odpowiedzi . Ale znalazłem w tym poście, że od EF 6+ można zapisywać prywatne nieruchomości. Więc wolałbym ten kod, ponieważ nie możesz zapisać ciągów znaków w niewłaściwy sposób.

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

Niewielkie szczypanie @Mathieu Viales „s odpowiedź , oto fragment kompatybilny NET Standardowy użyciu nowego System.Text.Json serializatora eliminując w ten sposób zależność od 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));

Zauważ, że chociaż drugi argument w obu Serialize()i Deserialize()zazwyczaj jest opcjonalny, pojawi się błąd:

Drzewo wyrażenia nie może zawierać wywołania ani wywołania używającego opcjonalnych argumentów

Jawne ustawienie wartości domyślnej (null) dla każdego usuwa to.

Możesz użyć tego ScalarCollectionkontenera, który ogranicza tablicę i zapewnia pewne opcje manipulacji ( Gist ):

Stosowanie:

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

Kod:

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