"The process cannot access the file because it is being used by another process." How do file locks work on Windows and Linux, how does FileShare affect them, and how do you debug and fix this error?

1. Mandatory vs advisory

Windows (mandatory)                    Linux (advisory)
┌─────────────┐  open(W)    kernel     ┌─────────────┐  flock(EX)
│ Process A   │──share=None──►│     │ Process A   │─────────────► lock table
└─────────────┘               │     └─────────────┘
┌─────────────┐  open(R)      │     ┌─────────────┐  open(R) ── no flock call ──► OK!
│ Process B   │───────────────►✘     │ cat / vim   │
└─────────────┘  sharing        └─────────────┘
                 violation

On Linux, any program that does not call flock simply ignores the lock. .NET applies the emulation to its own FileStreams, and it can be turned off with the DOTNET_SYSTEM_IO_DISABLEFILELOCKING environment variable (useful on some network file systems where flock misbehaves).

2. Deleting and renaming open files

• Linux: you can delete or rename a file someone has open. The open handle keeps working on the old inode.
• Windows: delete/rename fails unless every opener passed FileShare.Delete. This is why log rotation and deployments on Windows hit "file in use" errors.

3. Common holders on Windows

• Your own process: a forgotten FileStream, Image.FromFile (keeps the file open until disposed), XmlReader without using.
• Antivirus and Windows Search indexer: brief locks right after a file is written.
• Explorer preview pane, Excel (opens CSVs exclusively), backup agents.
• IIS / the app itself locking its DLLs during deployment (use app_offline.htm or shadow copying).

4. Finding the holder

5. Coordinating writers properly

Locks on files are a weak coordination tool, especially on network shares (SMB/NFS lock semantics vary). Better options:

• One writer process; others send it messages.
• A named Mutex or Semaphore on one machine.
• Distributed: a database row lock, a blob lease, or a lock service.
• Write to unique temp names and atomically rename, so readers never see partial files.

6. Try it yourself

1. Open a file in one console app with FileShare.None and keep it open. In a second app, try File.ReadAllText. Run on Windows and Linux; then on Linux try cat on the same file.
2. On Windows, open the file in Excel and try to write it from .NET; use handle.exe to see who holds it.

// Read a file that another process is actively writing (log tailing)
await using var fs = new FileStream(
    path,
    FileMode.Open,
    FileAccess.Read,
    FileShare.ReadWrite | FileShare.Delete); // allow writer and rotation
using var reader = new StreamReader(fs);
while (await reader.ReadLineAsync(ct) is { } line)
    Process(line);

// Retry transient sharing violations (antivirus, indexer) with backoff
const int SharingViolation = unchecked((int)0x80070020);
const int LockViolation = unchecked((int)0x80070021);

static async Task<T> WithFileRetryAsync<T>(Func<Task<T>> action, CancellationToken ct)
{
    for (int attempt = 1; ; attempt++)
    {
        try { return await action(); }
        catch (IOException ex) when (attempt < 4 &&
            (ex.HResult == SharingViolation || ex.HResult == LockViolation))
        {
            await Task.Delay(TimeSpan.FromMilliseconds(100 * Math.Pow(2, attempt - 1)), ct);
        }
    }
}

// Release image files immediately: copy into memory instead of Image.FromFile holding the file
byte[] bytes = await File.ReadAllBytesAsync(path, ct);
using var ms = new MemoryStream(bytes);
using var image = SixLabors.ImageSharp.Image.Load(ms);