如何在 C#/实体框架中的 NotMapped 属性的 setter 中使用映射属性

Question

I want to use the value of a property called DirFotos that is mapped to column in the database table to retrieve the photos of a product. The photos of the product will be a list of string. That list is not mapped because I will retrieve it from the file system. Is it possible to use a mapped property in the setter of a NotMapped property in C# / Entity Framework? Besides photos is returning an empty list when I perform a query using the Entity Framework. Why is the NotMapped

class Product

    private List<string> _photos = new List<string>();

    [Column("dir_fotos")]
    public String DirFotos { get; set; }   

    [NotMapped]
    public List<String> photos
    {
        get { return _fotos; }
        set
        {            
            // GetPhotos(this.dirFotos) dirFotos is null here
            _photos.Add("teste1.jpg");
            _photos.Add("teste2.jpg");
        }
    }

So in summary I have two problems, I cannot use the this.dirFotos inside the setter of the photos property (it's null) and with this static snippet photos is returning an empty list when I retrieve the products using Entity Framework.

Answer 1

From what I make out from the question:

• You have an entity to a table which contains a Directory Path for where to find the photographs.
• You want to have a list of photographs which will be loaded based on the files in that directory.
• You're finding that the Directory can be #null when you try to load these photographs in the non-mapped property.

I suspect that the basic premise you have written should work, however a couple of important details. For the non-mapped Photos list, you do not need, nor should use a setter. Instead it just needs a getter:

private List<string> _photos = null;
private string _dirPhotos = null;

[Column("dir_fotos")]
public String DirPhotos 
{ 
    get { return _dirPhotos; }
    set
    { 
        if(string.Compare(_dirPhotos, value, true) != 0)
        {
            _dirPhotos = value;   
            _photos = null;
        }
    }
}

[NotMapped]
public List<String> photos
{
    get { return _photos ?? (_photos = GetPhotos(DirPhotos) ); }
}

What's important here is that your GetPhotos starts with this assertion as well:

private List<string> GetPhotos(string dirPhotos)
{
    if (string.IsNullOrEmpty(dirPhotos))
        return new List<string>();

    // ... load photos...
}

The key differences here:

• The DirPhotos is given a variable and getter/setter. If the Directory changes we want to "reset" the List variable so that it can reload when next accessed.

• The list initializes to #null as the default value. When the "getter" is called, this will check if the variable is null, and if so, call your GetPhotos method. Once that variable is set it will reuse that loaded data until the directory is changed.

• The GetPhotos will return an empty list if the Directory passed in is null/empty. You will also want to ensure that your GetPhotos method asserts that any directory passed in is valid and either bubble up an exception or return an empty list. Don't return #null though as we don't want to encounter null ref exceptions down the road.

I believe the issue you were encountering was that by trying to use a Setter you could be attempting to "set" the collection before the entity has had a chance to load it's data. With this pattern where the load occurs on the getter you just load the entity like normal and access the DirPhotos after the entity has been read from the DbSet. The first access of the DirPhotos will attempt to load the photos from the file system, but just be sure to handle that the entity row may not have a directory set. (or a valid directory)