如何让C# Rx的DistinctUntilChanged()支持List等任意结果类型

这个问题我之前也碰到过，确实是Rx.NET默认的DistinctUntilChanged在处理集合类型时的一个常见坑——因为它默认使用EqualityComparer<T>.Default，对于List<T>这类引用类型，只会比较对象引用，而不是集合里的实际内容，所以哪怕每次返回的集合内容完全一致，只要是新实例，就会被判定为"不同"，导致持续发射数据。

下面给你一套完整的解决方案，从自定义比较器到通用扩展方法，一步到位解决问题：

1. 实现通用的集合内容比较器 #

首先我们需要一个能比较集合内容是否相等的比较器，它会检查两个集合的元素序列是否完全一致：

using System.Collections.Generic;
using System.Linq;

public class EnumerableEqualityComparer<T> : IEqualityComparer<IEnumerable<T>>
{
    public bool Equals(IEnumerable<T>? x, IEnumerable<T>? y)
    {
        // 处理null情况
        if (ReferenceEquals(x, y)) return true;
        if (x is null || y is null) return false;
        
        // 用SequenceEqual比较元素序列是否完全一致
        return x.SequenceEqual(y);
    }

    public int GetHashCode(IEnumerable<T> obj)
    {
        // 生成基于元素的哈希码，用于快速筛选
        if (obj is null) return 0;
        
        return obj.Aggregate(
            seed: 17,
            func: (currentHash, item) => currentHash * 31 + (item?.GetHashCode() ?? 0)
        );
    }
}

这个比较器会遍历两个集合的元素，逐个比较是否相等，同时生成基于元素的哈希码（比简单异或更稳定），确保DistinctUntilChanged能正确判断集合内容是否变化。

2. 写一个通用扩展方法自动适配比较器 #

如果每次调用DistinctUntilChanged都要手动指定比较器，太麻烦了。我们可以写一个扩展方法，自动判断当前泛型类型是否是集合类型，如果是就用上面的集合比较器，否则用默认比较器：

using System;
using System.Reflection;
using System.Reactive.Linq;

public static class ObservableCollectionDistinctExtensions
{
    public static IObservable<T> DistinctUntilChangedByContent<T>(this IObservable<T> source)
    {
        // 判断T是否是IEnumerable<>的实现
        var enumerableInterface = typeof(T).GetInterface(typeof(IEnumerable<>).FullName);
        if (enumerableInterface == null)
        {
            // 非集合类型，直接用默认的DistinctUntilChanged
            return source.DistinctUntilChanged();
        }

        // 获取集合的元素类型
        var elementType = enumerableInterface.GetGenericArguments()[0];
        
        // 创建对应的EnumerableEqualityComparer<TElement>实例
        var comparerType = typeof(EnumerableEqualityComparer<>).MakeGenericType(elementType);
        var comparer = Activator.CreateInstance(comparerType);

        // 通过反射调用泛版的DistinctUntilChanged方法
        var distinctMethod = typeof(Observable)
            .GetMethods(BindingFlags.Public | BindingFlags.Static)
            .First(m => m.Name == "DistinctUntilChanged" && m.GetParameters().Length == 2)
            .MakeGenericMethod(typeof(T));

        return (IObservable<T>)distinctMethod.Invoke(null, new object[] { source, comparer });
    }
}

3. 使用示例 #

现在你可以直接用这个扩展方法替换原来的DistinctUntilChanged，不管是普通类型还是集合类型，都会自动适配正确的比较逻辑：

// 测试场景：每隔1秒发射一个内容固定的List<int>
var testObservable = Observable.Interval(TimeSpan.FromSeconds(1))
    .Select(_ => new List<int> { 1, 2, 3 });

// 使用我们的扩展方法
testObservable.DistinctUntilChangedByContent()
    .Subscribe(result => 
        Console.WriteLine($"数据发射：{string.Join(", ", result)}")
    );

运行这段代码，你会发现它只会发射一次，而不是每隔1秒都发射——因为集合内容没有变化，符合你的预期。

额外说明 #

• 如果你的集合是自定义的集合类型（不是直接实现IEnumerable<T>），可以调整扩展方法里的类型判断逻辑，比如检查是否继承自ICollection<T>等。
• GetHashCode的实现可以根据你的需求优化，比如使用更复杂的哈希算法，避免哈希冲突（不过即使有冲突，Equals方法会最终做精确比较，不会影响正确性）。

内容的提问来源于stack exchange，提问作者shtse8