不，没有适用于 .Net 的 BigMemory 系统（即进程内非 GC 堆内存管理器），但是您可以自行开发。
您可以利用非托管堆来收集非垃圾的进程内堆，但是，如果您使用的是对象而不是原始内存，则必须对它们进行序列化和反序列化，这很慢。
您需要查找堆信息以便检索对象，这显然有其自身的内存开销，因此不适合大量非常小的对象，例如：
一个。管理对象会占用大量内存。
湾。 GC 会疯狂扫描管理对象。
如果对象足够大并且没有太多个对象，这可能适合你。
但是，您也可以将一些管理信息推送到非托管堆中。有很多优化机会。
这一切都可以像键\值缓存一样被包装起来，从而抽象出堆信息和堆。
更新
更新了示例代码以使用 Protobuf，它的二进制序列化速度明显快于 .Net。这个简单的示例每秒可以 Put+Get 425k 个对象，带有键\值包装器。您的米数会因对象大小\复杂性而异。
对象大小存储在非托管堆中，以减少托管堆上的内存消耗。
...
...
using ProtoBuf;
[TestFixture]
public class UnmanagedHeap
{
[Test]
public void UnmanagedHeapAccess()
{
const int Iterations = 425 * 1000;
const string Key = "woo";
Bling obj = new Bling { Id = -666 };
Cache cache = new Cache();
Stopwatch sw = Stopwatch.StartNew();
for (int i = 0; i < Iterations; i++)
{
cache.Put(Key, obj);
obj = cache.Get<Bling>(Key);
}
cache.Remove(Key);
Console.WriteLine(sw.Elapsed.TotalMilliseconds);
}
[DataContract]
public class Bling
{
[DataMember(Order = 1)]
public int Id { get; set; }
}
public class Cache
{
private const int SizeFieldWidth = 4;
private readonly Dictionary<string, IntPtr> _lookup = new Dictionary<string, IntPtr>();
public void Put(string key, object obj)
{
IntPtr oldPtr = _lookup.TryGetValue(key, out oldPtr) ? oldPtr : IntPtr.Zero;
IntPtr newPtr = SerializeToHeap(obj, oldPtr);
_lookup[key] = newPtr;
}
public T Get<T>(string key)
{
IntPtr ptr = _lookup[key];
return DeserializeFromHeap<T>(ptr);
}
public void Remove(string key)
{
IntPtr ptr = _lookup[key];
Marshal.FreeHGlobal(ptr);
_lookup.Remove(key);
}
private static IntPtr SerializeToHeap(object obj, IntPtr oldPtr)
{
using (MemoryStream ms = new MemoryStream())
{
Serializer.Serialize(ms, obj);
byte[] objBytes = ms.GetBuffer();
int newSize = (int)ms.Length;
bool requiresAlloc = true;
if (oldPtr != IntPtr.Zero)
{
int oldSize = GetObjectSize(oldPtr);
requiresAlloc = (oldSize != newSize);
}
IntPtr newPtr = requiresAlloc ? Marshal.AllocHGlobal(newSize + SizeFieldWidth) : oldPtr;
byte[] sizeField = BitConverter.GetBytes(newSize);
Marshal.Copy(sizeField, 0, newPtr, SizeFieldWidth);
Marshal.Copy(objBytes, 0, newPtr + SizeFieldWidth, newSize);
return newPtr;
}
}
private static T DeserializeFromHeap<T>(IntPtr ptr)
{
int size = GetObjectSize(ptr);
byte[] objBytes = new byte[size];
Marshal.Copy(ptr + SizeFieldWidth, objBytes, 0, size);
using (MemoryStream ms = new MemoryStream(objBytes))
{
return Serializer.Deserialize<T>(ms);
}
}
private static int GetObjectSize(IntPtr ptr)
{
byte[] sizeField = new byte[SizeFieldWidth];
Marshal.Copy(ptr, sizeField, 0, SizeFieldWidth);
int size = BitConverter.ToInt32(sizeField, 0);
return size;
}
}
}