文章目录
前言
在软件开发过程中，性能优化是一个至关重要的环节。当处理大量数据时，传统的双重for循环和逐个写入Excel的方式可能会成为性能瓶颈。本文将介绍两种优化方法：使用Linq来替代双重for循环，以及使用Office插件的批量写入功能来提升数据写入Excel的效率。
一、使用Linq优化双重for循环
双重for循环在处理二维数组或列表时很常见，但如果数据量较大，这种循环方式可能会导致性能问题。Linq（Language Integrated Query）是C#提供的一种强大的查询功能，它允许我们以声明性方式查询和操作数据，而无需编写显式的循环代码。
以下是一个使用双重for循环的示例：
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优化后的代码：
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时，逐个写入单元格的方式可能会导致性能下降。为了提高性能，我们可以使用批量写入的方式，即一次性将多个值写入一个范围。
以下是一个逐个写入单元格的示例：
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();
使用批量写入优化后的代码：
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、字符串拼接
string result = "";
for (int i = 0; i < 1000; i++)
{
result += i.ToString();
}
优化:
使用 StringBuilder 类来优化字符串拼接。
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++)
{
sb.Append(i);
}
string result = sb.ToString();
2、使用 LINQ 查询
var result = list.Where(x => x.Property == value).ToList();
优化
对于简单的过滤，使用 foreach 循环。
List<T> result = new List<T>();
foreach (var item in list)
{
if (item.Property == value)
{
result.Add(item);
}
}
3、频繁访问数据库
foreach (var item in items)
{
var data = dbContext.GetData(item.Id);
// Process data
}
优化
尽可能减少对数据库的访问，可以考虑在循环外部一次性获取所有数据。
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、频繁使用大对象图
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);
}
优化
尽量避免加载完整的对象图，可以使用延迟加载或仅加载必要的属性。
List<Person> people = GetPeopleFromDatabase();
foreach (var person in people)
{
// Load addresses only when needed
person.Addresses = GetAddressesForPerson(person.Id);
ProcessPerson(person);
}
5、未使用索引进行查找
var item = list.FirstOrDefault(x => x.Id == searchId);
优化
如果列表较大，应该使用索引进行快速查找。
var dictionary = list.ToDictionary(x => x.Id);
var item = dictionary.ContainsKey(searchId) ? dictionary[searchId] : null;
6、频繁的装箱和拆箱操作
int sum = 0;
for (int i = 0; i < 1000; i++)
{
sum += i;
object boxedSum = sum; // Boxing operation
int unboxedSum = (int)boxedSum; // Unboxing operation
}
优化
避免不必要的装箱和拆箱操作，尽可能直接使用值类型。
int sum = 0;
for (int i = 0; i < 1000; i++)
{
sum += i;
}
7、使用递归导致堆栈溢出
public int Factorial(int n)
{
if (n == 0)
{
return 1;
}
else
{
return n * Factorial(n - 1); // Recursive call
}
}
优化
避免深度递归调用，可以改为使用迭代或尾递归优化。
public int Factorial(int n)
{
int result = 1;
for (int i = 1; i <= n; i++)
{
result *= i;
}
return result;
}
8、频繁的文件I/O操作
foreach (var file in files)
{
string content = File.ReadAllText(file);
// Process file content
}
优化
减少文件I/O操作次数，尽可能合并读写操作。
List<string> contents = new List<string>();
foreach (var file in files)
{
contents.Add(File.ReadAllText(file));
}
// Process file contents
9、未使用并行处理
List<int> numbers = Enumerable.Range(1, 1000000).ToList();
List<int> squaredNumbers = new List<int>();
foreach (var num in numbers)
{
squaredNumbers.Add(num * num);
}
优化
使用并行处理可以提高处理速度。
List<int> numbers = Enumerable.Range(1, 1000000).ToList();
List<int> squaredNumbers = new List<int>();
Parallel.ForEach(numbers, num =>
{
squaredNumbers.Add(num * num);
});
总结
通过这两种优化方法，我们可以显著提高程序处理大量数据时的性能。但是，请注意，在使用Linq和Office插件时，还需要考虑其他性能因素，如内存使用和垃圾回收等。
