Question

我有这个功能：

public static double MaxValue(IEnumerable<double> Collection)
{
    double max = Collection.First();
    foreach (double d in Collection)
        if (d > max)
            max = d;

    return max;
}

如果我定义了一个通用方法：MaxValue<T>(IEnumerable<T> Collection)如何在没有< >定义的自定义类型中确保没有人可以使用它？这是一件值得担心的好事吗？
如何编写一种适用于IEnumerable和ObservableCollection的方法？

Answer 1

正如其他人在评论中提到的那样，你正在重新发明轮子;您可以使用Linq的Max扩展方法。

如果我定义一个泛型方法：MaxValue（IEnumerable Collection）我怎样才能确保没有人可以在没有＆lt;的自定义类型上使用它？＆GT;界定？这是一件值得担心的好事吗？

您可以添加通用约束以确保类型实现IComparable<T>：

public static T MaxValue<T>(IEnumerable<T> collection) where T : IComparable<T>

使用CompareTo方法代替比较运算符。

我如何编写一个既适用于IEnumerable又适用于ObservableCollection的方法？

您的方法已适用于ObservableCollection<T>，因为它实现了IEnumerable<T>

作为旁注，你当前的实现有一个缺陷：它枚举了两次集合，在懒惰IEnumerable<T>的情况下，这是一个坏主意，因为枚举它可能会导致数据库调用，或者网络请求，或其他什么。通常，请避免多次枚举可枚举。

Answer 2

如果我定义一个通用方法：MaxValue<T>(IEnumerable<T> Collection) 我怎样才能确保没有人可以在没有＆lt;的自定义类型上使用它＆GT;界定？这是一件值得担心的好事吗？

如果我理解您所说的内容，则根本不能使用此处定义的通用方法。如果需要，您需要约束T来实施IComparable<T>，这样您就可以将其与其他值进行比较，或者在您的方法中使用IComparer<T>（然后就可以了需要约束）：

public T MaxValue<T>(IEnumerable<T> collection) where T : IComparable<T>
{
    T maxValue = default(T);
    foreach (var element in collection)
    {
        var comparsion = element.CompareTo(maxValue);
        if (comparsion > 0)
            maxValue = element;
    }
    return maxValue;
}

或者

public T MaxValue<T>(IEnumerable<T> collection, IComparer<T> comparer)
{
    T maxValue = default(T);
    foreach (var element in collection)
    {
        var comparsion = comparer.Compare(element, maxValue);
        if (comparsion > 0)
            maxValue = element;
    }
    return maxValue;
}

我如何只编写一个适用于IEnumerable和的ObservableCollection？

ObservableCollection<T>实施IEnumerable<T>。您可以做的是创建一个适用于任何IEnumerable<T>的扩展方法，类似于LINQ通过System.Linq命名空间工作的方式：

public static class Extensions
{
    public static T MaxValue<T>(this IEnumerable<T> collection) where T : IComparable<T>
    {
        T maxValue = default(T);
        foreach (var element in collection)
        {
            var comparsion = element.CompareTo(maxValue);
            if (comparsion > 0)
                maxValue = element;
        }
        return maxValue;
    }

    public static T MaxValue<T>(this IEnumerable<T> collection, IComparer<T> comparer)
    {
       T maxValue = default(T);
       foreach (var element in collection)
       {
           var comparsion = comparer.Compare(element, maxValue);
           if (comparsion > 0)
               maxValue = element;
       }
       return maxValue;
    }
}

Answer 3

如果我定义一个泛型方法：MaxValue（IEnumerable Collection）我如何确保没有人可以在没有＆lt;＆gt;的自定义类型上使用它界定？＆GT;这是一件值得担心的好事吗？

对于类似的东西，泛型约束总是派上用场，所以你可以定义一个接口，即：

public interface IMyInterface
{
    public decimal Amount { get; set; }
}

然后写一个方法：

public static decimal MaxValue<T>(IEnumerable<T> myCol) where T : IMyInterface
{
    decimal max = myCol.First().Amount;
   // then iterate collection to find max value, code ommitted
}

但正如已经说过的那样，你已经有了使用linq的方法来做到这一点，所以除非你真的需要这样做，否则请使用现有的。

ObservableCollection和IEnumerable的通用方法

3 个答案: