Using memory mapped files to conserve physical memory for large arrays

class Program
{
	static void Main(string[] args)
	{
		string path = AppDomain.CurrentDomain.BaseDirectory;
		var myList = new GenericMemoryMappedArray<Interval>(102400, path);
		myList.AutoGrow = true;
		using (myList)
		{
			try
			{
				for (int i = 0; i < 250; i++)
				{
					ThreadPool.QueueUserWorkItem(new WaitCallback(OnWorkerThreadConsumeMMF), myList);
					Thread.Sleep(200);
				}
			}
			catch (Exception e)
			{

				Console.WriteLine(e.Message);
			}
			finally
			{
				Console.WriteLine("Wait ...");
				Console.ReadLine();
			}
		}
	}

	static void OnWorkerThreadConsumeMMF(object state)
	{
		GenericMemoryMappedArray<Interval> myList = (GenericMemoryMappedArray<Interval>)state;
		int length = 102400;
		for (int i = 0; i < length; i++)
		{
			Interval x = new Interval(100);
			for (int k = 0; k < x.Value.Length; k++)
			{
				x.Value[k] = Convert.ToDecimal(k / 3);
			}
			myList[Convert.ToInt64(i)] = x;
		}
		Thread.Sleep(5000); // to make sure system can generate enough worker threads.
		ThreadPool.QueueUserWorkItem(new WaitCallback(OnWorkerThreadConsumeMMF), myList);
	}

	[Serializable]
	[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
	struct Interval
	{
		[MarshalAs(UnmanagedType.ByValArray, SizeConst = 100)]
		public decimal[] Value;
		/// <summary>
		/// Initializes a new instance of the <see cref="Interval"/> struct.
		/// </summary>
		/// <param name="length">The length.</param>
		public Interval(int length)
		{
			Value = new decimal[length];
		}
	}
}

public IntPtr MapView(MapAccess access, long offset, long size)
        {
            if (!IsOpen)
                throw new ObjectDisposedException("Winterdom.IO.FileMap.MemoryMappedFile.MapView - MMF already closed");

            // Throws OverflowException if (a) this is a 32-bit platform AND (b) size is out of bounds (ie. int bounds) with respect to this platform
            IntPtr mapSize = new IntPtr(size);

            IntPtr baseAddress = Win32MapApis.MapViewOfFile(
              hMap, (int)access,
              (int)((offset >> 32) & 0xFFFFFFFF),
              (int)(offset & 0xFFFFFFFF), mapSize
              );

            if (baseAddress == IntPtr.Zero)
                throw new FileMapIOException(Marshal.GetHRForLastWin32Error());

            return baseAddress;

        }

get
{
   ReaderWriterLock.AcquireReaderLock(Timeout.Infinite);
   try
   {...}
   finally
   {
      ReaderWriterLock.ReleaseReaderLock();
   }
}

[MarshalAs(UnmanagedType.ByValTStr, SizeConst=80)] //MAX_COLUMN_NAME_LEN
public string myTitle; //WCHAR

public class Result
{
    const byte Version = 1;
    
    List _matches;
    List _sourceStats;
    List _matchStats;

    public Result()
    { }

    public byte[] Serialize(bool compress)
    {
        MemoryStream stream = new MemoryStream();
        BinaryWriter writer = new BinaryWriter(stream);

        writer.Write(Version);
        writer.Write(SourceMatchStat.Version);
        if (_sourceStats == null) writer.Write(0);
        else
        {
            writer.Write(_sourceStats.Count);
            foreach (SourceMatchStat stat in _sourceStats)
            {
                stat.Save(writer);
            }
        }

        writer.Write(Match.Version);
        writer.Write(_matches.Count);
        foreach (Match match in _matches)
        {
            match.Save(writer);
        }

        writer.Write(MatchStat.Version);
        if (_matchStats == null) writer.Write(0);
        else
        {
            writer.Write(_matchStats.Count);
            foreach (MatchStat stat in _matchStats)
            {
                stat.Save(writer);
            }
        }

        if (compress)
        {
            return Compression.Compress(stream.ToArray());
        }

        return stream.ToArray();
    }

    public static Result Deserialize(byte[] data)
    {
        data = Compression.DeCompress(data);

        Result result = new Result();
        MemoryStream stream = new MemoryStream(data);
        using (stream)
        {
            BinaryReader reader = new BinaryReader(stream);
            using (reader)
            {
                byte version = reader.ReadByte();
                if (version == 1)
                {
                    result.EstimatedMatchCount = reader.ReadInt32();
                    result.LastExternalDocIdInStorage = reader.ReadInt32();
                    result.NextPageRef = reader.ReadInt32();
                }
                // TODO: include check for other versions

                version = reader.ReadByte();
                int count = reader.ReadInt32();
                result.SourceStats = new List(count);
                for (int i = 0; i < count; i++)
                {
                    result.SourceStats.Add(new SourceMatchStat(reader, version));
                }

                version = reader.ReadByte();
                count = reader.ReadInt32();
                result.Matches = new List(count);
                for (int i = 0; i < count; i++)
                {
                    result.Matches.Add(new Match(reader, version));
                }

                version = reader.ReadByte();
                count = reader.ReadInt32();
                result.MatchStats = new List(count);
                for (int i = 0; i < count; i++)
                {
                    result.MatchStats.Add(new MatchStat(reader, version));
                }
            }
        }
        return result;
    }
}

_memPtr = Marshal.AllocHGlobal(_dataSize);

~GenericMemoryMappedArray()
{
    Dispose(false);
}

public void Dispose()
{
    Dispose(true);
    GC.SuppressFinalize(this);
}

protected virtual void Dispose(bool disposing)
{
    if (!_isDisposed && disposing)
    {
        lock (_lockObject)
        {
            // Clean up all views
            foreach (KeyValuePair<int, MapViewStream> pair in _inUse)
            {
                pair.Value.Dispose();
                pair.Value.Close();
            }
            _inUse.Clear();
            _lastUsedThread.Clear();
        }

        if (_map != null) _map.Close();
    }

    try
    {
        if (_deleteFile)
        {
            Marshal.DestroyStructure(_memPtr, typeof(TValue));
            Marshal.FreeHGlobal(_memPtr);
            if (File.Exists(_fileName)) File.Delete(_fileName);
        }
    }
    catch (Exception)
    {
        // TODO: Handle files which for some reason didn't want to be deleted
        throw;
    }
    _deleteFile = true;
}