【软件基础】Linq优化双重for循环、批量写入Excel以提升程序运行速度、常见代码优化方法

文章目录

前言
一、使用Linq优化双重for循环
二、使用Office插件批量写入Excel
三、常见代码优化方法
- - 1、字符串拼接
  - [2、使用 LINQ 查询](#2、使用 LINQ 查询)
  - 3、频繁访问数据库
  - 4、频繁使用大对象图
  - 5、未使用索引进行查找
  - 6、频繁的装箱和拆箱操作
  - 7、使用递归导致堆栈溢出
  - 8、频繁的文件I/O操作
  - 9、未使用并行处理
总结

前言

在软件开发过程中，性能优化是一个至关重要的环节。当处理大量数据时，传统的双重for循环和逐个写入Excel的方式可能会成为性能瓶颈。本文将介绍两种优化方法：使用Linq来替代双重for循环，以及使用Office插件的批量写入功能来提升数据写入Excel的效率。

一、使用Linq优化双重for循环

双重for循环在处理二维数组或列表时很常见，但如果数据量较大，这种循环方式可能会导致性能问题。Linq（Language Integrated Query）是C#提供的一种强大的查询功能，它允许我们以声明性方式查询和操作数据，而无需编写显式的循环代码。

以下是一个使用双重for循环的示例：

csharp 复制代码

int[,] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };  
List<int> results = new List<int>();  
  
for (int i = 0; i < matrix.GetLength(0); i++)  
{  
    for (int j = 0; j < matrix.GetLength(1); j++)  
    {  
        if (matrix[i, j] % 2 == 0) // 假设我们找所有偶数  
            results.Add(matrix[i, j]);  
    }  
}

使用Linq优化后的代码：

csharp 复制代码

int[,] matrix = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };  
List<int> results = Enumerable.Range(0, matrix.GetLength(0))  
    .SelectMany(i => Enumerable.Range(0, matrix.GetLength(1)).Select(j => matrix[i, j]))  
    .Where(num => num % 2 == 0)  
    .ToList();

在上面的Linq示例中，我们使用Enumerable.Range来模拟二维数组的索引，然后使用SelectMany来"展平"二维结构，并通过Where筛选出偶数。最后，使用ToList将结果转换为列表。

二、使用Office插件批量写入Excel

当使用Office插件（如Microsoft.Office.Interop.Excel）将数据写入Excel时，逐个写入单元格的方式可能会导致性能下降。为了提高性能，我们可以使用批量写入的方式，即一次性将多个值写入一个范围。

以下是一个逐个写入单元格的示例：

csharp 复制代码

Excel.Application excelApp = new Excel.Application();  
Excel.Workbook workbook = excelApp.Workbooks.Add();  
Excel.Worksheet worksheet = (Excel.Worksheet)workbook.Sheets[1];  
  
for (int i = 1; i <= 1000; i++)  
{  
    worksheet.Cells[i, 1] = "数据" + i;  
}  
  
workbook.SaveAs("C:\\temp\\Test.xlsx");  
workbook.Close();  
excelApp.Quit();

使用批量写入优化后的代码：

csharp 复制代码

Excel.Application excelApp = new Excel.Application();  
Excel.Workbook workbook = excelApp.Workbooks.Add();  
Excel.Worksheet worksheet = (Excel.Worksheet)workbook.Sheets[1];  
  
// 准备要写入的数据  
object[,] data = new object[1000, 1];  
for (int i = 0; i < 1000; i++)  
{  
    data[i, 0] = "数据" + (i + 1);  
}  
  
// 批量写入数据  
Excel.Range range = worksheet.Range[worksheet.Cells[1, 1], worksheet.Cells[1000, 1]];  
range.Value2 = data;  
  
workbook.SaveAs("C:\\temp\\Test_Batch.xlsx");  
workbook.Close();  
excelApp.Quit();

在上面的优化示例中，我们首先创建了一个二维对象数组data来存储要写入的数据。然后，我们定义了一个Excel范围range，它覆盖了我们要写入的单元格。最后，我们将整个data数组一次性写入该范围，从而避免了逐个写入单元格的开销。

三、常见代码优化方法

1、字符串拼接

