Kerangka Kerja Entitas - Kode Pertama - Tidak Dapat Menyimpan Daftar <String>

Saya menulis kelas seperti itu:

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

dan

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

Setelah menjalankan kode:

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

data saya disimpan tetapi hanya file Id. Saya tidak memiliki tabel atau hubungan apa pun yang berlaku untuk daftar String .

Apa yang saya lakukan salah? Saya juga mencoba membuat Strings virtual tetapi tidak mengubah apa pun.

Terima kasih untuk bantuannya.

Kerangka Kerja Entitas tidak mendukung kumpulan tipe primitif. Anda dapat membuat entitas (yang akan disimpan ke tabel yang berbeda) atau melakukan beberapa pemrosesan string untuk menyimpan daftar Anda sebagai string dan mengisi daftar setelah entitas terwujud.

EF Core 2.1+:

Properti:

public string[] Strings { get; set; }

OnModelCreating:

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

Jawaban ini berdasarkan yang diberikan oleh @Sasan dan @CAD bloke .

Hanya bekerja dengan EF Core 2.1+ (tidak kompatibel .NET Standard) (Newtonsoft JsonConvert)

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

Dengan menggunakan konfigurasi fasih EF Core, kami membuat serial / deserialisasi List ke / dari JSON.

Mengapa kode ini adalah perpaduan sempurna dari semua yang dapat Anda perjuangkan:

• Masalah dengan jawaban asli Sasn adalah bahwa itu akan menjadi kekacauan besar jika string dalam daftar berisi koma (atau karakter apapun yang dipilih sebagai pembatas) karena itu akan mengubah satu entri menjadi beberapa entri tetapi paling mudah dibaca dan paling ringkas.
• Masalah dengan jawaban pria CAD adalah bahwa itu jelek dan membutuhkan model untuk diubah yang merupakan praktek desain yang buruk (lihat komentar Marcell Toth tentang jawaban Sasan ). Tapi itu satu-satunya jawaban yang aman untuk data.

Saya tahu ini adalah pertanyaan lama, dan Pawel telah memberikan jawaban yang benar , saya hanya ingin menunjukkan contoh kode cara melakukan pemrosesan string, dan menghindari kelas tambahan untuk daftar tipe 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 untuk menyelamatkan.

Anda membuat serial ke JSON untuk bertahan dalam Database dan Deserialisasi untuk menyusun kembali koleksi .NET. Ini tampaknya berkinerja lebih baik dari yang saya harapkan dengan Entity Framework 6 & SQLite. Saya tahu Anda memintanya, List<string>tetapi berikut adalah contoh koleksi yang bahkan lebih kompleks yang berfungsi dengan baik.

Saya menandai properti yang dipertahankan dengan [Obsolete]sehingga akan sangat jelas bagi saya bahwa "ini bukan properti yang Anda cari" dalam proses pengkodean normal. Properti "nyata" diberi tag[NotMapped] sehingga kerangka Entitas mengabaikannya.

(tangen tidak terkait): Anda dapat melakukan hal yang sama dengan tipe yang lebih kompleks tetapi Anda perlu bertanya pada diri sendiri apakah Anda hanya membuat kueri properti objek itu terlalu sulit untuk diri Anda sendiri? (ya, dalam kasus saya).

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

Hanya untuk menyederhanakan -

Kerangka entitas tidak mendukung primitif. Anda bisa membuat kelas untuk membungkusnya atau menambahkan properti lain untuk memformat daftar sebagai string:

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

Tentu Pawel sudah memberikan jawaban yang benar . Tetapi saya menemukan dalam posting ini bahwa sejak EF 6+ dimungkinkan untuk menyimpan properti pribadi. Jadi saya lebih suka kode ini, karena Anda tidak dapat menyimpan String dengan cara yang salah.

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

Sedikit tweaker @Mathieu Viales 's jawaban , di sini adalah potongan NET Standard kompatibel menggunakan serializer System.Text.Json baru sehingga menghilangkan ketergantungan pada 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));

Perhatikan bahwa sementara argumen kedua di keduanya Serialize()dan Deserialize()biasanya opsional, Anda akan mendapatkan kesalahan:

Pohon ekspresi tidak boleh berisi panggilan atau pemanggilan yang menggunakan argumen opsional

Secara eksplisit mengaturnya ke default (null) untuk setiap membersihkannya.

Anda dapat menggunakan ScalarCollectioncontainer ini yang membatasi array dan menyediakan beberapa opsi manipulasi ( Gist ):

Pemakaian:

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

Kode:

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