C# 比较可为空值的列表

我使用以下方法检查

值1

是否在

值2

上方交叉：

Boolean CrossAbove<T>(IList<T> values1, IList<T> values2) where T : IComparable {

  return values1[values1.Count - 2].CompareTo(values2[values2.Count - 2]) < 0 && values1.Last().CompareTo(values2.Last()) > 0;

}

比较时，其中一个值为null，然后返回false

如何更改

crossover

方法以允许此操作

更新

最后，我得到了以下结果，它允许将一个参数用作可空参数，而将另一个参数用作不可空参数。或可为空或不可为空：

Boolean CrossAbove<T>(IList<Nullable<T>> values1, IList<Nullable<T>> values2) where T : struct, IComparable {

  if (values1[values1.Count - 2] == null || values1.Last() == null || values2[values1.Count - 2] == null || values2.Last() == null)
    return false;

  return values1[values1.Count - 2].Value.CompareTo(values2[values2.Count - 2].Value) < 0 && values1.Last().Value.CompareTo(values2.Last().Value) > 0;

} 

Boolean CrossAbove<T>(IList<Nullable<T>> values1, IList<T> values2) where T : struct, IComparable => CrossAbove(values1, values2.Select(x => new Nullable<T>(x)).ToList());

Boolean CrossAbove<T>(IList<T> values1, IList<Nullable<T>> values2) where T : struct, IComparable => CrossAbove(values1.Select(x => new Nullable<T>(x)).ToList(), values2);

Boolean CrossAbove<T>(IList<T> values1, IList<T> values2) where T : struct, IComparable => CrossAbove(values1.Select(x => new Nullable<T>(x)).ToList(), values2.Select(x => new Nullable<T>(x)).ToList());

布尔交叉（IList值1，IList值2），其中T:struct，i可比较{
如果（values1[values1.Count-2]==null | | | values1.Last（）==null | | | values2[values1.Count-2]==null | | values2.Last（）==null）
返回false；
返回值1[values1.Count-2].Value.CompareTo（values2[values2.Count-2].Value）<0&&values1.Last（）.Value.CompareTo（values2.Last（）.Value）>0；
} 
布尔交叉（IList values1，IList values2），其中T:struct，IComparable=>crossover（values1，values2.Select（x=>new Nullable（x））.ToList（）；
布尔交叉（IList values1，IList values2），其中T:struct，IComparable=>crossover（values1.Select（x=>new Nullable（x））.ToList（），values2）；
布尔交叉（IList values1，IList values2），其中T:struct，IComparable=>crossover（values1.Select（x=>new Nullable（x））.ToList（），values2.Select（x=>new Nullable（x））.ToList（）；

我找不到更好的方法来满足这些要求

---

尽管如此？

您可以修改方法以接收比较逻辑，例如：

List<Decimal> values1 = getValues1();
List<Decimal> values2 = getValues2();

Boolean result = CrossAbove(values1, values2);

bool CrossAbove<T>(IList<T> values1, IList<T> values2, Func<T, T, int> compare)
{
     return compare(values1[values1.Count - 2], values2[values2.Count - 2]) < 0 && compare(values1.Last(), values2.Last()) > 0;
}

对于您的

列表

示例调用，您可以使用

比较

调用您的方法，如下所示：

CrossAbove(values1, values2, (v1, v2) => {
    if (v1.HasValue && v2.HasValue) {
       return v1.Value.CompareTo(v2.Value);
    }
    return v1 == null && v2 == null;
});

请注意，这两个列表都必须是可为空的

列表。希望能有帮助

更新：
我将在两个类型参数上实现
crossover
generic，并继续接收比较委托：

bool CrossAbove<T1, T2>(IList<T1> values1, IList<T2> values2, Func<T1, T2, int> compare)

您可以修改方法以接收比较逻辑，如：

List<Decimal> values1 = getValues1();
List<Decimal> values2 = getValues2();

