C#使用stringBuilder.Append超1G报内存错误

cxnet · 发表于 2024-7-17 16:50:36

马上注册，结交更多好友，享用更多功能^_^

您需要登录才可以下载或查看，没有账号？立即注册

x

最近弄个字符串处理工具，因为要查找替换的字符串长度有点长，如果分块读入后查找替换很可能要替换的内容被分成2段导致替换漏掉，所以为了能彻底替换完整所以需要将整个字符串循环读入拼接完整后再查找替换，但是我使用stringBuilder.Append();在拼接字符串时，每次在1G左右就会报System.OutOfMemoryException错误，请问有什么办法解决这个问题吗？

FishC · 发表于 2024-7-17 16:52:19

哈哈，看来你把字符串硬是吃成了“破纪录的长面条”！不过面条太长了也容易噎着，C#的`StringBuilder`也是一样，遇到太大的字符串就会报内存错误。别担心，这里有几个办法能帮你解决这个问题：

### 1. 分块处理
尽可能避免一次性加载超大的字符串。虽然你提到了分块处理会导致替换漏掉，但可以考虑稍微复杂一点的逻辑来解决这个问题。例如：

- 每次读取部分字符，并保证每次读取有部分重叠。
- 在替换时，检查重叠部分是否有跨块的替换情况。

### 2. 使用临时文件
如果需要处理非常大的文本，可以考虑将中间结果写入临时文件而不是都保存在内存中。C# 提供了 `StreamWriter` 和 `StreamReader` 来帮助处理文件 I/O。

using (StreamWriter writer = new StreamWriter("temp.txt"))
{
// 假设你有一个方法来分块读取和替换内容：
foreach (var chunk in ReadAndReplaceChunks("sourceFile.txt"))
{
writer.Write(chunk);
}
}

复制代码

### 3. 操作内存映射文件（Memory-Mapped Files）
对于超大文件，内存映射文件（Memory-Mapped Files）是一种高效的解决方案。它允许你把文件的一部分映射到内存中，从而避免一次性读取整个文件。

using System.IO.MemoryMappedFiles;
using (var mmf = MemoryMappedFile.CreateFromFile("largefile.txt", FileMode.Open))
{
using (var accessor = mmf.CreateViewAccessor())
{
// 这里可以像数组一样访问文件内容
byte value = accessor.ReadByte(0);
// 进行你的替换逻辑
}
}

复制代码

### 4. 增加内存
如果上述方法都不适合你的需求，也可以考虑增加服务器的物理内存或在64位环境下运行程序，以获取更多的可用内存。不过，这不是根本解决方法，毕竟内存再大也有上限。

### 5. 使用其他数据结构
根据具体情况，也可以使用其他更高效的数据结构来存储和操作大字符串，例如链表、数组等，以减少内存占用和提高操作效率。

希望这些方法能帮到你，让你的工具不再“噎”住，顺利地“吞”下任何长度的字符串！如果你有更多问题，尽管甩过来哈~

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

行客 · 发表于 2024-7-18 12:59:21

FishC 发表于 2024-7-17 16:52
哈哈，看来你把字符串硬是吃成了“破纪录的长面条”！不过面条太长了也容易噎着，C#的`StringBuilder`也是 ...

即使你希望保留整个字符串的完整性以进行查找和替换，也不一定非得一次性加载整个字符串到内存中。你可以将文件读取为多个小块，每读取一小块，就使用StringBuilder󠁪进行处理，处理完一块后再读取下一块。
• 你可以设置一个合理大小的缓冲区，比如几百兆字节，这样可以减少内存消耗。
• 使用流式处理：
• 你可以使用StreamReader󠁪和StreamWriter等类来流式读取和写入数据，这样可以避免一次性加载整个文件到内存中。每次读取一部分数据，处理后再写入新的文件，直到文件完全处理完毕。
下面是一个使用C#处理大型文本文件，同时确保跨行或跨缓冲区边界的替换操作正确的示例：

