Collections/arrays inside of records

[eduherminio]

Given

public record Foo(int N);
public record Bar(int N, Foo F) : Foo(N);
public record FooBar(int N, Foo[] Fs) : Foo(N);

I really want all these use cases to work:

[Fact]
public void MyTest()
{
    // Pass
    Assert.Equal(new Foo(1), new Foo(1));
    Assert.Equal(new Bar(1, new Foo(1)), new Bar(1, new Foo(1)));

    // Fails
    Assert.Equal(new FooBar(1, new[] { new Foo(1) }), new FooBar(1, new[] { new Foo(1) }));
}

I'm tempted of using:

public record FixedFooBar(int N, Foo[] Fs) : Foo(N)
{
    public virtual bool Equals(FixedFooBar? other)
    {
        if (other is null)
        {
            return false;
        }

        return N.Equals(other.N) && Fs.SequenceEqual(other.Fs);
    }

    public override int GetHashCode()
    {
        return HashCode.Combine(N, Fs);
    }
}

so that this test passes

[Fact]
public void MyTest()
{
    Assert.Equal(new FixedFooBar(1, new[] { new Foo(1) }), new FixedFooBar(1, new[] { new Foo(1) }));
}

However, that's going to end up backfiring because of the GetHashCode() implementation, for instance here:

[Fact]
public void MyTest()
{
    var mySet = new HashSet<FixedFooBar>() { new FixedFooBar(1, new[] { new Foo(1) }) };
    Assert.False(mySet.Add(new FixedFooBar(1, new[] { new Foo(1) })));
}

---

So my real debate is between:

• Not taking into account the array/collection.

public record FixedFooBar(int N, Foo[] Fs) : Foo(N)
{
    public virtual bool Equals(FixedFooBar? other)
    {
        if (other is null)
        {
            return false;
        }

        return N.Equals(other.N);
    }

    public override int GetHashCode()
    {
        N.GetHashCode();
    }
}

• Taking it into account just for the Equals(), but being well aware of the limitations of the comparisons.

public record FixedFooBar(int N, Foo[] Fs) : Foo(N)
{
    public virtual bool Equals(FixedFooBar? other)
    {
        if (other is null)
        {
            return false;
        }

        return N.Equals(other.N) && Fs.SequenceEqual(other.Fs);
    }

    public override int GetHashCode()
    {
         N.GetHashCode();
    }
}

---

I'm not asking for any specific answer, since it obviously depends on the context and specific use case of these classes, but has anyone faced similar dilemmas or thought about this situations with record classes in mind?

Any other 'gotchas' while using records with System.Generic.Collections?

[YairHalberstadt]

The LDT decided that addressing all the possible ways of doing equality with records was not practical in the language.

Instead the equality can be overridden, either manually or using the new Source Generators to generate equality for you.