0

我有一个庞大的遗留代码库，我想优化它，让它更快。出于这个原因，我考虑寻找可以用 HashSet 和字典替换列表和数组的机会。

.NET Framework Usage / System.collection 下有以下 NDepend 查询

// <Name>Caution with List.Contains()</Name>
let containsMethods = ThirdParty.Methods.WithFullNameIn(
   "System.Collections.Generic.List<T>.Contains(T)",
   "System.Collections.Generic.IList<T>.Contains(T)",
   "System.Collections.ArrayList.Contains(Object)")

from m in Application.Methods.UsingAny(containsMethods) 
select m

这个查询是不够的。它将列出一个带有以下代码的函数：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ListOptimisation
{
    class Program
    {
        static void Main(string[] args)
        {
            int aLength = 10000;
            List<int> aNumbers2Search = Enumerable.Range(0, aLength).ToList();

            List<int> aTestList = Enumerable.Range(0, aLength).ToList();
            int[] aTestArray = Enumerable.Range(0, aLength).ToArray();

            HashSet<int> aTestHash = new HashSet<int>(Enumerable.Range(0, aLength));
            Dictionary<int, int> aTestDictionary = new Dictionary<int, int>();
            for(int i = 0; i < aLength; ++i)
            {
                aTestDictionary.Add(i, i);
            }

            Search(aTestList, aNumbers2Search);
            SearchIList(aTestList, aNumbers2Search);
            SearchIEnumerable(aTestList, aNumbers2Search);
            Search(aTestArray, aNumbers2Search);
            SearchIList(aTestArray, aNumbers2Search);
            SearchIEnumerable(aTestArray, aNumbers2Search);
            Search(aTestHash, aNumbers2Search);
            SearchIEnumerable(aTestHash, aNumbers2Search);
            Search(aTestDictionary, aNumbers2Search);
        }

        private static void Search(List<int> testList_in, List<int> numbers2Search_in)
        {
            numbers2Search_in.ForEach(x => testList_in.Contains(x));
        }

        private static void Search(HashSet<int> testHash_in, List<int> numbers2Search_in)
        {
            numbers2Search_in.ForEach(x => testHash_in.Contains(x));
        }

        private static void Search(Dictionary<int, int> testDictionary_in, List<int> numbers2Search_in)
        {
            numbers2Search_in.ForEach(x => testDictionary_in.ContainsKey(x));
        }

        private static void Search(int[] testArray_in, List<int> numbers2Search_in)
        {
            numbers2Search_in.ForEach(x => testArray_in.Contains(x));
        }

        private static void SearchIList(IList<int> testIList_in, List<int> numbers2Search_in)
        {
            numbers2Search_in.ForEach(x => testIList_in.Contains(x));
        }

        private static void SearchIEnumerable(IEnumerable<int> testIEnumerable_in, List<int> numbers2Search_in)
        {
            numbers2Search_in.ForEach(x => testIEnumerable_in.Contains(x));
        }
    }
}

一个更好的查询是这个：

// <Name>Caution with List style contains</Name>
let containsMethods = ThirdParty.Methods.WithSimpleName("Contains").Except(ThirdParty.Methods.WithFullNameIn("System.Collections.Generic.HashSet<T>.Contains(T)"))

from m in Application.Methods.UsingAny(containsMethods) 
select m

//<Description>
// Alternative to Caution with List.Contains()
//</Description>

这将列出 4 个函数（List、IList、int[]、IEnumerable）。我是关于 CQLinq 的新手。我的问题是：

  • 有没有人可以编写更好的查询来检测可能的不良 .NET 容器使用情况（不仅用于包含，还用于其他可能的操作）？
  • 您如何或将如何检测不良容器使用情况？

最后一点，我们的一些业务逻辑处理大量数据，因此拥有正确的容器、数据结构和算法很重要。

4

2 回答 2

1

确实尝试用调用替换List<T>.Contains()调用Hashset<T>.Contains()不是微优化，并且可以显着提高性能。根据我的经验，实际上重构算法以依赖 O(1) 哈希集搜索是提高性能的最佳方法之一。

您编写的 CQLinq 查询是识别一些潜在慢点的第一步。但是，要开始良好地重构，您必须1) 在运行时查看代码以评估集合大小，以及 2) 在实际情况下使用性能分析工具来评估这些潜在的慢点是否对性能有影响，并找到其他的查询不匹配的慢点。

于 2016-07-26T09:24:13.577 回答
1

这不是优化性能问题的好方法。除非您处理大量列表，否则此优化将对您的系统产生轻微影响。

使用性能分析软件会获得更好的结果。如果您想通过搜索一些代码模式来提高性能，请尝试搜索嵌套循环和昂贵的代码，例如文件和数据库相关的方法。

于 2016-07-22T17:53:15.823 回答