C# FileOptions Enum
last modified April 20, 2025
This tutorial explains how to use the FileOptions enum in C# to control file handling behavior. FileOptions provides advanced options for file operations.
The FileOptions enum specifies advanced options for creating FileStream objects. These options control caching, writing behavior, and other file system operations.
FileOptions is used when creating FileStream instances to
optimize performance or ensure specific behavior. It's part of the
System.IO namespace in .NET.
Basic FileOptions Example
This example demonstrates using FileOptions.None as the default option when creating a FileStream. It shows basic file operations.
using System;
using System.IO;
using System.Text;
class Program
{
static void Main()
{
string filePath = "testfile.txt";
// Create file with default options
using (var fs = new FileStream(filePath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
FileOptions.None))
{
byte[] data = Encoding.UTF8.GetBytes("Hello, FileOptions!");
fs.Write(data, 0, data.Length);
}
Console.WriteLine("File created with FileOptions.None");
}
}
This code creates a file with default options. FileOptions.None specifies no special options should be used. The FileStream is created with typical parameters including file path, mode, access, and share settings.
The buffer size is set to 4096 bytes. The file is written using UTF-8 encoding. This represents the most basic way to create and write to a file in C# without any special options.
Using FileOptions.WriteThrough
FileOptions.WriteThrough ensures data is written directly to disk without intermediate caching. This example shows how to use it.
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = "writethrough.txt";
// Create file with WriteThrough option
using (var fs = new FileStream(filePath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
FileOptions.WriteThrough))
{
byte[] data = { 1, 2, 3, 4, 5 };
fs.Write(data, 0, data.Length);
Console.WriteLine("Data written with WriteThrough option");
}
}
}
WriteThrough bypasses system cache and writes directly to disk. This is useful when data integrity is critical. The option ensures data is physically written to storage immediately.
This comes with a performance cost as it prevents write caching. Use it for critical data that must persist even after system crashes. The example writes a simple byte array to demonstrate the option.
Using FileOptions.Asynchronous
FileOptions.Asynchronous enables asynchronous file operations. This example demonstrates async file writing.
using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
class Program
{
static async Task Main()
{
string filePath = "asyncfile.txt";
// Create file with Asynchronous option
using (var fs = new FileStream(filePath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
FileOptions.Asynchronous))
{
byte[] data = Encoding.UTF8.GetBytes("Asynchronous file operation");
await fs.WriteAsync(data, 0, data.Length);
Console.WriteLine("File written asynchronously");
}
}
}
Asynchronous operations improve scalability by not blocking threads. FileOptions.Asynchronous enables this behavior for the FileStream. The example uses async/await pattern for non-blocking file operations.
Note that simply adding the option doesn't make operations async - you must use async methods. The option optimizes the stream for async operations. This is particularly useful in server applications.
Using FileOptions.SequentialScan
FileOptions.SequentialScan optimizes for sequential file access. This example shows reading a file sequentially.
using System;
using System.IO;
using System.Text;
class Program
{
static void Main()
{
string filePath = "sequential.txt";
// First create a file to read
File.WriteAllText(filePath, "This is some sample text for sequential reading");
// Open with SequentialScan option
using (var fs = new FileStream(filePath,
FileMode.Open,
FileAccess.Read,
FileShare.Read,
4096,
FileOptions.SequentialScan))
{
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = fs.Read(buffer, 0, buffer.Length)) > 0)
{
string text = Encoding.UTF8.GetString(buffer, 0, bytesRead);
Console.Write(text);
}
}
}
}
SequentialScan hints to the system that the file will be read from start to finish. This allows for better caching and prefetching. The option is particularly useful when processing large files linearly.
The example reads the file in chunks using a buffer. The system may optimize read-ahead operations. This can significantly improve performance for large sequential reads like log processing.
Combining Multiple FileOptions
FileOptions values can be combined using bitwise OR. This example shows using multiple options together.
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = "combined.txt";
// Combine Asynchronous and WriteThrough options
var options = FileOptions.Asynchronous | FileOptions.WriteThrough;
using (var fs = new FileStream(filePath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
options))
{
byte[] data = { 10, 20, 30, 40, 50 };
fs.Write(data, 0, data.Length);
Console.WriteLine("File written with combined options");
}
}
}
Multiple options can be combined using the bitwise OR operator. This example combines Asynchronous and WriteThrough options. The resulting FileStream will have both behaviors enabled.
Not all combinations make sense or are allowed. Some options may conflict with each other. Always test combinations to ensure they provide the expected behavior.
Using FileOptions.DeleteOnClose
FileOptions.DeleteOnClose automatically deletes the file when it's closed. This example demonstrates temporary file handling.
using System;
using System.IO;
using System.Text;
class Program
{
static void Main()
{
string tempFilePath = Path.GetTempFileName();
// Create temporary file with DeleteOnClose
using (var fs = new FileStream(tempFilePath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
FileOptions.DeleteOnClose))
{
byte[] data = Encoding.UTF8.GetBytes("Temporary data");
fs.Write(data, 0, data.Length);
Console.WriteLine($"Temporary file created at {tempFilePath}");
}
// File is automatically deleted after the using block
Console.WriteLine($"File exists after close: {File.Exists(tempFilePath)}");
}
}
DeleteOnClose is useful for temporary files that should be automatically cleaned up. The file is deleted when the stream is closed or disposed. The example uses the system temp directory for the file location.
Note that the file exists while in use but is deleted immediately after closing. This behavior is different from FileStream's own temporary file methods. It provides more control over temporary file handling.
Using FileOptions.Encrypted
FileOptions.Encrypted requests file encryption at the filesystem level. This example shows creating an encrypted file.
using System;
using System.IO;
class Program
{
static void Main()
{
string filePath = "encrypted.dat";
try
{
// Create encrypted file
using (var fs = new FileStream(filePath,
FileMode.Create,
FileAccess.Write,
FileShare.None,
4096,
FileOptions.Encrypted))
{
byte[] data = { 1, 2, 3, 4, 5 };
fs.Write(data, 0, data.Length);
Console.WriteLine("Encrypted file created");
}
}
catch (PlatformNotSupportedException ex)
{
Console.WriteLine($"Encryption not supported: {ex.Message}");
}
}
}
FileOptions.Encrypted requests filesystem-level encryption. This depends on the underlying OS and filesystem support. The example includes error handling for unsupported platforms.
On Windows with NTFS, this enables EFS (Encrypting File System). The actual encryption is handled by the OS, not .NET. Note that this is different from application-level encryption.
Source
FileOptions Enum Documentation
This tutorial covered using the FileOptions enum in C# to control file handling behavior, including various options and their combinations.
Author
List all C# tutorials.