Entity Framework - Code First - ไม่สามารถจัดเก็บรายการ <String> ได้

ฉันเขียนคลาสดังกล่าว:

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

และ

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

หลังจากรันโค้ด:

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

ข้อมูลของฉันกำลังได้รับการบันทึก แต่เป็นเพียงไฟล์Id. ฉันไม่มีตารางหรือความสัมพันธ์ใด ๆ ที่ใช้กับรายการสตริง

ผมทำอะไรผิดหรือเปล่า? ฉันพยายามสร้างStrings ด้วย virtualแต่ก็ไม่ได้เปลี่ยนแปลงอะไรเลย

ขอขอบคุณสำหรับความช่วยเหลือของคุณ.

Entity Framework ไม่สนับสนุนคอลเลกชันของชนิดดั้งเดิม คุณสามารถสร้างเอนทิตี (ซึ่งจะถูกบันทึกลงในตารางอื่น) หรือดำเนินการประมวลผลสตริงเพื่อบันทึกรายการของคุณเป็นสตริงและเติมข้อมูลในรายการหลังจากเอนทิตีเป็นรูปธรรม

EF Core 2.1+:

คุณสมบัติ:

public string[] Strings { get; set; }

OnModelCreating:

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

คำตอบนี้จะขึ้นอยู่กับคนที่มีให้โดย@Sasanและ@CAD เจ้าหมอ

หากคุณต้องการใช้สิ่งนี้ใน. NET Standard 2 หรือไม่ต้องการให้ Newtonsoft ดูคำตอบของ Xaniffด้านล่าง

ใช้งานได้กับ EF Core 2.1+ เท่านั้น (ไม่รองรับ. NET Standard) (Newtonsoft JsonConvert)

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

การใช้การกำหนดค่า EF Core ได้อย่างคล่องแคล่วเราทำให้เป็นอนุกรม / แยกส่วน List / จาก JSON

เหตุใดรหัสนี้จึงเป็นส่วนผสมที่ลงตัวของทุกสิ่งที่คุณสามารถทำได้:

• ปัญหาเกี่ยวกับคำตอบเดิมของ Sasn คือมันจะกลายเป็นเรื่องยุ่งเหยิงหากสตริงในรายการมีเครื่องหมายจุลภาค (หรืออักขระใด ๆ ที่ถูกเลือกให้เป็นตัวคั่น) เนื่องจากจะเปลี่ยนรายการเดียวให้เป็นหลายรายการ แต่จะง่ายที่สุดในการอ่านและ รัดกุมที่สุด
• ปัญหาเกี่ยวกับคำตอบของ CAD bloke คือมันน่าเกลียดและต้องมีการเปลี่ยนแปลงโมเดลซึ่งเป็นการออกแบบที่ไม่ดี (ดูความคิดเห็นของ Marcell Toth ในคำตอบของ Sasan ) แต่เป็นคำตอบเดียวที่ปลอดภัยต่อข้อมูล

ฉันรู้ว่านี่เป็นคำถามเก่าและPawel ได้ให้คำตอบที่ถูกต้องฉันแค่ต้องการแสดงตัวอย่างโค้ดเกี่ยวกับวิธีการประมวลผลสตริงและหลีกเลี่ยงคลาสพิเศษสำหรับรายการประเภทดั้งเดิม

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เพื่อช่วยเหลือ

คุณทำให้เป็นอนุกรมเป็น JSON เพื่อคงอยู่ในฐานข้อมูลและยกเลิกการกำหนดค่าสถานะเพื่อสร้างคอลเล็กชัน. NET ใหม่ ดูเหมือนว่าจะทำงานได้ดีกว่าที่ฉันคาดไว้กับ Entity Framework 6 & SQLite ฉันรู้ว่าคุณถามหาList<string>แต่นี่คือตัวอย่างของคอลเลกชันที่ซับซ้อนยิ่งขึ้นซึ่งใช้งานได้ดี

ฉันติดแท็กคุณสมบัติที่ยังคงอยู่ด้วย[Obsolete]ดังนั้นจึงเห็นได้ชัดมากสำหรับฉันว่า "นี่ไม่ใช่คุณสมบัติที่คุณกำลังมองหา" ในการเขียนโค้ดตามปกติ คุณสมบัติ "จริง" ถูกแท็กด้วย[NotMapped]Entity framework จึงละเว้น

(ไม่เกี่ยวข้องแทนเจนต์): คุณสามารถทำเช่นเดียวกันกับประเภทที่ซับซ้อนกว่านี้ได้ แต่คุณต้องถามตัวเองว่าคุณเพิ่งค้นหาคุณสมบัติของวัตถุนั้นยากเกินไปสำหรับตัวคุณเองหรือไม่? (ใช่ในกรณีของฉัน)

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

เพียงเพื่อให้ง่ายขึ้น -

เอนทิตีเฟรมเวิร์กไม่รองรับแบบดั้งเดิม คุณสร้างคลาสเพื่อตัดหรือเพิ่มคุณสมบัติอื่นเพื่อจัดรูปแบบรายการเป็นสตริง:

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

ปรับแต่งคำตอบของ@Mathieu Vialesเล็กน้อยนี่คือตัวอย่างข้อมูลที่เข้ากันได้กับ.

using System.Text.Json;

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

โปรดทราบว่าในขณะที่อาร์กิวเมนต์ที่สองในทั้งสองSerialize()และDeserialize()โดยทั่วไปเป็นทางเลือกคุณจะได้รับข้อผิดพลาด:

แผนภูมินิพจน์ต้องไม่มีการเรียกหรือการเรียกใช้ที่ใช้อาร์กิวเมนต์ที่เป็นทางเลือก

การตั้งค่าให้เป็นค่าดีฟอลต์ (null) อย่างชัดเจนสำหรับการล้างข้อมูลนั้น

แน่นอนPawel ได้ให้คำตอบที่เหมาะสม แต่ฉันพบในโพสต์นี้ว่าเนื่องจาก EF 6+ สามารถบันทึกคุณสมบัติส่วนตัวได้ ดังนั้นฉันจึงต้องการรหัสนี้เนื่องจากคุณไม่สามารถบันทึก Strings ได้ผิดวิธี

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

คุณสามารถใช้ScalarCollectionคอนเทนเนอร์นี้เพื่อ จำกัด อาร์เรย์และให้ตัวเลือกการจัดการบางอย่าง ( Gist ):

การใช้งาน:

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

รหัส:

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

ฉันต้องการเพิ่มว่าเมื่อใช้ Npgsql (ผู้ให้บริการข้อมูลสำหรับ PostgreSQL) อาร์เรย์และรายการประเภทดั้งเดิมได้รับการสนับสนุนจริง:

https://www.npgsql.org/efcore/mapping/array.html