record R(int X, ImmutableArray<int> Xs);

static class P
{
    static void Main()
    {
        var r1 = new R(1,ImmutableArray.Create(2));
        var r2 = new R(1,ImmutableArray.Create(2));

        Console.WriteLine(r1 == r2);
   }
}

public sealed record R(int x, int[] xs)
{
    public bool Equals(R? other)
        => other.x == x && other.xs.SequenceEqual(xs);
}

_>public sealed record R(int x, int[] xs)
_>{
_>    public bool Equals(R? other)
_>        => other.x == x && other.xs.SequenceEqual(xs);
_>}
_>

record R(int X, int[] Xs)
{
    public virtual bool Equals(R? other) => other != null && other.X == X && other.Xs.SequenceEqual(Xs);

    public override int GetHashCode()
    {
        return X;
    }
}

_>public sealed record R(int x, int[] xs)
_>{
_>    public bool Equals(R? other)
_>        => other.x == x && other.xs.SequenceEqual(xs);
_>}
_>

record R(int X, int[] Xs)
{
    public virtual bool Equals(R? other) => other != null && other.X == X && other.Xs.SequenceEqual(Xs);

    public override int GetHashCode()
    {
        return X;
    }
}

using System;

var r1 = new R("R");
var r2 = new R("R");
Console.WriteLine($"Compare {nameof(r1)} and {nameof(r2)} before subscription: {r1 == r2}");

r1.Event += delegate { };
Console.WriteLine($"Compare {nameof(r1)} and {nameof(r2)} after subscription: {r1 == r2}");

record R(string Name) {
  public event EventHandler? Event;
}

record R(string Name) {
  public event EventHandler? Event;
    
  public virtual bool Equals(R? other) => other != null && other.EqualityContract == EqualityContract && other.Name == Name;
  public override int GetHashCode() => (EqualityContract, Name).GetHashCode();
}

> let arr1 = [|1;2;3|];;
val arr1 : int [] = [|1; 2; 3|]

> let arr2 = [|1;2;3|];;
val arr2 : int [] = [|1; 2; 3|]

> arr1 = arr2;;
val it : bool = true

> type Cart = { Id : int; Items : array<int> };;
type Cart =
  {Id: int;
   Items: int array;}

> let c1 = { Id = 1; Items = arr1 };;
val c1 : Cart = {Id = 1;
                 Items = [|1; 2; 3|];}

> let c2 = { Id = 1; Items = arr2 };;
val c2 : Cart = {Id = 1;
                 Items = [|1; 2; 3|];}

> c1 = c2;;
val it : bool = true

obj.ReferenceEquals (arr1,arr2)// => false

The EqualityContract enables the equality methods to compare the runtime type of objects when they're checking for equality.

using System;

var r = new R("A");
var x = new X("A");
Console.WriteLine($"Compare {nameof(r)} and {nameof(x)}: {r == x}"); // False

var r1 = new R1("A");
var x1 = new X1("A");
Console.WriteLine($"Compare {nameof(r1)} and {nameof(x1)}: {r1 == x1}"); // True

record R(string Name) { }
record X(string Name) : R(Name) { }

record R1(string Name) {
  public virtual bool Equals(R1? other) => other is not null && other.Name == Name;
  public override int GetHashCode() => Name?.GetHashCode() ?? 0;
}

record X1(string Name) : R1(Name) { }

Для типов class два объекта равны, если они ссылаются на один и тот же объект в памяти.
Для типов struct два объекта равны, если хранят одинаковые значения и имеют один и тот же тип.
Для типов с модификатором record (record class, record struct и readonly record struct) два объекта равны, если они относятся к одному типу и хранят одинаковые значения.

using System;

var r = new R("A");
var x = new X("A");
Console.WriteLine($"Compare {nameof(r)} and {nameof(x)}: {r == x}"); // True

record R(string Name) { }
record X(string Name) : R(Name) {
  protected override Type EqualityContract => typeof(R);
}

abstract record Expression { }
abstract record BinaryExpression(Expression Left, Expression Right) : Expression { }
sealed record BinaryPlusExpression(Expression Left, Expression Right) : BinaryExpression(Left, Right) { }
sealed record BinaryMinusExpression(Expression Left, Expression Right) : BinaryExpression(Left, Right) { }

VD>В целом, да. Вот только в стандартных на это забили. Да и культура у дотнетных программистов явно не та, что показывает данная тема. Всем естественно противоестественное поведение.

1. Выписать `IEqualityComparer`-ы для коллекций (имеющихся) вместо новых коллекций.
   
2. Найти удобный способ связать компаратор с полем/свойством рекорда. Атрибут или приватное свойство с именем `<PropertyName>EqualityComparer` или что-то ещё или даже всё вместе.
   
3. Сделать Source Generator. который вместо дефолтового компаратора будет брать тот, что указан выше.