Khung thực thể - Mã đầu tiên - Danh sách không thể lưu trữ <Chuỗi>

Tôi đã viết lớp học như vậy:

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

và

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

Sau khi chạy mã:

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

dữ liệu của tôi đang được lưu nhưng chỉ là Id. Tôi không có bất kỳ bảng cũng như mối quan hệ nào áp dụng cho danh sách Chuỗi .

Tôi đang làm gì sai? Tôi cũng đã thử tạo Strings virtual nhưng nó không thay đổi được gì.

Cảm ơn sự giúp đỡ của bạn.

Entity Framework không hỗ trợ tập hợp các kiểu nguyên thủy. Bạn có thể tạo một thực thể (sẽ được lưu vào một bảng khác) hoặc thực hiện một số xử lý chuỗi để lưu danh sách của bạn dưới dạng một chuỗi và điền vào danh sách sau khi thực thể được thực thể hóa.

EF Core 2.1+:

Bất động sản:

public string[] Strings { get; set; }

OnModelCreating:

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

Câu trả lời này dựa trên những câu trả lời được cung cấp bởi @Sasan và @CAD bloke .

Chỉ hoạt động với EF Core 2.1+ (không tương thích .NET Standard) (Newtonsoft JsonConvert)

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

Sử dụng cấu hình thông thạo EF Core, chúng tôi tuần tự hóa / giải mã hóa Listđến / từ JSON.

Tại sao mã này là sự kết hợp hoàn hảo của mọi thứ bạn có thể cố gắng:

• Vấn đề với câu trả lời ban đầu của Sasn là nó sẽ trở thành một mớ hỗn độn lớn nếu các chuỗi trong danh sách chứa dấu phẩy (hoặc bất kỳ ký tự nào được chọn làm dấu phân cách) vì nó sẽ biến một mục nhập thành nhiều mục nhập nhưng dễ đọc nhất và ngắn gọn nhất.
• Vấn đề với câu trả lời của CAD bloke là nó xấu và yêu cầu thay đổi mô hình, đây là một thực tiễn thiết kế tồi (xem nhận xét của Marcell Toth về câu trả lời của Sasan ). Nhưng đó là câu trả lời duy nhất là an toàn về dữ liệu.

Tôi biết đây là một câu hỏi cũ và Pawel đã đưa ra câu trả lời chính xác , tôi chỉ muốn hiển thị một ví dụ mã về cách thực hiện một số xử lý chuỗi và tránh một lớp bổ sung cho danh sách kiểu nguyên thủy.

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 để giải cứu.

Bạn tuần tự hóa nó thành JSON để tồn tại trong Cơ sở dữ liệu và Deserialize nó để tạo lại bộ sưu tập .NET. Điều này dường như hoạt động tốt hơn tôi mong đợi với Entity Framework 6 & SQLite. Tôi biết bạn đã yêu cầu List<string>nhưng đây là một ví dụ về một bộ sưu tập thậm chí còn phức tạp hơn nhưng hoạt động tốt.

Tôi đã gắn thẻ thuộc tính vẫn tồn tại với [Obsolete]vì vậy tôi sẽ thấy rất rõ ràng rằng "đây không phải là thuộc tính bạn đang tìm kiếm" trong quá trình viết mã thông thường. Thuộc tính "thực" được gắn thẻ [NotMapped]nên khung thực thể bỏ qua nó.

(tiếp tuyến không liên quan): Bạn có thể làm điều tương tự với các kiểu phức tạp hơn nhưng bạn cần tự hỏi bản thân mình có phải bạn vừa thực hiện truy vấn các thuộc tính của đối tượng đó quá khó đối với bản thân không? (vâng, trong trường hợp của tôi).

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

Chỉ để đơn giản hóa -

Khung thực thể không hỗ trợ nguyên mẫu. Bạn có thể tạo một lớp để bọc nó hoặc thêm một thuộc tính khác để định dạng danh sách dưới dạng chuỗi:

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

Tất nhiên Pawel đã đưa ra câu trả lời đúng . Nhưng tôi thấy trong bài đăng này rằng vì EF 6+ có thể lưu các thuộc tính riêng tư. Vì vậy, tôi thích mã này hơn, vì bạn không thể lưu các Chuỗi theo cách sai.

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

Điều chỉnh một chút câu trả lời của @Mathieu Viales , đây là đoạn mã tương thích .NET Standard sử dụng bộ tuần tự System.Text.Json mới, do đó loại bỏ sự phụ thuộc vào 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));

Lưu ý rằng trong khi đối số thứ hai trong cả hai Serialize()và Deserialize()thường là tùy chọn, bạn sẽ gặp lỗi:

Cây biểu thức không được chứa lệnh gọi hoặc lệnh gọi sử dụng các đối số tùy chọn

Đặt rõ ràng điều đó thành mặc định (null) cho mỗi lần xóa nó.

Bạn có thể sử dụng vùng ScalarCollectionchứa này để giới hạn một mảng và cung cấp một số tùy chọn thao tác ( Gist ):

Sử dụng:

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

Mã:

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