CODEWITHSUNDEEP
c#filesize
Minimus Heximus
Minimus Heximus

Reputation: 2815

Change the size of a file without opening the file

With std::filesystem::resize_file in C++, it is possible to change the size of a file without opening the file.

Is there any similar function in C#, which allows changing the size of a file without opening it?

I think opening a file as a FileStream and saving it again with a new size will be slower.

Upvotes: 1

Views: 588

Answers (1)

Matthew Watson
Matthew Watson

Reputation: 109762

Using FileStream.SetLength() will be about as fast as you can make it.

It ends up calling the Windows API to set the length of the file, the same as the std::filesystem::resize_file().

So you just need to do something like this, and it will be fast enough:

using (var file = File.Open(myFilePath, FileMode.Open))
{
    file.SetLength(myRequiredFileSize);
}

The implementation of FileStream.SetLength() is:

    private void SetLengthCore(long value)
    {
        Contract.Assert(value >= 0, "value >= 0");
        long origPos = _pos;

        if (_exposedHandle)
            VerifyOSHandlePosition();
        if (_pos != value)
            SeekCore(value, SeekOrigin.Begin);
        if (!Win32Native.SetEndOfFile(_handle)) {
            int hr = Marshal.GetLastWin32Error();
            if (hr==__Error.ERROR_INVALID_PARAMETER)
                throw new ArgumentOutOfRangeException("value", Environment.GetResourceString("ArgumentOutOfRange_FileLengthTooBig"));
            __Error.WinIOError(hr, String.Empty);
        }
        // Return file pointer to where it was before setting length
        if (origPos != value) {
            if (origPos < value)
                SeekCore(origPos, SeekOrigin.Begin);
            else
                SeekCore(0, SeekOrigin.End);
        }
    }

(Note that SeekCore() just calls the the Windows API SetFilePointer() function.)

Doing this does NOT read the file into memory.

Also, the Windows API function SetEndOfFile() does not write to the extended region, so it is fast. The documentation states If the file is extended, the contents of the file between the old end of the file and the new end of the file are not defined. - this is as a result of data not being written to the extended region.

As test, I tried the following code:

using System;
using System.Diagnostics;
using System.IO;

namespace Demo
{
    public class Program
    {
        public static void Main()
        {
            string filename = @"e:\tmp\test.bin";
            File.WriteAllBytes(filename, new byte[0]); // Create empty file.

            var sw = Stopwatch.StartNew();

            using (var file = File.Open(filename, FileMode.Open))
            {
                file.SetLength(1024*1024*1024);
            }

            Console.WriteLine(sw.Elapsed);
        }
    }
}

My E:\ drive is a hard drive, not an SSD.

The output was: 00:00:00.0003574

So it took less than a hundreth of a second to extend the file to 1GB in size.

Upvotes: 4

Related Questions