Editar Isso parece ocorrer porqualquer Propriedade da entidade que referencia outra entidade em uma direção. Em outras palavras, para o exemplo abaixo, o fato de queBar substitui A igualdade parece ser irrelevante.

Suponha que eu tenha as seguintes classes:

public class Foo
{
    public int? Id { get; set; }

    public virtual Bar { get; set; }

}

public class Bar : IEquatable<Bar>
{
    public int Id { get; set; }

    public override bool Equals(object obj)
    {
        var other = obj as Bar;

        return Equals(other);
    }

    public bool Equals(Bar other)
    {
        if (object.Equals(other, null))
            return false;

        return this.Id == other.Id;
    }

    public static bool operator ==(Bar left, Bar right)
    {
        return object.Equals(left, right);
    }

    public static bool operator !=(Bar left, Bar right)
    {
        return !object.Equals(left, right);
    }

    public override int GetHashCode()
    {
        return Id.GetHashCode();
    }
}

Observe que aqui, "Bar" intencionalmente tem a igualdade "Id", porque representa mais ou menos uma tabela de pesquisa - portanto, quaisquer duas referências de objeto com o mesmo Id sempre devem ser consideradas iguais.

Aqui está a parte estranha, tudo funciona bem quando eu definirFoo.Bar para outroBar instância - tudo é atualizado conforme o esperado.

No entanto, sefoo possui umBar quando é recuperado doDbContext e eu faço:

foo.Bar = null

então a propriedade não muda realmente!

Se eu fizer:

var throwAway = foo.Bar;
foo.Bar = null;

Em seguida, a propriedade será configurada e salva como nula.

Desde oFoo.Bar Como a propriedade é simplesmente uma propriedade virtual implementada automaticamente, só posso concluir que isso tem algo a ver com carregamento lento e proxies do Entity Framework - mas por que esse cenário em particular causa um problema, não faço ideia.

Por que o Entity Framework se comporta dessa maneira e como posso defini-lonull confiável?