C# Generic List<T> 更新项目

Question

我正在使用List<T>，我需要更新列表中的对象属性。

最高效/更快的方法是什么？我知道随着列表的增长，扫描List<T> 的索引会变慢，而且List<T> 并不是进行更新的最有效集合。

那伤心，不如：

• 删除匹配对象然后添加一个新对象？
• 扫描列表索引，直到找到匹配的对象，然后更新对象的属性？
• 如果我有一个集合，让我们使用 IEnumerable，并且我想将该 IEnumerable 更新到列表中，最好的方法是什么。

存根代码示例：

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
}

public class ProductRepository
{
    List<Product> product = Product.GetProduct();
    public void UpdateProducts(IEnumerable<Product> updatedProduct)
    {
    }
    public void UpdateProduct(Product updatedProduct)
    {
    }
}

Answer 1

如果您想要快速查找，可以考虑使用 Dictionary 而不是 List。在您的情况下，它将是产品 ID（我假设它是唯一的）。 Dictionary MSDN

例如：

public class ProductRepository
    {
        Dictionary<int, Product> products = Product.GetProduct();
        public void UpdateProducts(IEnumerable<Product> updatedProducts)
        {
            foreach(var productToUpdate in updatedProducts)
            {
                UpdateProduct(productToUpdate);
            }

            ///update code here...
        }
        public void UpdateProduct(Product productToUpdate)
        {
            // get the product with ID 1234 
            if(products.ContainsKey(productToUpdate.ProductId))
            {
                var product = products[productToUpdate.ProductId];
                ///update code here...
                product.ProductName = productToUpdate.ProductName;
            }
            else
            {
                //add code or throw exception if you want here.
                products.Add(productToUpdate.ProductId, productToUpdate);
            }
        }
    }

Answer 2

您的用例正在更新一个List<T>，它可以包含数百万条记录，并且更新的记录可以是一个子列表或只是一条记录

以下是架构：

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
}

Product 是否包含主键，这意味着每个 Product 对象都可以唯一标识，并且没有重复项，并且每次更新都针对单个唯一记录？

如果是，那么最好以Dictionary<int,T> 的形式排列List<T>，这意味着对于IEnumerable<T>，每次更新都是O(1) 的时间复杂度和这意味着所有更新都可以根据IEnumerable<T> 的大小来完成，我不希望它很大，尽管需要为不同的数据结构分配额外的内存，但这将是一个非常快速的解决方案.@JamieLupton 已经提供了类似的解决方案

如果Product被重复，没有主键，那么上面的解决方案是无效的，那么扫描List<T>的理想方法是Binary Search，其时间复杂度是O(logN)

现在由于IEnumerable<T>的大小相对较小，比如M，所以整体时间复杂度为O(M*logN)，其中M远小于N，可以忽略。

List<T> 支持 Binary Search API，它提供元素索引，然后可以使用它来更新相关索引处的对象，请查看example 这里

对于如此多的记录，我认为最好的选择是并行处理和二分搜索

既然，线程安全是个问题，我通常做的是将List<T>划分为List<T>[]，这样每个单元都可以分配给一个单独的线程，一个简单的方法是使用MoreLinq批处理Api，您可以使用Environment.ProcessorCount 获取系统处理器的数量，然后按如下方式创建IEnumerable<IEnumerable<T>>：

var enumerableList = List<T>.Batch(Environment.ProcessorCount).ToList();

另一种方法是遵循自定义代码：

public static class MyExtensions
{
    // data - List<T>
    // dataCount - Calculate once and pass to avoid accessing the property everytime
    // Size of Partition, which can be function of number of processors
    public static List<T>[] SplitList<T>(this List<T> data, int dataCount, int partitionSize)
    {
        int remainderData;    
        var fullPartition = Math.DivRem(dataCount, partitionSize, out remainderData);    
        var listArray = new List<T>[fullPartition];    
        var beginIndex = 0;

        for (var partitionCounter = 0; partitionCounter < fullPartition; partitionCounter++)
        {
            if (partitionCounter == fullPartition - 1)
                listArray[partitionCounter] = data.GetRange(beginIndex, partitionSize + remainderData);
            else
                listArray[partitionCounter] = data.GetRange(beginIndex, partitionSize);    
            beginIndex += partitionSize;
        }    
        return listArray;
    }
}

现在您可以在上面生成的List<T>[] 上创建Task[]，其中每个Task 分配给每个元素List<T>，然后对每个子分区进行二进制搜索。虽然它是重复的，但会使用并行处理和二进制搜索的力量。每个Task都可以启动，然后我们可以使用Task.WaitAll(taskArray)等待Task处理完成

除此之外，如果您想创建一个Dictionary<int,T>[] 并因此使用并行处理，那么这将是最快的。

List<T>[] 到 List<T> 的最终集成可以使用 Linq Aggregation 或 SelectMany 完成，如下所示：

List<T>[] splitListArray = Fetch splitListArray;

// Process  splitListArray

var finalList = splitListArray.SelectMany(obj => obj).ToList()

另一种选择是使用Parallel.ForEach 以及像ConcurrentBag<T> 这样的线程安全数据结构，或者在替换完整对象的情况下可能是ConcurrentDictionary<int,T>，但是如果它的属性更新，那么简单的List<T> 就可以了. Parallel.ForEach 内部使用类似于我上面建议的范围分区器

上述解决方案理想情况下取决于您的用例，您应该能够使用组合来达到最佳效果。如果您需要具体示例，请告诉我

Answer 3

究竟什么是效率？

除非确实有数千个项目在执行 foreach、for 或任何其他类型的循环操作，否则很可能只会显示以毫秒为单位的差异。真的吗？因此，您在试图找到最佳方面浪费了更多时间（程序员的成本为每小时 XX 美元，而不是最终用户的成本）。

因此，如果您实际上有数千条记录，我建议通过使用 Parallel.Foreach 方法并行处理列表来提高效率，该方法可以处理更多记录以节省线程开销的时间。

---

恕我直言，如果记录数大于 100，则表示正在使用数据库。如果涉及数据库，请编写一个更新存储过程并收工；我很难编写一个一次性程序来执行特定更新，这可以在所述数据库中以更简单的方式完成。