Campos de Retaguarda

Os campos de suporte permitem que o Entity Framework (EF) leia e/ou escreva num campo, em vez de em uma propriedade. Isto pode ser útil quando o encapsulamento na classe está a ser usado para restringir o uso e/ou melhorar a semântica em torno do acesso aos dados por código de aplicação, mas o valor deve ser lido e/ou escrito na base de dados sem usar essas restrições/melhorias.

Configuração básica

Por convenção, os seguintes campos serão descobertos como campos de apoio para uma dada propriedade (listados por ordem de precedência).

• <camel-cased property name>
• _<camel-cased property name>
• _<property name>
• m_<camel-cased property name>
• m_<property name>

No exemplo seguinte, a Url propriedade está configurada para ter _url como campo de apoio:

public class Blog
{
    private string _url;

    public int BlogId { get; set; }

    public string Url
    {
        get { return _url; }
        set { _url = value; }
    }
}

Note que os campos de apoio só são descobertos para propriedades incluídas no modelo. Para mais informações sobre quais propriedades estão incluídas no modelo, consulte Incluir e Excluir Propriedades.

Também pode configurar campos de apoio usando uma Data Annotations ou a API Fluent, por exemplo, se o nome do campo não corresponder às convenções acima:

public class Blog
{
    private string _validatedUrl;

    public int BlogId { get; set; }

    [BackingField(nameof(_validatedUrl))]
    public string Url
    {
        get { return _validatedUrl; }
    }

    public void SetUrl(string url)
    {
        // put your validation code here

        _validatedUrl = url;
    }
}

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .Property(b => b.Url)
        .HasField("_validatedUrl");
}

Acesso a campos e propriedades

Por defeito, o EF irá sempre ler e escrever no campo de backup – assumindo que um foi devidamente configurado – e nunca usará essa propriedade. No entanto, o EF também suporta outros padrões de acesso. Por exemplo, o exemplo seguinte instrui o EF a escrever apenas no campo de apoio enquanto estiver a materializar, e a usar a propriedade em todos os outros casos:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .Property(b => b.Url)
        .HasField("_validatedUrl")
        .UsePropertyAccessMode(PropertyAccessMode.PreferFieldDuringConstruction);
}

Consulte o enum PropertyAccessMode para o conjunto completo de opções suportadas.

Propriedades apenas de campo

Também pode criar uma propriedade conceptual no seu modelo que não tenha uma propriedade CLR correspondente na classe de entidade, mas que use um campo para armazenar os dados na entidade. Isto é diferente de Shadow Properties, onde os dados são armazenados no tracker de alterações, em vez no tipo CLR da entidade. As propriedades apenas de campo são frequentemente usadas quando a classe de entidade utiliza métodos em vez de propriedades para obter/definir valores, ou em casos em que os campos não deveriam estar expostos de todo no modelo de domínio (por exemplo, chaves primárias).

Pode configurar uma propriedade apenas de campo fornecendo um nome na Property(...) API:

internal class MyContext : DbContext
{
    public DbSet<Blog> Blogs { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Blog>()
            .Property("_validatedUrl");
    }
}

public class Blog
{
    private string _validatedUrl;

    public int BlogId { get; set; }

    public string GetUrl()
    {
        return _validatedUrl;
    }

    public void SetUrl(string url)
    {
        using (var client = new HttpClient())
        {
            var response = client.GetAsync(url).Result;
            response.EnsureSuccessStatusCode();
        }

        _validatedUrl = url;
    }
}

O EF tentará encontrar uma propriedade CLR com o nome próprio, ou um campo se nenhuma propriedade for encontrada. Se nem uma propriedade nem um campo forem encontrados, será criada uma propriedade sombra em vez disso.

Pode ser necessário consultar uma propriedade apenas de campo a partir de consultas LINQ, mas esses campos são normalmente privados. Pode usar o EF.Property(...) método numa consulta LINQ para se referir ao campo:

var blogs = db.blogs.OrderBy(b => EF.Property<string>(b, "_validatedUrl"));