using System;
using System.IO;
using System.Text;
class LargeFileReplacer
{
static void Main()
{
string inputFilePath = @"C:\path\to\your\largefile.txt";
string outputFilePath = @"C:\path\to\your\outputfile.txt";
string searchPattern = "very_long_pattern_to_search";
string replacePattern = "replacement_text";
ProcessFile(inputFilePath, outputFilePath, searchPattern, replacePattern);
}
static void ProcessFile(string inputFilePath, string outputFilePath, string searchPattern, string replacePattern)
{
int bufferSize = 1024 * 1024 * 5; // 5 MB buffer size
using (var inputFile = new StreamReader(inputFilePath))
using (var outputFile = new StreamWriter(outputFilePath))
{
char[] buffer = new char[bufferSize];
StringBuilder contextBuffer = new StringBuilder();
int charsRead;
while ((charsRead = inputFile.ReadBlock(buffer, 0, bufferSize)) > 0)
{
contextBuffer.Append(new string(buffer, 0, charsRead));
// Check and replace patterns that may span the current buffer and the previous buffer contents.
while (contextBuffer.ToString().Contains(searchPattern))
{
contextBuffer.Replace(searchPattern, replacePattern);
outputFile.Write(contextBuffer.ToString().Split(searchPattern.ToCharArray(), StringSplitOptions.None)[0]);
contextBuffer.Remove(0, contextBuffer.ToString().IndexOf(searchPattern) + searchPattern.Length);
}
}
// Write remaining context to the output file
if (contextBuffer.Length > 0)
{
outputFile.Write(contextBuffer.ToString());
}
}
}
}

复制代码

注意事项
确保
bufferSize

的大小合适，既要能够容纳最长的待查找字符串，也要考虑到你的系统内存限制。
在替换后，记得从
StringBuilder

中移除已处理的部分，否则你可能会继续处理同一段数据，导致不必要的重复工作。
上述代码示例中的
contextBuffer.Replace(...)

和
outputFile.Write(...)

操作需要确保正确处理边界条件，避免遗漏或重复替换。
通过这种方法，你可以有效地处理大型文本文件中的查找和替换操作，同时避免因分段造成的错误。

FishC · 发表于 2024-7-18 12:59:42

行客发表于 2024-07-18 12:59
即使你希望保留整个字符串的完整性以进行查找和替换， ...

哈哈，这方法就像吃大面条时分段吃，确保每一口都吃得彻底！下面是修正和详细实现的代码示例，确保处理大文件时，查找和替换操作能正确进行：

using System;
using System.IO;
using System.Text;
class LargeFileReplacer
{
static void Main()
{
string inputFilePath = @"C:\path\to\your\largefile.txt";
string outputFilePath = @"C:\path\to\your\outputfile.txt";
string searchPattern = "very_long_pattern_to_search";
string replacePattern = "replacement_text";
ProcessFile(inputFilePath, outputFilePath, searchPattern, replacePattern);
}
static void ProcessFile(string inputFilePath, string outputFilePath, string searchPattern, string replacePattern)
{
int bufferSize = 1024 * 1024 * 5; // 5 MB buffer size
char[] buffer = new char[bufferSize];
StringBuilder contextBuffer = new StringBuilder();
using (var inputFile = new StreamReader(inputFilePath))
using (var outputFile = new StreamWriter(outputFilePath))
{
int charsRead;
while ((charsRead = inputFile.ReadBlock(buffer, 0, bufferSize)) > 0)
{
contextBuffer.Append(buffer, 0, charsRead);
// Ensure we handle the last part of the context buffer in the next iteration
int processLength = contextBuffer.Length - searchPattern.Length;
string processText = contextBuffer.ToString(0, processLength);
processText = processText.Replace(searchPattern, replacePattern);
outputFile.Write(processText);
// Keep the unprocessed part in the context buffer
string remainingText = contextBuffer.ToString(processLength, contextBuffer.Length - processLength);
contextBuffer.Clear();
contextBuffer.Append(remainingText);
}
// Write remaining context to the output file
if (contextBuffer.Length > 0)
{
string finalText = contextBuffer.ToString().Replace(searchPattern, replacePattern);
outputFile.Write(finalText);
}
}
}
}

复制代码

### 注意事项
1. **设置缓冲区大小**：缓冲区大小设置为5MB，可以根据实际需要调整。但要确保缓冲区大小能容纳最长的查找字符串。

2. **保留未处理部分**：每次从`contextBuffer`中处理完一部分后，保留未处理的部分，以确保在下次读取时能正确处理跨块的替换。

3. **边界处理**：在替换操作中，处理好边界条件，确保不遗漏或重复替换。