csharp 复制代码

string result = "";
for (int i = 0; i < 1000; i++)
{
    result += i.ToString();
}

优化:

使用 StringBuilder 类来优化字符串拼接。

csharp 复制代码

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
{
    sb.Append(i);
}
string result = sb.ToString();

2、使用 LINQ 查询

csharp 复制代码

var result = list.Where(x => x.Property == value).ToList();

优化

对于简单的过滤，使用 foreach 循环。

csharp 复制代码

List<T> result = new List<T>();
foreach (var item in list)
{
    if (item.Property == value)
    {
        result.Add(item);
    }
}

3、频繁访问数据库

csharp 复制代码

foreach (var item in items)
{
    var data = dbContext.GetData(item.Id);
    // Process data
}

优化

尽可能减少对数据库的访问，可以考虑在循环外部一次性获取所有数据。

csharp 复制代码

var itemIds = items.Select(i => i.Id).ToList();
var data = dbContext.GetDataForItems(itemIds);

foreach (var item in items)
{
    var itemData = data.FirstOrDefault(d => d.Id == item.Id);
    // Process itemData
}

4、频繁使用大对象图

csharp 复制代码

public class Person
{
    public string Name { get; set; }
    public List<Address> Addresses { get; set; }
    // Other properties
}

List<Person> people = GetPeopleFromDatabase();
foreach (var person in people)
{
    ProcessPerson(person);
}

优化

尽量避免加载完整的对象图，可以使用延迟加载或仅加载必要的属性。

csharp 复制代码

List<Person> people = GetPeopleFromDatabase();
foreach (var person in people)
{
    // Load addresses only when needed
    person.Addresses = GetAddressesForPerson(person.Id);
    ProcessPerson(person);
}

5、未使用索引进行查找

csharp 复制代码

var item = list.FirstOrDefault(x => x.Id == searchId);

优化

如果列表较大，应该使用索引进行快速查找。

csharp 复制代码

var dictionary = list.ToDictionary(x => x.Id);
var item = dictionary.ContainsKey(searchId) ? dictionary[searchId] : null;

6、频繁的装箱和拆箱操作

csharp 复制代码

int sum = 0;
for (int i = 0; i < 1000; i++)
{
    sum += i;
    object boxedSum = sum; // Boxing operation
    int unboxedSum = (int)boxedSum; // Unboxing operation
}

优化

避免不必要的装箱和拆箱操作，尽可能直接使用值类型。

csharp 复制代码

int sum = 0;
for (int i = 0; i < 1000; i++)
{
    sum += i;
}

7、使用递归导致堆栈溢出

csharp 复制代码

public int Factorial(int n)
{
    if (n == 0)
    {
        return 1;
    }
    else
    {
        return n * Factorial(n - 1); // Recursive call
    }
}

优化

避免深度递归调用，可以改为使用迭代或尾递归优化。

csharp 复制代码

public int Factorial(int n)
{
    int result = 1;
    for (int i = 1; i <= n; i++)
    {
        result *= i;
    }
    return result;
}

8、频繁的文件I/O操作

csharp 复制代码

foreach (var file in files)
{
    string content = File.ReadAllText(file);
    // Process file content
}

优化

减少文件I/O操作次数，尽可能合并读写操作。

csharp 复制代码

List<string> contents = new List<string>();
foreach (var file in files)
{
    contents.Add(File.ReadAllText(file));
}
// Process file contents

9、未使用并行处理

csharp 复制代码

List<int> numbers = Enumerable.Range(1, 1000000).ToList();
List<int> squaredNumbers = new List<int>();
foreach (var num in numbers)
{
    squaredNumbers.Add(num * num);
}

优化

使用并行处理可以提高处理速度。

csharp 复制代码

List<int> numbers = Enumerable.Range(1, 1000000).ToList();
List<int> squaredNumbers = new List<int>();
Parallel.ForEach(numbers, num =>
{
    squaredNumbers.Add(num * num);
});

总结

通过这两种优化方法，我们可以显著提高程序处理大量数据时的性能。但是，请注意，在使用Linq和Office插件时，还需要考虑其他性能因素，如内存使用和垃圾回收等。