Entity Framework - Code First - <String> Liste Depolanamıyor

Böyle bir sınıf yazdım:

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

ve

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

Kodu çalıştırdıktan sonra:

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

verilerim kaydediliyor ancak yalnızca Id. Dizeler listesine uygulanan herhangi bir tablom veya ilişkim yok .

Neyi yanlış yapıyorum? Strings yapmayı da denedim virtualama bu hiçbir şeyi değiştirmedi.

Yardımın için teşekkürler.

Entity Framework, ilkel türlerin koleksiyonlarını desteklemez. Bir varlık oluşturabilir (farklı bir tabloya kaydedilecektir) veya listenizi bir dize olarak kaydetmek ve varlık gerçekleştirildikten sonra listeyi doldurmak için bir dizi dize işlemi yapabilirsiniz.

EF Core 2.1+:

Emlak:

public string[] Strings { get; set; }

OnModelCreating:

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

Bu cevap @Sasan tarafından sağlananlara dayanmaktadır. ve @CAD bloke .

Yalnızca EF Core 2.1+ ile çalışır (.NET Standard uyumlu değildir) (Newtonsoft JsonConvert )

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

EF Core akıcı yapılandırmasını kullanarak, List kaldırıyoruz.

Bu kod neden çabalayabileceğiniz her şeyin mükemmel bir karışımıdır:

• Sasn'ın orijinal cevabındaki sorun, listedeki dizeler virgül (veya sınırlayıcı olarak seçilen herhangi bir karakter) içeriyorsa, tek bir girişi birden çok girişe çevireceği için büyük bir karmaşaya dönüşeceği, ancak okunması en kolay olanıdır. en özlü.
• CAD adamının cevabındaki sorun, çirkin olması ve modelin değiştirilmesini gerektirmesidir ki bu kötü bir tasarım uygulamasıdır (Marcell Toth'un Sasan'ın cevabı hakkındaki yorumuna bakın ). Ancak veri güvenli olan tek cevap budur.

Bunun eski bir soru olduğunu biliyorum ve Pawel doğru cevabı verdi , ben sadece bazı dizgi işlemenin nasıl yapılacağına dair bir kod örneği göstermek ve ilkel bir tipin listesi için fazladan bir sınıftan kaçınmak istedim.

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.NETKurtarmaya .

Veritabanında kalması için JSON olarak serileştirirsiniz ve .NET koleksiyonunu yeniden oluşturmak için serisini kaldırırsınız. Bu, Entity Framework 6 ve SQLite ile beklediğimden daha iyi performans gösteriyor gibi görünüyor. İstediğini biliyorumList<string> ama işte gayet iyi çalışan daha karmaşık bir koleksiyon örneği.

Kalıcı özelliği ile etiketledim, [Obsolete]böylece normal kodlama sürecinde "aradığınız özellik bu değil" benim için çok açık olacaktı. "Emlak" özelliği ile etiketlenmiştir[NotMapped] Entity çerçevesi onu yok sayar.

(ilgisiz tanjant): Aynı şeyi daha karmaşık türler için de yapabilirsiniz, ancak kendinize sormanız gerekir, bu nesnenin özelliklerini sorgulamayı kendiniz için çok mu zorlaştırdınız? (evet, benim durumumda).

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

Sadece basitleştirmek için -

Varlık çerçevesi temelleri desteklemez. Ya onu sarmak için bir sınıf oluşturursunuz ya da listeyi bir dize olarak biçimlendirmek için başka bir özellik eklersiniz:

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

Tabii ki Pawel doğru cevabı verdi . Ancak bu yazıda EF 6+ 'den beri özel mülkleri kaydetmenin mümkün olduğunu buldum . Bu yüzden bu kodu tercih ederim, çünkü Dizeleri yanlış bir şekilde kaydedemezsiniz.

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

Biraz verdiği @Mathieu Viales bireyin cevabı , burada böylece Newtonsoft.Json bağımlılığını ortadan kaldırarak yeni System.Text.Json seri hale kullanarak .NET Standart uyumlu snippet'ine.

using System.Text.Json;

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

Her ikisinde de ikinci bağımsız değişken Serialize()ve Deserialize()genellikle isteğe bağlı olsa da, bir hata alacağınızı unutmayın:

Bir ifade ağacı, isteğe bağlı bağımsız değişkenler kullanan bir çağrı veya çağrı içeremez

Açıkça bunu her biri için varsayılan (null) olarak ayarlamak bunu temizler.

ScalarCollectionBir diziyi sınırlayan ve bazı manipülasyon seçenekleri sağlayan bu kabı kullanabilirsiniz ( Gist ) :

Kullanım:

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

Kod:

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 için veri sağlayıcı) kullanırken, ilkel türlerin dizileri ve listelerinin gerçekten desteklendiğini eklemek istiyorum:

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