通过这种方法，可以有效地处理超大文件中的查找和替换操作，同时避免一次性加载整个文件到内存中，避免内存不足的问题。希望这解决方案能帮你顺利吃完“大面条”，处理好所有字符串替换问题！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet · 发表于 2024-7-18 14:53:19

非常感谢楼上两位大佬的帮助，我是通过Socket接收本机TCP端口的数据进行处理，之前是通过append拼接成完整的字符串进行处理时发现超1G就内存错误，后来又一想，数据比较小的时侯拼接完了再处理还可以，但是数据稍大，即便是解决了拼接超大数据内存问题，这也比较消耗时间，所以我想每次接收数据同步进行处理并写到文件，如果发现最后需要替换的内容被分割了导致不完整就直接将后面要替换的内容给提取出来并将提取部份从原数据删除再将拼接到下一次新接收的数据的最前面，这样应该比较快。

FishC · 发表于 2024-7-18 14:54:01

cxnet 发表于 2024-07-18 14:53
非常感谢楼上两位大佬的帮助，我是通过Socket接收本机 ...

你这个思路不错，边接收数据边处理，避免了内存过大的问题，并且处理效率也会更高。这里提供一个实现思路，通过 `Socket` 接收数据并同步处理，每次接收到数据后，检查是否有跨段的替换内容，并处理好跨段的情况。

using System;
using System.IO;
using System.Net.Sockets;
using System.Text;
class SocketDataProcessor
{
private const int BufferSize = 1024 * 1024; // 1MB buffer size
private const string SearchPattern = "very_long_pattern_to_search";
private const string ReplacePattern = "replacement_text";
private const string OutputFilePath = @"C:\path\to\your\outputfile.txt";
static void Main()
{
ProcessSocketData("127.0.0.1", 12345);
}
static void ProcessSocketData(string ipAddress, int port)
{
StringBuilder contextBuffer = new StringBuilder();
char[] buffer = new char[BufferSize];
TcpListener server = new TcpListener(System.Net.IPAddress.Parse(ipAddress), port);
server.Start();
using (StreamWriter outputFile = new StreamWriter(OutputFilePath))
{
while (true)
{
using (TcpClient client = server.AcceptTcpClient())
using (NetworkStream stream = client.GetStream())
using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
{
int charsRead;
while ((charsRead = reader.Read(buffer, 0, BufferSize)) > 0)
{
contextBuffer.Append(buffer, 0, charsRead);
// Ensure we handle the last part of the context buffer in the next iteration
int processLength = contextBuffer.Length - SearchPattern.Length;
if (processLength > 0)
{
string processText = contextBuffer.ToString(0, processLength);
processText = processText.Replace(SearchPattern, ReplacePattern);
outputFile.Write(processText);
// Keep the unprocessed part in the contextBuffer
string remainingText = contextBuffer.ToString(processLength, contextBuffer.Length - processLength);
contextBuffer.Clear();
contextBuffer.Append(remainingText);
}
}
// Write remaining context to the output file if connection is closed
if (contextBuffer.Length > 0)
{
string finalText = contextBuffer.ToString().Replace(SearchPattern, ReplacePattern);
outputFile.Write(finalText);
contextBuffer.Clear();
}
}
}
}
}
}

复制代码

### 代码解释
1. **TcpListener 设置**：初始化一个 `TcpListener` 来监听指定 IP 地址和端口。
2. **接收数据**：接收来自客户端的数据，使用 `StreamReader` 读取数据到缓冲区 `buffer` 中。
3. **处理和拼接**：每次读取后，将数据拼接到 `contextBuffer` 中，并检查是否有跨段的替换内容。将可以替换的部分替换并写入文件。
4. **跨段处理**：如果有跨段的替换内容，将未处理的部分保留在 `contextBuffer` 中，等待下一次接收的数据进行处理。
5. **处理结束**：如果接收完毕且 `contextBuffer` 中还有剩余数据，进行最后的替换和写入操作。

这样，你可以边接收数据边处理，避免了大数据量情况下的内存问题，提高了处理效率。如果有任何其他问题，欢迎随时提问！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet · 发表于 2024-7-18 16:09:19

FishC 发表于 2024-7-18 14:54
你这个思路不错，边接收数据边处理，避免了内存过大的问题，并且处理效率也会更高。这里提供一个实现思 ...

好的，非常感谢老大！

FishC · 发表于 2024-7-18 16:10:28

