实体框架-代码优先-无法存储List <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但是它并没有改变任何东西。

谢谢您的帮助。

实体框架不支持原始类型的集合。您可以创建一个实体（将保存到另一个表中），也可以进行一些字符串处理以将列表另存为字符串，并在实体实现后填充列表。

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 bloke提供的答案。

仅适用于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]因此对我来说很明显，在正常的编码过程中“这不是您要查找的属性”。“ real”属性用标记，[NotMapped]因此实体框架将忽略它。

（不相关的切线）：您可以对更复杂的类型执行相同的操作，但是您需要问问自己，是否只是让查询对象的属性对自己来说太难了？（是的，在我的情况下）。

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

当然，帕维尔给出了正确的答案。但是我在这篇文章中发现，自EF 6+起，可以保存私有属性。所以我更喜欢这段代码，因为您不能以错误的方式保存字符串。

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

稍微调整@Mathieu Viales的答案，这是一个使用新的System.Text.Json序列化程序的.NET Standard兼容片段，从而消除了对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));

请注意，虽然在这两个第二个参数Serialize()，并Deserialize()通常是可选的，你会得到一个错误：

表达式树可能不包含使用可选参数的调用或调用

分别将其显式设置为默认值（null）可以清除该问题。

您可以使用此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);
  }
}