private void AddMemoryCacheItem(OnlineMapsTile tile, int tileHash, string tileKey)
{
for (int i = 0; i < countMemoryItems; i++)
{
if (memoryCache[i].hash == tileHash && memoryCache[i].key == tileKey)
{
return;
}
}
if (memoryCache == null)
{
memoryCache = new MemoryCacheItem[maxMemoryCacheSize * 10];
}
else if (memoryCache.Length == countMemoryItems)
{
Array.Resize(ref memoryCache, memoryCache.Length + 50);
}
MemoryCacheItem item = new MemoryCacheItem(tileKey, tile);
memoryCache[countMemoryItems++] = item;
_memoryCacheSize += item.size;
if (memoryCacheSize > maxMemoryCacheSize * 1000000)
{
UnloadOldMemoryCacheItems();
}
}
private bool TryLoadFromMemoryCache(OnlineMapsTile tile)
{
if (memoryCache == null)
{
return(false);
}
string key = GetTileKey(tile);
int keyHash = key.GetHashCode();
MemoryCacheItem item = null;
for (int itemIndex = 0; itemIndex < countMemoryItems; itemIndex++)
{
if (memoryCache[itemIndex].hash == keyHash && memoryCache[itemIndex].key == key)
{
item = memoryCache[itemIndex];
item.time = DateTime.Now.Ticks;
break;
}
}
if (item == null)
{
return(false);
}
LoadTile(tile, item.bytes);
if (OnLoadedFromMemoryCache != null)
{
OnLoadedFromMemoryCache(tile);
}
return(true);
}
private bool TryLoadTraffic(OnlineMapsTile tile)
{
if (memoryCache == null)
{
return(false);
}
string key = GetTrafficKey(tile);
int keyHash = key.GetHashCode();
MemoryCacheItem item = null;
for (int itemIndex = 0; itemIndex < countMemoryItems; itemIndex++)
{
if (memoryCache[itemIndex].hash == keyHash && memoryCache[itemIndex].key == key)
{
item = memoryCache[itemIndex];
item.time = DateTime.Now.Ticks;
break;
}
}
if (item == null)
{
return(false);
}
Texture2D trafficTexture = new Texture2D(256, 256, TextureFormat.RGB24, false);
trafficTexture.LoadImage(item.bytes);
trafficTexture.wrapMode = TextureWrapMode.Clamp;
tile.trafficTexture = trafficTexture;
map.Redraw();
return(true);
}
public void Build()
{
cache = new Cache();
cacheItemUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(cacheItemUUID.ToString(),DateTime.Now + TimeSpan.FromDays(1));
byte[] foo = new byte[1];
foo[0] = 255;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
}
public void Build()
{
cache = new Cache();
cache = new Cache(CacheMedium.Memory,CacheStrategy.Aggressive,CacheFlags.AllowUpdate);
cacheItemUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(cacheItemUUID.ToString(),DateTime.Now + TimeSpan.FromDays(1));
byte[] foo = new byte[1];
foo[0] = 255;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
}
public void Build()
{
cache = new Cache();
cacheItemUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(cacheItemUUID.ToString(), DateTime.Now + TimeSpan.FromDays(1));
byte[] foo = new byte[1];
foo[0] = 255;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
}
public void Build()
{
cache = new Cache();
cache = new Cache(CacheMedium.Memory, CacheStrategy.Aggressive, CacheFlags.AllowUpdate);
cacheItemUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(cacheItemUUID.ToString(), DateTime.Now + TimeSpan.FromDays(1));
byte[] foo = new byte[1];
foo[0] = 255;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
}
public void Set(string key, object value, int expire = -1)
{
lock (_sync)
{
var expirationDate = DateTime.MinValue;
if (expire > 0)
{
expirationDate = DateTime.Now.AddSeconds(expire);
}
Items[key] = new MemoryCacheItem(value, expirationDate);
}
}
public void ExpireItemManually()
{
UUID ImmediateExpiryUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(ImmediateExpiryUUID.ToString(), TimeSpan.FromDays(1));
byte[] foo = new byte[1];
foo[0] = 1;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
cache.Invalidate(cacheItemUUID.ToString());
cache.Get(cacheItemUUID.ToString());
object citem = cache.Get(cacheItemUUID.ToString());
Assert.That(citem == null, "Item should not be in Cache because we manually invalidated it");
}
public void TestTTLExpiredEntry()
{
UUID ImmediateExpiryUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(ImmediateExpiryUUID.ToString(), TimeSpan.FromDays(-1));
byte[] foo = new byte[1];
foo[0] = 1;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
cache.Get(cacheItemUUID.ToString());
//object citem = cache.Get(cacheItemUUID.ToString());
//Assert.That(citem == null, "Item should not be in Cache because the expiry time was before now");
}
public void ExpireItemManually()
{
UUID ImmediateExpiryUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(ImmediateExpiryUUID.ToString(), TimeSpan.FromDays(1));
byte[] foo = new byte[1];
foo[0] = 1;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
cache.Invalidate(ImmediateExpiryUUID.ToString());
cache.Get(cacheItemUUID.ToString());
//object citem = cache.Get(cacheItemUUID.ToString());
//Assert.That(citem == null, "Item should not be in Cache because we manually invalidated it");
}
public void TestTTLExpiredEntry()
{
UUID ImmediateExpiryUUID = UUID.Random();
MemoryCacheItem cachedItem = new MemoryCacheItem(ImmediateExpiryUUID.ToString(), TimeSpan.FromDays(-1));
byte[] foo = new byte[1];
foo[0] = 1;
cachedItem.Store(foo);
cache.Store(cacheItemUUID.ToString(), cachedItem);
cache.Get(cacheItemUUID.ToString());
//object citem = cache.Get(cacheItemUUID.ToString());
//Assert.That(citem == null, "Item should not be in Cache because the expiry time was before now");
}
/// <summary>
/// 设置缓存项
/// </summary>
/// <typeparam name="T">缓存数据类型</typeparam>
/// <param name="key">Key</param>
/// <param name="item">缓存数据</param>
/// <param name="policy">缓存策略</param>
public void Set <T>(string key, T item, CachePolicy?policy = null)
{
var cacheItem = new MemoryCacheItem <T>
{
Value = item
};
MemoryCacheEntryOptions opt = new MemoryCacheEntryOptions();
var entry = _cache.CreateEntry(key);
entry.Value = item;
if (policy != null)
{
opt.AbsoluteExpirationRelativeToNow = policy.Value.AbsoluteExpiration;
opt.SlidingExpiration = policy.Value.SlidingExpiration;
}
_cache.Set(key, cacheItem, opt);
}
private static void StoreToMemoryCache(string key, BitmapImage image)
{
lock (_memoryCache)
{
var mci = new MemoryCacheItem()
{
LastUpdated = DateTime.Now,
Image = image
};
if (_memoryCache.Contains(key))
{
_memoryCache[key] = mci;
}
else
{
_memoryCache.Add(key, mci);
}
FixMemoryCacheSize();
}
}
private void UnloadOldMemoryCacheItems()
{
int countUnload = Mathf.RoundToInt(countMemoryItems * memoryCacheUnloadRate);
if (countUnload == 0)
{
return;
}
if (countUnload < 0)
{
throw new Exception("Can not unload a negative number of items. Check memoryCacheUnloadRate.");
}
if (countMemoryItems < countUnload)
{
countUnload = countMemoryItems;
}
long[] unloadTimes = new long[countUnload];
int[] unloadIndices = new int[countUnload];
int c = 0;
for (int i = 0; i < countMemoryItems; i++)
{
long t = memoryCache[i].time;
if (c == 0)
{
unloadIndices[0] = 0;
unloadTimes[0] = t;
c++;
}
else
{
int index = c;
int index2 = index - 1;
while (index2 >= 0)
{
if (unloadTimes[index2] < t)
{
break;
}
index2--;
index--;
}
if (index < countUnload)
{
for (int j = countUnload - 1; j > index; j--)
{
unloadIndices[j] = unloadIndices[j - 1];
unloadTimes[j] = unloadTimes[j - 1];
}
unloadIndices[index] = i;
unloadTimes[index] = t;
if (c < countUnload)
{
c++;
}
}
}
}
for (int i = 0; i < countUnload; i++)
{
int index = unloadIndices[i];
MemoryCacheItem mci = memoryCache[index];
if (mci.tileUsed)
{
continue;
}
_memoryCacheSize -= mci.size;
mci.Dispose();
memoryCache[index] = null;
}
int offset = 0;
for (int i = 0; i < countMemoryItems; i++)
{
if (memoryCache[i] == null)
{
offset++;
}
else if (offset > 0)
{
memoryCache[i - offset] = memoryCache[i];
}
}
countMemoryItems -= countUnload;
}
/// <summary>
/// ake current cache item most recently used
/// </summary>
/// <param name="cacheItem">cache item</param>
/// <returns>cache item wrapped into node of type <see cref="LinkedListNode"/></returns>
/// <remarks>Both operation in the method have O(1) complexity</remarks>
private LinkedListNode <MemoryCacheItem <TKey, TValue> > UpdateAccessChain(MemoryCacheItem <TKey, TValue> cacheItem)
{
return(_accessChain.AddFirst(cacheItem));
}
