Why is the property EqualityContract on a C# record virtual?

[bitbonk]

The record type of C# 9 has the following property

Type EqualityContract { get; }

If the record is not sealed, that property will be virtual so it can be overridden.
Unfortunately the docs do not state what I would use this property for. Why would I ever want to override this property? Can you give me a somewhat realistic example?

I tried to override the EqualityContract property to allow equality of derived types but it doesn't work. This raised the question, if overriding it can't be used for that, what can it be used for?

[Fact]
public void Test()
{
    Foo foo = new Foo("name");
    Foo fooDerived = new FooDerived("name");
    Assert.True(foo.Equals(fooDerived));
    Assert.True(fooDerived.Equals(foo)); // fails
}

record Foo(string Name)
{
    public virtual bool Equals(Foo? other)
    {
        return other != null && this.Name.Equals(other.Name);
    }
    public override int GetHashCode()
    {
        return this.Name.GetHashCode();
    }
    protected virtual Type EqualityContract { get; } = typeof(Foo);
}

record FooDerived(string Name) : Foo(Name)
{
    public virtual bool Equals(FooDerived? other)
    {
        return other != null && this.Name.Equals(other.Name);
    }
    public override int GetHashCode()
    {
        return this.Name.GetHashCode();
    }
    protected override Type EqualityContract { get; } = typeof(Foo);
}

[yaakov-h]

Typically you wouldn't override it, but the compiler would. In the compiler-generated Equals function, it signals to the base class that the subclass is not of the same type, so that base.Equals(derived) knows to return false even if all of the members in the base class are identical in both object instances.

[CyrusNajmabadi]

I suspect there would have been other means to achieve the equality contract

Sure. There were probably other routes we could have taken. But why would we? This route was simple and works very well.

[bitbonk]

@CyrusNajmabadi

See #3137 (comment)

I don't think it is possible to override that property in a meaningful way in user code. At least I can't come up with an example. Do you have an example?

[alexrp]

record Base();

record Derived : Base
{
    protected override Type EqualityContract => typeof(Base);
}

?

[CyrusNajmabadi]

@bitbonk The comment l linked to gives an example.

[bitbonk]

@alexrp

record Base();

record Derived : Base
{
    protected override Type EqualityContract => typeof(Base);
}

?

Thank you! 🙏
Upon further investigation of this simple example, I finally understood what I was misunderstanding here.

That example still makes my test fail:

[Fact]
public void Test2()
{
    Base @base = new Base();
    Base derived = new Derived();
    Assert.True(@base.Equals(derived));
    Assert.True(derived.Equals(@base)); // fails here
}

As a result, I was wrongly assuming that overriding the EqualityContract property has no effect. But it actually does: If I remove the override

record Base;
record Derived : Base;

the test already fails in the first assertion.

[Fact]
public void Test2()
{
    Base @base = new Base();
    Base derived = new Derived();
    Assert.True(@base.Equals(derived)); // fails here
    Assert.True(derived.Equals(@base)); 
}

So overriding the property does makes sense if you want base and derived considered to be equal. It is just important to keep in mind that equality is not symmetrical. For records, it is generally not possible to make derived.Equals(@base) return true. This is a bit suprising.