Boolean result = CrossAbove(values1, values2);

bool CrossAbove<T>(IList<T> values1, IList<T> values2, Func<T, T, int> compare)
{
     return compare(values1[values1.Count - 2], values2[values2.Count - 2]) < 0 && compare(values1.Last(), values2.Last()) > 0;
}

对于您的
列表
示例调用，您可以使用
比较
调用您的方法，如下所示：

CrossAbove(values1, values2, (v1, v2) => {
    if (v1.HasValue && v2.HasValue) {
       return v1.Value.CompareTo(v2.Value);
    }
    return v1 == null && v2 == null;
});

请注意，这两个列表都必须是可为空的
列表。希望能有帮助

更新：
我将在两个类型参数上实现
crossover
generic，并继续接收比较委托：

bool CrossAbove<T1, T2>(IList<T1> values1, IList<T2> values2, Func<T1, T2, int> compare)

您可以使用
Nullable。如下进行比较：

Boolean CrossAbove<T>(IList<T?> values1, IList<T?> values2) where T : struct
{
    return 
        !values1.Reverse().Take(2).Any(x => !x.HasValue) &&
        !values2.Reverse().Take(2).Any(x => !x.HasValue) &&
        Nullable.Compare<T>(values1[values1.Count - 2],values2[values2.Count - 2]) < 0 
        && Nullable.Compare<T>(values1.Last(), values2.Last()) > 0;
}

布尔交叉（IList值1，IList值2），其中T:struct
{
返回
！values1.Reverse（）.Take（2）.Any（x=>！x.HasValue）&&
！values2.Reverse（）.Take（2）.Any（x=>！x.HasValue）&&
可为空。比较（值1[values1.Count-2]，值2[values2.Count-2]）<0
&&可空。比较（values1.Last（），values2.Last（））>0；
}

但是，它根据所描述的
null
比较进行比较，这与您预期的不同。但是您可以根据需要对其进行一些修改。
您可以使用
Nullable。比较如下所示：

Boolean CrossAbove<T>(IList<T?> values1, IList<T?> values2) where T : struct
{
    return 
        !values1.Reverse().Take(2).Any(x => !x.HasValue) &&
        !values2.Reverse().Take(2).Any(x => !x.HasValue) &&
        Nullable.Compare<T>(values1[values1.Count - 2],values2[values2.Count - 2]) < 0 
        && Nullable.Compare<T>(values1.Last(), values2.Last()) > 0;
}

布尔交叉（IList值1，IList值2），其中T:struct
{
返回
！values1.Reverse（）.Take（2）.Any（x=>！x.HasValue）&&
！values2.Reverse（）.Take（2）.Any（x=>！x.HasValue）&&
可为空。比较（值1[values1.Count-2]，值2[values2.Count-2]）<0
&&可空。比较（values1.Last（），values2.Last（））>0；
}

但是，它根据所描述的
null
比较进行比较，这与您预期的不同。但是你可以做一些你想做的修改。
这件事是
可空的
没有实现
IComparable
这可以在不使用IComparable的情况下用可空的泛型实现吗？问题是
可空的
没有实现
IComparable
可以在不使用IComparable的情况下用可空的泛型实现吗？我补充道对我的问题的更新，以及我将要使用的解决方案，允许对空值的比较进行更多的控制。你怎么认为？找不到缩短代码的方法。@MiguelMoura重载没有什么错，缩短代码并不总是更好。我在我的问题中添加了一个更新，使用我将使用的解决方案，可以更好地控制空值的比较。你怎么认为？找不到缩短代码的方法。@MiguelMoura重载没有什么错，缩短代码并不总是更好。我在我的问题中添加了一个更新，使用我将使用的解决方案，可以更好地控制空值的比较。你怎么认为？找不到缩短代码的方法。我在我的问题中添加了一个更新，我将使用的解决方案允许对空值的比较进行更多控制。你怎么认为？找不到缩短代码的方法。