Question

想象一下我有一个涉及类型T的通用方法。就用法而言，T永远只会是类型Nullable<long>或Nullable<Guid>的类型。

由于T是可空的，所以我不能在方法上施加类型约束where T : IComparable<T>。

鉴于此，在该方法中确定T类型的两个变量之间相等的最有效方法是什么？

我目前正在传递lambda函数，例如（x，y）=> x == y ..但觉得必须有更好的方法。

Answer 1

如果T始终为Nullable，则可以传递基础类型的参数（而不是Nullable<T>），然后使用Nullable.Compare进行比较：

public static void Method<T>(Nullable<T> n1, Nullable<T> n2)
    where T : struct
{
    int comparisonResult = Nullable.Compare(n1, n2);
    ...
}

Answer 2

Comparer<T>.Default应该处理完全可为空的值。它会检查Nullable<> here，因此应该进行处理。

请注意，如果您想知道<，>，<=，> =，==（所以两个元素之间的顺序），请使用IComparable<>。如果只想使用Equals，请使用IEquatable<>（和EqualityComparer<T>.Default）。

Answer 3

另一种实现方式-https://dotnetfiddle.net/EBjU54

此处：我在一个单独的类中创建了一个适当的可为空的比较逻辑，以检查两个可为空的相等性。接下来，作为vc74的答案，您传递基础类型的参数并使用NullableComparer进行检查。

public static bool Comparexxx<T>(this T? myValue, T? otherValue)
            where T : struct
            { 
                var comparer = new NullableComparer<T>();

                return comparer.Compare(myValue, otherValue) == 1;              
            } 

            public class NullableComparer<T> : IComparer<Nullable<T>>
                  where T : struct
            {

                 public int Compare(Nullable<T> x, Nullable<T> y)
                 {              
                    //Two nulls are equal
                    if (!x.HasValue && !y.HasValue)
                        return 1;

                    //Any object is greater than null
                    if (x.HasValue && !y.HasValue) 
                        return 0;

                    if (y.HasValue && !x.HasValue)
                        return 0;

                    //Otherwise compare the two values
                    return x.Value.Equals(y.Value) ? 1 : 0 ;
                 }

            }
    }

然后打电话

long? a = 10;           
long? b = 10;
var rs = a.Comparexxx<long>(b);

比较通用Nullable类型

3 个答案: