0

我有一个双 foreach 循环，并希望通过使其成为一个循环而不是两个循环来加速它。

这个想法是它从字典中获取一个元素并将其与字典中的所有元素进行比较

foreach (KeyValuePair<Int64, string> kvp in originCounts)
{
    foreach (KeyValuePair<Int64, string> testkvp in originCounts)
    {
    //Run Comparison on testkvp ad kvp
    }
}

我想把它变成一个循环，有什么建议吗？

4

6 回答 6

2

您可以使用Enumerable.All检查所有元素是否相同：

var firstID = originCounts.First().Value.UserID;
bool allEquals = originCounts.Skip(1).All(o => o.Value.UserID == firstID);

看来这就是你真正想要的。

我刚刚在重复的问题中挑选了你班级的一个字段，听起来是一个合理的标识符。

public class MyObject 
{
    public string FirstName{ get; set; }
    public string LastName{ get; set; }
    public int UserID { get; set; }
    public string Address { get; set; }
}

编辑：根据您的评论，您想确定是否有任何对象的字段与另一个对象的同一字段不同。

var first = originCounts.First().Value;
bool allEquals = originCounts.Skip(1).All(o =>
                o.Value.FirstName == first.FirstName
             && o.Value.LastName  == first.LastName
             && o.Value.UserID    == first.UserID
             && o.Value.Address   == first.Address);
于 2012-11-15T15:29:06.267 回答
0

您可以尝试使用 linq 语法并比较性能

例如

foreach(KeyValuePair<long, string> kvp1 in originCounts.SelectMany(kvp1 => originCounts.Select(testkvp => kvp1), (kvp1, kvp) => kvp1)) {

}

或者

foreach(KeyValuePair<long, string> kvp1 in from kvp1 in originCounts
                                                 from kvp in originCounts.Select(testkvp => kvp1)
                                                 select kvp1) {
}
于 2012-11-15T14:05:54.087 回答
0

您可以创建实现IComparable接口的可比较字符串键值类。

public class ComparableString : IComparable
{
    public Int64 Key { get; set; }

    public string Value { get; set; }

    public int CompareTo(object obj)
    {
        if (obj == null) return 1;

        string otherString = obj as ComparableString;

        if (otherString != null)
        {
            // PLACE YOUR COMPARE LOGIC HERE
            return this.Value.CompareTo(otherString.Value);
        }
        else
        {
            throw new ArgumentException("Object is not a Comparable String");
        }
    }
}

之后，您可以创建一个链表并运行 .sort 方法

var originCounts= new List<ComparableString>();
// Logic to fill your list
originCounts.Sort();

.Sort 方法的平均复杂度为 O(n(log n))，最坏的情况为 O(n^2)，请参阅http://msdn.microsoft.com/en-us/library/b0zbh7b6.aspx了解更多信息信息。

一旦你调用了 .Sort() 方法，你就会知道你的项目索引之前的任何值都小于或等于你的项目的值，并且任何大于你所在索引的索引都大于或等于您的物品的价值。

于 2012-11-15T14:11:34.277 回答
0

也许我误解了这个问题而过度简化了这一点，但如果您只是想在字符串中查找重复的值，您可以使用 Dictionary 的 Values 属性，并对它们进行区分。

使用您的字典示例：

    Dictionary<Int64, string> originalCounts = new Dictionary<Int64, string>();
    for (Int64 i = 0; i < 10; i++)
    {
        originalCounts.Add(i, i.ToString());
    }
    originalCounts[5] = originalCounts[3];

    foreach (var kvp in originalCounts)
    {
        Console.WriteLine("{0}  {1}", kvp.Key, kvp.Value);
    }

    Console.WriteLine();

    foreach (var value in originalCounts.Values.Distinct())
    {
        Console.WriteLine("{0}", value);
    }
于 2012-11-15T14:28:52.450 回答
0

如果我理解正确，获取不同的对象（不实现 IComparable 或覆盖 Equals 和 GetHashcode）：

var noDups = originCounts
                                 //Any Prop. you want to compare
              .GroupBy(o => new { o.FirstName, o.LastName, o.UserID, o.Address })
              .Select(g => g.First())
              .ToList();
于 2012-11-15T15:47:55.043 回答
-1

为什么要将字典条目与同一字典中的其他条目进行比较？你在检查重复项吗？如果是这样，您可以使用originCounts.Distinct().

编辑：您需要IEqualityComparer为该Distinct方法指定一个，否则它只会比较键（在 a 中总是不同的Dictionary），而不是值。

于 2012-11-15T14:01:51.457 回答