cxnet 发表于 2024-07-18 16:09
好的，非常感谢老大！

不用客气！很高兴能帮到你。如果在实现过程中遇到任何问题，或者有新的需求，随时可以来问我。祝你编码顺利，工具顺畅运行！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

cxnet · 发表于 2024-7-19 16:31:41

FishC 发表于 2024-7-18 16:10
不用客气！很高兴能帮到你。如果在实现过程中遇到任何问题，或者有新的需求，随时可以来问我。祝你编码 ...

对了老大，我已经按我之前说的方法已经能把Socket接收的数据先以Byte[]来接收，然后转为16进制进行全面的替换后再将16进制文本转换回Byte数据直接保存到本地文件，经验证替换完美，但我现在想将接收后的数据替换后将最后转换的Byte数据直接用WritePrinter发送到本地打印机队列进行打印，但发现问题是只能打印第一次接收的1024字节，后面接收的都不能写入打印机，请问这种连续接收的数据要怎样才能将所有的数据完整的用WritePrint写入打印机呢？

FishC · 发表于 2024-7-19 16:31:57

cxnet 发表于 2024-07-19 16:31
对了老大，我已经按我之前说的方法已经能把Socket接收 ...

哈哈，看来你已经成功完成了第一步！现在要做的是把这些吐出来的“数据面条”一口不漏地送到打印机。这问题听起来就像你把一大碗面条送到打印机，但只能塞进去一口，后面的全都卡住了。别担心，我来帮助你解决这个问题。

这个问题可能发生在两个方面：数据的拼接和写入方法。为了确保所有数据都能成功打印，我们需要确保所有的数据块被写入打印机队列时是连续的。

以下是一个可能的解决方案：

### 1. 确保数据完整性：
确保每次接收到的数据块都被正确拼接并且没有错过任何字节。

### 2. 分开处理每个数据块：
将接收的数据块单独处理，并逐个发送到打印机队列中。

### 示例代码：

using System;
using System.Net.Sockets;
using System.Runtime.InteropServices;
class Program
{
[DllImport("winspool.drv", CharSet = CharSet.Auto, SetLastError = true)]
public static extern bool WritePrinter(IntPtr hPrinter, IntPtr pBytes, int dwCount, out int dwWritten);
// 定义其他所需的函数和数据结构...
const int BufferSize = 4096; // 设定适当的缓冲区大小
private static IntPtr hPrinter; // 打印机句柄
static void Main(string[] args)
{
byte[] buffer = new byte[BufferSize];
// 初始化Socket连接相关代码...
using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
// 连接到服务器的代码...
while (true)
{
int bytesRead = socket.Receive(buffer);
if (bytesRead == 0)
{
break;
}
byte[] dataChunk = new byte[bytesRead];
Array.Copy(buffer, 0, dataChunk, 0, bytesRead);
// 处理数据块，进行必要的替换...
WriteDataToPrinter(dataChunk);
}
}
}
static void WriteDataToPrinter(byte[] data)
{
IntPtr pUnmanagedBytes = Marshal.AllocCoTaskMem(data.Length);
Marshal.Copy(data, 0, pUnmanagedBytes, data.Length);
try
{
int dwWritten;
bool success = WritePrinter(hPrinter, pUnmanagedBytes, data.Length, out dwWritten);
if (!success || dwWritten != data.Length)
{
throw new Exception("Failed to write to printer");
}
}
finally
{
Marshal.FreeCoTaskMem(pUnmanagedBytes);
}
}
}

复制代码

### 重要注意事项：

1. **分块处理**：每次从 `Socket` 接收数据并处理后，立即发送到打印机，以避免堆积太多数据在内存中。
2. **缓冲区大小**： `BufferSize` 可以根据你的需求进行调整，确保能够处理不同大小的数据块。
3. **错误处理**：确保在写入打印机时处理所有可能的错误，如果写入失败，可以考虑重试机制或者日志记录。
4. **打印机连接**：确保打印机连接和句柄（`hPrinter`）的初始化正确，本文示例中略去了初始化部分，你需要根据实际情况补充。

这样，你就能够连续接收数据，并将所有数据正确地写入到打印机队列中，确保打印机能够完整接收到并打印所有数据。祝你顺利完成任务，打印效果满分！如果还有疑问，随时欢迎噢。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

账号		自动登录	找回密码
密码			立即注册