Do we need DisposeInternal at all? Could FileStream's Dispose(bool) instead do:

if (disposing) _strategy.Dispose();

?

@stephentoub to answer your question I've written some additional tests (to cover all scenarios). And I've discovered a new bug: for types that derive from FileStream and have buffering enabled, the buffer is currently not getting flushed when the instance is finalized. Repro:

public class DerivedFileStream : FileStream
{
    public DerivedFileStream(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options)
        : base(path, mode, access, share, bufferSize, options)
    {
    }
}

[Fact]
public static void Repro()
{
    string filePath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
    Separate(filePath);
    
    GC.Collect();
    GC.WaitForPendingFinalizers();
    
    Assert.Equal(new byte [] { 1} , File.ReadAllBytes(filePath));

    // use a separate method to be sure that fs isn't rooted at time of GC.
    static void Separate(string filePath)
    {
        FileStream fs = new DerivedFileStream(filePath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.None);
        fs.WriteByte(1);
    }
}

It's caused by the fact that ~DerivedFileStreamStrategy is currently passing false to Dispose:

which is perfectly fine, because derived type is expecting that.

However, when it's passed back to BufferedFileStreamStrategy.Dispose the Flush is not performed for !disposing:

~BufferedFileStreamStrategy workarounds it by always passing true to Dispose:

My current take on it is that removing finalizer from FileStream was a bad idea as it actually got things more complicated and regressed the performance instead of improving it. I think that we should restore it, let it run for a few weeks on main and backport it to 6.0. PTAL at my recent changes and let me know what do you think.