C# 独立搜索更快的收集机会

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

在.NET Framework用法/System.collection下有以下独立查询

// <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

//注意List.Contains（）
让containsMethods=ThirdParty.Methods.WithFullNameIn(
“System.Collections.Generic.List.Contains（T）”，
“System.Collections.Generic.IList.Contains（T）”，
“System.Collections.ArrayList.Contains（对象）”）
在应用程序中从m开始。方法。使用任何（包含方法）
选择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));
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.Threading.Tasks；
名称空间列表优化
{
班级计划
{
静态void Main（字符串[]参数）
{
内部长度=10000；
List aNumbers2Search=Enumerable.Range（0，aLength.ToList（）；
List-aTestList=Enumerable.Range（0，aLength.ToList（）；
int[]aTestArray=Enumerable.Range（0，aLength.ToArray（）；
HashSet-aTestHash=新的HashSet（Enumerable.Range（0，aLength））；
字典aTestDictionary=新字典（）；
对于（inti=0；itestList_in.Contains（x））；
}
私有静态无效搜索（HashSet testHash_in，List numbers2Search_in）
{
ForEach中的numbers2Search_（x=>testHash_in.Contains（x））；
}
专用静态无效搜索（Dictionary testDictionary\u in，List Numbers 2Search\u in）
{
ForEach中的numbers2Search_（x=>testDictionary_in.ContainsKey（x））；
}
专用静态无效搜索（int[]测试阵列，列表编号2搜索）
{
ForEach中的numbers2Search_（x=>testArray_in.Contains（x））；
}
私有静态无效搜索IList（IList TestList_in，List Numbers 2Search_in）
{
ForEach中的numbers2Search_（x=>TestList_in.Contains（x））；
}
私有静态无效搜索IEnumerable（IEnumerable TestEnumerable_in，列表编号2Search_in）
{
ForEach中的numbers2Search_（x=>TestEnumerable_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>

//注意列表样式包含
让containsMethods=ThirdParty.Methods.WithSimpleName（“Contains”）。除了（ThirdParty.Methods.WithFullNameIn（“System.Collections.Generic.HashSet.Contains（T）”）之外）
在应用程序中从m开始。方法。使用任何（包含方法）
选择m
//
//使用List.Contains（）警告的替代方法
//

这将列出4个函数（list、IList、int[]和IEnumerable）。 我是CQLinq方面的新手。 我的问题是：

• 是否有人可以编写更好的查询来检测可能存在的错误.NET容器用法（不仅针对包含，还针对其他可能的操作）
• 您如何或将如何检测不良的容器使用情况

---

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

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

---

使用该工具将获得更好的结果。如果要通过搜索某些代码模式来提高性能，请尝试搜索嵌套循环和昂贵的代码，如文件和数据库相关方法。

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

---

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

确实尝试用

Hashset.Contains（）替换
List.Contains（）
调用。Contains（）

调用不是一种微观优化，可以显著提高性能。事实上，根据我的经验，重构算法以依赖O（1）哈希集搜索是提高性能的最佳方法之一

---

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

确实试图替换

列表。Contains（）

调用Hashset.Contains（）调用不是一种微优化，可以显著提高性能。事实上，根据我的经验，重构算法以依赖O（1）哈希集搜索是提高性能的最佳方法之一

您编写的CQLinq查询是识别一些潜在的慢点的第一步。但是，要想开始良好的重构，您必须1）在运行时检查代码以评估集合大小，2）根据实际情况评估这些潜在的慢点是否会对性能产生影响，并找出其他慢点不匹配的慢点