检查集合中的所有项目是否具有相同的值

Question

一个名为 MeasurementCollection 的集合上的扩展方法检查每个项目的属性 Template.Frequency (Enum) 是否具有相同的值。

public static bool IsQuantized(this MeasurementCollection items)
{
    return  (from i in items 
             select i.Template.Frequency)
            .Distinct()
            .Count() == 1;
}

编辑 有关底层类的信息

MeasurementCollection : ICollection<IMeasurement>

IMeasurement 
{
    IMeasurementTemplate Template { get; }        
    ......
}

这是一种正确的方法，还是在 Linq 中已有更简单的解决方案？ 此方法将在应用程序中大量使用。

你有什么小窍门要跟我一起回到绘图板上吗？

Answer 1

您可以只找到第一个值并检查其他值是否不同，这将避免评估整个集合（除非单个不同的值是最后一个）

public static bool IsQuantized(this MeasurementCollection items)
{
    if(!items.Any())
        return false; //or true depending on your use case

    //might want to check that Template is not null, a bit a violation of level of demeter, but just an example
    var firstProp = items.First().Template.Frequency;

    return !items.Any(x=> x.Template.Frequency != firstProp);

}

Answer 2

编辑：解决 Timwi 对 3 个枚举器的担忧：

bool same = <your default> ;
var first = items.FirstOrDefault();
if (first != null)  // assuming it's a class
{
   same = items.Skip(1).All(i => i.Template.Frequency == first.Template.Frequency); 
}

仍然使用 2 个枚举器。对于普通的List<> 来说不是问题，但对于数据库查询，使用可读性较差的可能会有所帮助：

bool same = <your default> ;
Item first = null;

foreach(var item in items)
{
    if (first == null)
    {
        first = item;
        same = true;
    }
    else
    {
        if (item.Template.Frequency != first.Template.Frequency)
        {
           same = false;
           break;
        }
    }
}

Answer 3

首先是一般的 linq 建议。如果您只是想知道集合中是否恰好有一个，请使用 Single() 或 SingleOrDefault()。 Count 可能会迭代整个集合，这超出了您的需要，因为如果有两个，您可以退出。

public static bool IsQuantized(this MeasurementCollection items)
        {
            var first = items.FirstOrDefault();
            return first != null && items.Skip(1).All(i => first.Template.Frequency == i.Template.Frequency));
        }

Answer 4

我得到了一点灵感，想到了一个只考虑速度的解决方案。这确实不是那么可读（我通常更喜欢），但在速度方面的特性应该是相当不错的。

对于大多数其他实现 O(n) 来说，最坏的情况是相同的，但这是极不可能的，因为它要求所有元素的前半部分相等 并且 后半部分都相等但不等于前半部分的值。 并且需要与线性搜索相同数量的比较。 在大多数其他情况下，第一个奇数位于随机位置，这需要的比较次数是线性比较的一半。 在值成对的情况下。所以 item[0] == item[1] and item[2] == item[3] and item[0] != item[2] （和类似）然后线性搜索会更快。 一般来说，无论是随机数据还是少数奇数，这应该比线性搜索更快

public static bool AllSame<T>(this IEnumerable<T> source,
                              IEqualityComparer<T> comparer = null)
        {
            if (source == null)
                throw new ArgumentNullException("source cannot be null.", "source");

            if (comparer == null)
                comparer = EqualityComparer<T>.Default;
            var enumerator = source.GetEnumerator();

            return source.Zip(comparer);
        }

        private static bool Zip<T>(this IEnumerable<T> sequence, IEqualityComparer<T> comparer)
        {
            var result = new List<T>();
            var enumerator = sequence.GetEnumerator();
            while (enumerator.MoveNext())
            {
                var first = enumerator.Current;
                result.Add(enumerator.Current);
                if (enumerator.MoveNext())
                {
                    if (!comparer.Equals(first, enumerator.Current))
                    {
                       return false;
                    }
                }
                else
                {
                    break;
                }
            }
            return result.Count == 1 ? true : result.Zip(comparer);
        }

如果没有尾调用优化，这会使用额外的内存（最坏的情况是内存量接近原始源使用的内存量）。调用堆栈不应该深入，因为没有 IEnumerable 具体实现（至少我知道）可以容纳超过 int.MaxValue 元素。这需要最多 31 次递归。

Answer 5

这样会更快：

public static bool IsQuantized(this MeasurementCollection items)
{
    if(items == null || items.Count == 0)
       return true;

    var valueToCompare = items.First().Template.Frequency;

    return items.All(i => i.Template.Frequency == valueToCompare);
}

它将在第一个项目的模板频率不同时返回 false，而在您的代码中，算法会传递整个集合。

Answer 6

我是这样做的：

public static bool Same<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
    {
        var val = source.Select(keySelector).FirstOrDefault();

        return source.Select(keySelector).All(a => Object.Equals(a, val));
    }

用途：

ddlStatus.AppendDataBoundItems = true;
ddlStatus.Items.Add(new ListItem("<Mixed>", "-1"));
ddlStatus.DataSource = ctx.Status.OrderBy(s => s.AssetStatus).ToList();
ddlStatus.DataTextField = "AssetStatus";
ddlStatus.DataValueField = "id";
ddlStatus.SelectedValue = Assets.Same(a => a.AssetStatusID) ? Assets.FirstOrDefault().AssetStatusID.ToString() : "-1";
ddlStatus.DataBind();

这是一个包含可用状态列表的下拉框。表单编辑多个资产。下拉列表需要知道资产是否都具有相同的价值。我的 Same 扩展程序就是这样做的。

Answer 7

我建议以下解决方案：

private static bool IsSameCollections(ICollection<> collection1, ICollection<> collection2)
        {
          return collection1.Count == collection2.Count &&
     (collection1.Intersect(collection2).Count() == collection1.Count);
        }