MemoryMappedFile的初级应用

    public class SyncMemoryList<T>: SyncList<T>, IDisposable
    {
        private MemoryCache<T> _memoryCache = new MemoryCache<T>();

        public new void Add(T item)
        {
            string json = $"{ToJson(item)}\n";
            WriteCache(json);

            base.Add(item);
        }

        private string ToJson(T item)
        {
            Type type = typeof(T);
            if (type.IsClass)
                return JsonExtensions.ToJson(item);
            else
                return item.ToString();
        }

        private void WriteCache(string text)
        {
            byte[] bytes = Encoding.UTF8.GetBytes(text);
            if (_memoryCache.IsAllowWrite(bytes.Length))
            {
                _memoryCache.Write(bytes);
            }
            else
            {
                _memoryCache.Dispose();
                _memoryCache = new MemoryCache<T>();
                _memoryCache.Write(bytes);
            }
        }

        #region IDisposable Support
        private bool disposedValue = false; // 要检测冗余调用

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    // TODO: 释放托管状态(托管对象)。
                }

                _memoryCache?.Dispose();
                disposedValue = true;
            }
        }

        // TODO: 仅当以上 Dispose(bool disposing) 拥有用于释放未托管资源的代码时才替代终结器。
        // ~SyncMemoryList() {
        //   // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
        //   Dispose(false);
        // }

        // 添加此代码以正确实现可处置模式。
        public void Dispose()
        {
            // 请勿更改此代码。将清理代码放入以上 Dispose(bool disposing) 中。
            Dispose(true);
            // TODO: 如果在以上内容中替代了终结器，则取消注释以下行。
            // GC.SuppressFinalize(this);
        }
        #endregion
    }

    internal class MemoryCache<T>:IDisposable
    {
        private readonly MemoryMappedFile _memoryMapped = null;
        private readonly MemoryMappedViewStream _stream = null;
        private static readonly long _defaultSize = 1024 * 1024;
        private readonly long _capatity = 0;
        public MemoryCache()
        {
            string mapname = $"{typeof(T).Name}";
            string fileName = $"{typeof(T).Name}_{DateTime.Now:yyyy_M_d}.dat";
            long maxlen = 0;
            if (File.Exists(fileName))
            {
                (long size,long offset) = (0, 0);
                FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite);
                (size,offset) = GetFileInfo(stream);
                //stream.Close();
                maxlen = size + _defaultSize;
                _memoryMapped = MemoryMappedFile.CreateFromFile(stream, mapname, maxlen, MemoryMappedFileAccess.ReadWrite, HandleInheritability.None, false);
                _stream = _memoryMapped.CreateViewStream();
                _stream.Position = offset == 0 ? 16 : offset;
            }
            else
            {
                maxlen = _defaultSize + 16;
                _memoryMapped = MemoryMappedFile.CreateFromFile(fileName, FileMode.OpenOrCreate, mapname, maxlen, MemoryMappedFileAccess.ReadWrite);
                _stream = _memoryMapped.CreateViewStream();
                _stream.Position = 16;
            }

            _capatity = maxlen - 16;
        }

        public long Position => _stream.Position;

        private (long, long) GetFileInfo(Stream stream)
        {
            try
            {
                byte[] byteSize = new byte[8];
                byte[] byteOffset = new byte[8];

                stream.Read(byteSize, 0, byteSize.Length);
                stream.Read(byteOffset, 0, byteOffset.Length);

                return (BitConverter.ToInt64(byteSize, 0), BitConverter.ToInt64(byteOffset, 0));
            }
            catch (Exception e)
            {
                return (_defaultSize, 0);
            }
        }

        public bool IsAllowWrite(long size)
        {
            return _capatity - _stream.Position > size;
        }

        public void WriteLength(long offset)
        {
            byte[] byteSize = BitConverter.GetBytes(_capatity);
            byte[] byteOffset = BitConverter.GetBytes(offset);
            _stream.Position = 0;
            _stream.Write(byteSize, 0, byteSize.Length);
            _stream.Write(byteOffset, 0, byteOffset.Length);
        }

        public void Write(byte[] bytes)
        {
            var _offset = _stream.Position;
            WriteLength(_offset + bytes.Length);
            _stream.Position = _offset;
            _stream.Write(bytes, 0, bytes.Length);
        }

        public void Dispose()
        {
            _memoryMapped?.Dispose();
            _stream?.Dispose();
        }
    }