エンティティフレームワーク-コードファースト-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。文字列リストに適用されるテーブルや関係はありません。

何が悪いのですか？文字列 も作ってみました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 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 Fluent構成を使用して、ListJSONとの間でシリアル化/非シリアル化します。

なぜこのコードが、あなたが努力することができるすべての完璧な組み合わせなのか：

• Sasnの元の答えの問題は、リスト内の文字列にカンマ（または区切り文字として選択された任意の文字）が含まれている場合、単一のエントリが複数のエントリに変わるが、読みやすく、最も簡潔。
• CAD blokeの答えの問題は、醜く、モデルを変更する必要があるということです。これは悪い設計手法です（Sasanの答えに関するMarcell Tothのコメントを参照）。しかし、それはデータセーフな唯一の答えです。

私はこれが古い質問であることを知っており、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]ため、エンティティフレームワークはそれを無視します。

（無関係な接線）：もっと複雑な型でも同じことができますが、オブジェクトのプロパティのクエリを自分で行うのが難しいと思ったことはありませんか。（はい、私の場合）。

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標準互換のスニペットをここに示します。これにより、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);
  }
}