Entity Framework - Code First - Can't Store List <String>

Escribí tal clase:

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

y

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

Después de ejecutar el código:

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

mis datos se están guardando pero solo el Id. No tengo tablas ni relaciones que se apliquen a la lista de cadenas .

¿Qué estoy haciendo mal? Intenté también hacer Strings virtual pero no cambió nada.

Gracias por tu ayuda.

Entity Framework no admite colecciones de tipos primitivos. Puede crear una entidad (que se guardará en una tabla diferente) o realizar algún procesamiento de cadena para guardar su lista como una cadena y completar la lista después de que la entidad se materialice.

EF Core 2.1+:

Propiedad:

public string[] Strings { get; set; }

OnModelCreating:

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

Esta respuesta se basa en las proporcionadas por @Sasan y @CAD bloke .

Funciona solo con EF Core 2.1+ (no compatible con .NET Standard) (Newtonsoft JsonConvert)

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

Usando la configuración fluida de EF Core, serializamos / deserializamos el Lista / desde JSON.

Por qué este código es la combinación perfecta de todo lo que puede esforzarse:

• El problema con la respuesta original de Sasn es que se convertirá en un gran lío si las cadenas de la lista contienen comas (o cualquier carácter elegido como delimitador) porque convertirá una sola entrada en múltiples entradas, pero es la más fácil de leer y más conciso.
• El problema con la respuesta del tipo CAD es que es feo y requiere que se modifique el modelo, lo cual es una mala práctica de diseño (consulte el comentario de Marcell Toth sobre la respuesta de Sasan ). Pero es la única respuesta segura para los datos.

Sé que esta es una pregunta antigua, y Pawel ha dado la respuesta correcta , solo quería mostrar un ejemplo de código de cómo hacer un procesamiento de cadenas y evitar una clase adicional para la lista de un tipo primitivo.

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 al rescate.

Lo serializa en JSON para persistir en la base de datos y lo deserializa para reconstituir la colección .NET. Esto parece funcionar mejor de lo que esperaba con Entity Framework 6 y SQLite. Sé que lo pidió, List<string>pero aquí hay un ejemplo de una colección aún más compleja que funciona bien.

Etiqueté la propiedad persistente con [Obsolete]para que fuera muy obvio para mí que "esta no es la propiedad que está buscando" en el curso normal de la codificación. La propiedad "real" está etiquetada con, [NotMapped]por lo que Entity framework la ignora.

(tangente no relacionada): podría hacer lo mismo con tipos más complejos, pero debe preguntarse si hizo que consultar las propiedades de ese objeto sea demasiado difícil para usted. (sí, en mi caso).

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

Solo para simplificar:

Entity framework no admite primitivas. Puede crear una clase para envolverla o agregar otra propiedad para formatear la lista como una cadena:

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

Por supuesto, Pawel ha dado la respuesta correcta . Pero encontré en esta publicación que desde EF 6+ es posible guardar propiedades privadas. Así que preferiría este código, porque no puede guardar las cadenas de forma incorrecta.

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

Modificando ligeramente la respuesta de @Mathieu Viales , aquí hay un fragmento de código compatible con .NET Standard que utiliza el nuevo serializador System.Text.Json eliminando así la dependencia de 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));

Tenga en cuenta que si bien el segundo argumento en ambos Serialize()y Deserialize()suele ser opcional, obtendrá un error:

Un árbol de expresión no puede contener una llamada o invocación que utilice argumentos opcionales

Establecer explícitamente eso en el valor predeterminado (nulo) para cada uno aclara eso.

Puede usar este ScalarCollectioncontenedor que limita una matriz y proporciona algunas opciones de manipulación ( Gist ):

Uso:

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

Código:

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