Basic adapter for System.IO.MemoryMappedFiles

MemoryMappedFileEx.cs

using System;
using System.Buffers;
using System.IO;
using System.IO.MemoryMappedFiles;

namespace AirBreather.IO
{
    public static class MemoryMappedFileEx
    {
        public static unsafe OwnedMemory<byte> CreateFromFile(string filePath, FileMode mode, string mapName, long offset, long totalCapacity, MemoryMappedFileAccess access)
        {
            byte* ptr = null;
            MemoryMappedFile fl = null;
            MemoryMappedViewAccessor acc = null;
            try
            {
                fl = MemoryMappedFile.CreateFromFile(filePath, mode, mapName, totalCapacity, access);
                acc = fl.CreateViewAccessor(offset, totalCapacity - offset, access);
                acc.SafeMemoryMappedViewHandle.AcquirePointer(ref ptr);
                ptr += acc.PointerOffset;
                return new OwnedMappedMemory(fl, acc, ref ptr);
            }
            catch
            {
                acc?.Dispose();
                fl?.Dispose();
                throw;
            }
            finally
            {
                if (ptr != null)
                {
                    acc.SafeMemoryMappedViewHandle.ReleasePointer();
                }
            }
        }

        private sealed class OwnedMappedMemory : OwnedMemory<byte>
        {
            private MemoryMappedFile fl;

            private MemoryMappedViewAccessor acc;

            internal unsafe OwnedMappedMemory(MemoryMappedFile fl, MemoryMappedViewAccessor acc, ref byte* acquiredPointer)
                : base(null, 0, checked((int)acc.Capacity), new IntPtr(acquiredPointer))
            {
                this.fl = fl;
                this.acc = acc;

                // signal that we are now responsible for releasing the pointer.
                acquiredPointer = null;
            }

            ~OwnedMappedMemory()
            {
                this.Dispose(false);
            }

            protected override void Dispose(bool disposing)
            {
                this.acc.SafeMemoryMappedViewHandle.ReleasePointer();

                if (disposing)
                {
                    this.acc.Dispose();
                    this.fl.Dispose();
                    GC.SuppressFinalize(this);
                }

                base.Dispose(disposing);
            }
        }
    }
}