尝试通过StreamReader将800MB文本文件加载到DataTable时，我遇到了OutOfMemory Exceptions。我想知道是否有办法从内存流中批量加载DataTable，即从StreamReader读取文本文件的前10,000行，创建DataTable，使用DataTable执行某些操作，然后将下10,000行加载到StreamReader中等等。
我的谷歌在这里不是很有帮助，但似乎应该有一个简单的方法来做到这一点。最后，我将使用SqlBulkCopy将DataTables写入MS SQL数据库，因此如果有一种比我描述的更简单的方法，我会感谢快速指向正确的方向。
编辑 - 这是我正在运行的代码：
public static DataTable PopulateDataTableFromText(DataTable dt, string txtSource)
{
StreamReader sr = new StreamReader(txtSource);
DataRow dr;
int dtCount = dt.Columns.Count;
string input;
int i = 0;
while ((input = sr.ReadLine()) != null)
{
try
{
string[] stringRows = input.Split(new char[] { '\t' });
dr = dt.NewRow();
for (int a = 0; a < dtCount; a++)
{
string dataType = dt.Columns[a].DataType.ToString();
if (stringRows[a] == "" && (dataType == "System.Int32" || dataType == "System.Int64"))
{
stringRows[a] = "0";
}
dr[a] = Convert.ChangeType(stringRows[a], dt.Columns[a].DataType);
}
dt.Rows.Add(dr);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
i++;
}
return dt;
}
以下是返回的错误：
“System.OutOfMemoryException：抛出类型'System.OutOfMemoryException'的异常。
在System.String.Split（Char []分隔符，Int32计数，StringSplitOptions选项）
在System.String.Split（Char [] separator}
在C：....的Harvester.Config.PopulateDataTableFromText（DataTable dt，String txtSource）中“
关于将数据直接加载到SQL中的建议 - 当谈到C＃时，我有点像菜鸟，但我认为这基本上就是我在做什么？ SqlBulkCopy.WriteToServer获取我从文本文件创建的DataTable并将其导入sql。有没有更简单的方法来做到这一点，我错过了？
编辑：哦，我忘了提 - 这段代码不会与SQL Server在同一台服务器上运行。数据文本文件位于服务器B上，需要写入服务器A中的表。是否排除使用bcp？
答案 0 :(得分：5)
您是否考虑过将数据直接加载到SQL Server中，然后在数据库中对其进行操作？数据库引擎已经设计为以高效的方式处理大量数据。这可能会产生更好的整体结果，并允许您利用数据库和SQL语言的功能来完成繁重的工作。这是旧的“聪明的工作而不是更难”原则。
有许多different methods to load data into SQL Server，因此您可能需要检查这些内容以确定是否适合。如果您使用的是SQLServer 2005或更高版本，并且您确实需要对C＃中的数据进行一些操作，则可以始终使用managed stored procedure。
这里需要注意的是OutOfMemoryException有点误导。 Memory is more than just the amount of physical RAM you have。您可能用完的是 可寻址内存 。这是一个非常不同的事情。
当您将大文件加载到内存并将其转换为DataTable时，可能需要远远超过800Mb来表示相同的数据。由于32位.NET进程受限对于低于2Gb的可寻址内存，您可能永远无法在一个批处理中处理这一数量的数据。
您可能需要做的是以流方式处理数据。换句话说，不要尝试将其全部加载到DataTable然后批量插入到SQLServer。而是以块的形式处理文件，一旦完成它们就清除先前的行集。
现在，如果您可以访问具有大量内存的64位计算机（以避免虚拟机抖动）和 64位.NET运行时的副本，你可能会在运行代码不变的情况下逃脱。但我建议做出必要的改变，因为它甚至可以在那种环境下提高性能。
答案 1 :(得分：3)
您是否真的需要按批次处理数据？或者你可以逐行处理它吗？在后一种情况下，我认为Linq在这里可能非常有用，因为它可以很容易地在方法的“管道”中传输数据。这样，您不需要一次加载大量数据，一次只加载一行
首先，您需要使StreamReader可枚举。这可以通过扩展方法轻松完成：
public static class TextReaderExtensions
{
public static IEnumerable<string> Lines(this TextReader reader)
{
string line;
while((line = reader.ReadLine()) != null)
{
yield return line;
}
}
}
这样您就可以使用StreamReader作为Linq查询的来源。
然后你需要一个带字符串并将其转换为DataRow的方法：
DataRow ParseDataRow(string input)
{
// Your parsing logic here
...
}
使用这些元素，您可以轻松地将每行从文件投影到DataRow，并随意使用它：
using (var reader = new StreamReader(fileName))
{
var rows = reader.Lines().Select(ParseDataRow);
foreach(DataRow row in rows)
{
// Do something with the DataRow
}
}
（请注意，您可以使用简单的循环执行类似操作，而不使用Linq，但我认为Linq使代码更具可读性......）
答案 2 :(得分：2)
SqlBulkCopy.WriteToServer有一个接受IDataReader的重载。您可以将自己的IDataReader实现为StreamReader的包装器，其中Read（）方法将使用StreamReader中的一行。这样，数据将“流式传输”到数据库中，而不是首先尝试将其作为DataTable在内存中构建。 希望有所帮助。
答案 3 :(得分：0)
作为对其他答案的更新，我也在研究这个问题，并遇到this page which provides a great C# example on reading a text file by chunks, processing in parallel, and then bulk inserting into a database。
代码的关键在于这个循环：
//Of note: it's faster to read all the lines we are going to act on and
//then process them in parallel instead of reading and processing line by line.
//Code source: http://cc.davelozinski.com/code/c-sharp-code/read-lines-in-batches-process-in-parallel
while (blnFileHasMoreLines)
{
batchStartTime = DateTime.Now; //Reset the timer
//Read in all the lines up to the BatchCopy size or
//until there's no more lines in the file
while (intLineReadCounter < BatchSize && !tfp.EndOfData)
{
CurrentLines[intLineReadCounter] = tfp.ReadFields();
intLineReadCounter += 1;
BatchCount += 1;
RecordCount += 1;
}
batchEndTime = DateTime.Now; //record the end time of the current batch
batchTimeSpan = batchEndTime - batchStartTime; //get the timespan for stats
//Now process each line in parallel.
Parallel.For(0, intLineReadCounter, x =>
//for (int x=0; x < intLineReadCounter; x++) //Or the slower single threaded version for debugging
{
List<object> values = null; //so each thread gets its own copy.
if (tfp.TextFieldType == FieldType.Delimited)
{
if (CurrentLines[x].Length != CurrentRecords.Columns.Count)
{
//Do what you need to if the number of columns in the current line
//don't match the number of expected columns
return; //stop now and don't add this record to the current collection of valid records.
}
//Number of columns match so copy over the values into the datatable
//for later upload into a database
values = new List<object>(CurrentRecords.Columns.Count);
for (int i = 0; i < CurrentLines[x].Length; i++)
values.Add(CurrentLines[x][i].ToString());
//OR do your own custom processing here if not using a database.
}
else if (tfp.TextFieldType == FieldType.FixedWidth)
{
//Implement your own processing if the file columns are fixed width.
}
//Now lock the data table before saving the results so there's no thread bashing on the datatable
lock (oSyncLock)
{
CurrentRecords.LoadDataRow(values.ToArray(), true);
}
values.Clear();
}
); //Parallel.For
//If you're not using a database, you obviously won't need this next piece of code.
if (BatchCount >= BatchSize)
{ //Do the SQL bulk copy and save the info into the database
sbc.BatchSize = CurrentRecords.Rows.Count;
sbc.WriteToServer(CurrentRecords);
BatchCount = 0; //Reset these values
CurrentRecords.Clear(); // "
}
if (CurrentLines[intLineReadCounter] == null)
blnFileHasMoreLines = false; //we're all done, so signal while loop to stop
intLineReadCounter = 0; //reset for next pass
Array.Clear(CurrentLines, 0, CurrentLines.Length);
} //while blnhasmorelines