У меня есть фрагмент кода, который должен иметь возможность модифицировать несколько байтов в конце файла. Проблема в том, что файлы огромны. До 100+ Гб.
Мне нужно, чтобы операция была как можно быстрее, но после нескольких часов Googeling, она выглядит как .Net здесь довольно ограничена.
В основном я пытаюсь использовать System.IO.FileStream и не знаю других методов. "Реверсивный" поток будет делать, но я знаю, как его создать (пишите с конца, а не из начала).
Вот что я делаю: (Примечание: время уходит при закрытии потока)
static void Main(string[] args)
{
//Simulate a large file
int size = 1000 * 1024 * 1024;
string filename = "blah.dat";
FileStream fs = new FileStream(filename, FileMode.Create);
fs.SetLength(size);
fs.Close();
//Modify the last byte
fs = new FileStream(filename, FileMode.Open);
//If I don't seek, the modification happens instantly
fs.Seek(-1, SeekOrigin.End);
fs.WriteByte(255);
//Now, since I am modifying the last byte,
//this last step is very slow
fs.Close();
}
}
Как уже отмечал Дарин, это артефакт вашего "симулятора" большого файла.
Задержка - это фактически "заполнение" файла, задержка происходит только в первый раз. Если вы повторите часть с //Modify the last byte до fs.Close();, она будет очень быстрой.
Я выполнил несколько тестов, и результаты немного запутывают. Если вы создадите файл и измените его в одной программе, он будет медленным:
static void Main(string[] args)
{
//Simulate a large file
int size = 100 * 1024 * 1024;
string filename = "blah.datn";
using (var fs = new FileStream(filename, FileMode.Create))
{
fs.SetLength(size);
}
using (var fs = new FileStream(filename, FileMode.Open))
{
fs.Seek(-1, SeekOrigin.End);
fs.WriteByte(255);
}
}
Но если файл существует, и вы только пытаетесь изменить последний байт, это быстро:
static void Main(string[] args)
{
string filename = "blah.datn";
using (var fs = new FileStream(filename, FileMode.Open))
{
fs.Seek(-1, SeekOrigin.End);
fs.WriteByte(255);
}
}
Хммм... Забастовкa >
UPDATE:
Пожалуйста, проигнорируйте мои предыдущие наблюдения и отмените это как ответ, потому что это все неправильно.
Дальнейшее исследование проблемы я заметил следующий шаблон. Предположим, что вы выделяете файл с заданным размером с нулевыми байтами:
using (var stream = File.OpenWrite("blah.dat"))
{
stream.SetLength(100 * 1024 * 1024);
}
Эта операция выполняется очень быстро и создает файл размером 100 МБ, заполненный нулями.
Теперь, если в какой-либо другой программе вы попытаетесь изменить последний байт, закрытие потока будет медленным:
using (var stream = File.OpenWrite("blah.dat"))
{
stream.Seek(-1, SeekOrigin.End);
stream.WriteByte(255);
}
Я понятия не имею о внутренних функциях файловой системы или о том, как именно создан этот файл, но у меня есть ощущение, что он не полностью инициализирован, пока вы не попытаетесь его модифицировать, и закрытие дескриптора будет медленным.
Чтобы подтвердить это, я тестировал неуправляемый код (не стесняйтесь исправить любую аберрацию, так как мой C очень ржавый):
void main()
{
int size = 100 * 1024 * 1024 - 1;
FILE *handle = fopen("blah.dat", "wb");
if (handle != NULL) {
fseek(handle, size, SEEK_SET);
char buffer[] = {0};
fwrite(buffer, 1, 1, handle);
fclose(handle);
}
}
Это ведет себя так же, как в .NET = > он выделяет файл размером 100 МБ, заполненный нулями, и это очень быстро.
Теперь, когда я пытаюсь изменить последний байт этого файла:
void main()
{
int size = 100 * 1024 * 1024 - 1;
FILE *handle = fopen("blah.datn", "rb+");
if (handle != NULL) {
fseek(handle, -1, SEEK_END);
char buffer[] = {255};
fwrite(buffer, 1, 1, handle);
fclose(handle);
}
}
Последний fclose(handle) медленный. Я надеюсь, что некоторые эксперты принесут немного света.
Кажется, что изменение последнего байта реального файла (не разреженного) с использованием предыдущих методов выполняется очень быстро.
Возможно, самый быстрый способ работы с большими файлами с помощью MemoryMappedFile. Файл с отображением памяти - это файл, который отображается (не загружен) в виртуальную память, поэтому вы можете получить доступ к случайным байтам в нем, не обращаясь к определенному местоположению, буферам загрузки и т.д. Вы также можете читать целые структуры непосредственно из файла без через десериализацию.
Следующий код, выходящий прямо из MSDN, загружает и сохраняет структуру MyColor в середине файла размером 512 МБ:
static void Main(string[] args)
{
long offset = 0x10000000; // 256 megabytes
long length = 0x20000000; // 512 megabytes
// Create a memory-mapped view of a portion of
// an extremely large image, from the 256th megabyte (the offset)
// to the 768th megabyte (the offset plus length).
using (var mmf =
MemoryMappedFile.CreateFromFile(@"c:\ExtremelyLargeImage.data",
FileMode.Open,"ImgA"))
{
using (var accessor = mmf.CreateViewAccessor(offset, length))
{
int colorSize = Marshal.SizeOf(typeof(MyColor));
MyColor color;
// Make changes to the view.
for (long i = 0; i < length; i += colorSize)
{
accessor.Read(i, out color);
color.Brighten(10);
accessor.Write(i, ref color);
}
}
}
}
public struct MyColor
{
public short Red;
public short Green;
public short Blue;
public short Alpha;
// Make the view brigher.
public void Brighten(short value)
{
Red = (short)Math.Min(short.MaxValue, (int)Red + value);
Green = (short)Math.Min(short.MaxValue, (int)Green + value);
Blue = (short)Math.Min(short.MaxValue, (int)Blue + value);
Alpha = (short)Math.Min(short.MaxValue, (int)Alpha + value);
}
}
Вы можете найти дополнительную информацию и образцы в Файлы с памятью
Я предлагаю вам попробовать его с реальным файлом, а не с "смоделированным" файлом. Возможно, что .net использует какой-то разреженный механизм распределения и только записывает файл до последнего байта, на самом деле написанного.
Итак, когда вы пишете в начале файла, ему нужно только записать несколько байтов, но когда вы пишете в конец файла, ему действительно нужно записать весь файл.