本文整理汇总了C#中System.Runtime.Caching.MemoryCache.Set方法的典型用法代码示例。如果您正苦于以下问题：C# MemoryCache.Set方法的具体用法？C# MemoryCache.Set怎么用？C# MemoryCache.Set使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类System.Runtime.Caching.MemoryCache的用法示例。
在下文中一共展示了MemoryCache.Set方法的5个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: ExistingObject_IncrementByOneAndSetExpirationDate
public void ExistingObject_IncrementByOneAndSetExpirationDate()
{
// Arrange
var key = new SimpleThrottleKey("test", "key");
var limiter = new Limiter()
.Limit(1)
.Over(100);
var cache = new MemoryCache("testing_cache");
var repository = new MemoryThrottleRepository(cache);
string id = repository.CreateThrottleKey(key, limiter);
var cacheItem = new MemoryThrottleRepository.ThrottleCacheItem()
{
Count = 1,
Expiration = new DateTime(2030, 1, 1)
};
cache
.Set(id, cacheItem, cacheItem.Expiration);
// Act
repository.AddOrIncrementWithExpiration(key, limiter);
// Assert
var item = (MemoryThrottleRepository.ThrottleCacheItem)cache.Get(id);
Assert.Equal(2L, item.Count);
Assert.Equal(new DateTime(2030, 1, 1), item.Expiration);
}示例2: Trim
public void Trim ()
{
var config = new NameValueCollection ();
config ["__MonoEmulateOneCPU"] = "true";
var mc = new MemoryCache ("MyCache", config);
for (int i = 0; i < 10; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), null);
// .NET doesn't touch the freshest 10 entries
Assert.AreEqual (10, mc.GetCount (), "#A1-1");
long trimmed = mc.Trim (50);
Assert.AreEqual (0, trimmed, "#A1-2");
Assert.AreEqual (10, mc.GetCount (), "#A1-3");
mc = new MemoryCache ("MyCache", config);
// Only entries 11- are considered for removal
for (int i = 0; i < 11; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), null);
Assert.AreEqual (11, mc.GetCount (), "#A2-1");
trimmed = mc.Trim (50);
Assert.AreEqual (1, trimmed, "#A2-2");
Assert.AreEqual (10, mc.GetCount (), "#A2-3");
mc = new MemoryCache ("MyCache", config);
// Only entries 11- are considered for removal
for (int i = 0; i < 125; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), null);
Assert.AreEqual (125, mc.GetCount (), "#A3-1");
trimmed = mc.Trim (50);
Assert.AreEqual (62, trimmed, "#A3-2");
Assert.AreEqual (63, mc.GetCount (), "#A3-3");
// Testing the removal order
mc = new MemoryCache ("MyCache", config);
var removed = new List <string> ();
var cip = new CacheItemPolicy ();
cip.RemovedCallback = (CacheEntryRemovedArguments args) => {
removed.Add (args.CacheItem.Key);
};
for (int i = 0; i < 50; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), cip);
object value;
for (int i = 0; i < 50; i++)
value = mc.Get ("key" + i.ToString ());
trimmed = mc.Trim (50);
Assert.AreEqual (25, mc.GetCount (), "#A4-1");
Assert.AreEqual (25, trimmed, "#A4-2");
Assert.AreEqual (25, removed.Count, "#A4-3");
// OK, this is odd... The list is correct in terms of entries removed but the entries
// are removed in the _MOST_ frequently used order, within the group selected for removal.
for (int i = 24; i >= 0; i--) {
int idx = 24 - i;
Assert.AreEqual ("key" + i.ToString (), removed [idx], "#A5-" + idx.ToString ());
}
}示例3: Trim
public void Trim ()
{
var config = new NameValueCollection ();
config ["__MonoEmulateOneCPU"] = "true";
var mc = new MemoryCache ("MyCache", config);
for (int i = 0; i < 10; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), null);
Assert.AreEqual (10, mc.GetCount (), "#A1-1");
long trimmed = mc.Trim (50);
Assert.AreEqual (5, trimmed, "#A1-2");
Assert.AreEqual (5, mc.GetCount (), "#A1-3");
mc = new MemoryCache ("MyCache", config);
// Only entries 11- are considered for removal
for (int i = 0; i < 11; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), null);
Assert.AreEqual (11, mc.GetCount (), "#A2-1");
trimmed = mc.Trim (50);
Assert.AreEqual (6, trimmed, "#A2-2");
Assert.AreEqual (5, mc.GetCount (), "#A2-3");
mc = new MemoryCache ("MyCache", config);
// Only entries 11- are considered for removal
for (int i = 0; i < 125; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), null);
Assert.AreEqual (125, mc.GetCount (), "#A3-1");
trimmed = mc.Trim (50);
Assert.AreEqual (63, trimmed, "#A3-2");
Assert.AreEqual (62, mc.GetCount (), "#A3-3");
// Testing the removal order
mc = new MemoryCache ("MyCache", config);
var removed = new List <string> ();
var cip = new CacheItemPolicy ();
cip.RemovedCallback = (CacheEntryRemovedArguments args) => {
removed.Add (args.CacheItem.Key);
};
for (int i = 0; i < 50; i++)
mc.Set ("key" + i.ToString (), "value" + i.ToString (), cip);
object value;
for (int i = 0; i < 50; i++)
value = mc.Get ("key" + i.ToString ());
trimmed = mc.Trim (50);
Assert.AreEqual (25, mc.GetCount (), "#A4-1");
Assert.AreEqual (25, trimmed, "#A4-2");
Assert.AreEqual (25, removed.Count, "#A4-3");
for (int i = 0; i < 25; i++)
Assert.AreEqual ("key" + i.ToString (), removed [i], "#A5-" + i.ToString ());
}示例4: MemorySpeedPerformance
private static void MemorySpeedPerformance()
{
/*
* Some numbers:
* 1. keep in mind, this is done with blocking => ...value).Result
* 2. all tests were ran in debug mode
* Remarks:
* Running the async methods synchronously adds a *lot* of overhead, so the values are probably
* exaggerated quite a bit (since they were ran using the async versions).
*
* Based on the figures, it looks like you can store 1m raw objects with 10k strings in < 1s. However
* at ~70s, you can compress and store those same objects but use ~1/50th the space. Neato!
* ---------------------------------------------------------------------------------------------------------
* 1m iterations @ OneLong
* ---------------------------------------------------------------------------------------------------------
* Blocking Async No Async
* Serialized Set: 6,921,999 1,962ms 2,262ms
* Serialized Get: 3,529,009 929ms 1,055ms
* Compression Set: 177,613,772 54,904ms 22,462ms
* Decompression Get: 4,610,846 1,248ms 1,096ms
* Raw Set: 3,317,033 1,046ms 1,063ms
* Raw Get: 472,352 139ms 141ms
*
* No Async
* Serialized v Raw Get: 7.47114x 5.7688x
* Serialized v Raw Set: 2.08680x 1.9814x
* Compression v Raw Get: 9.76146x 6.2608x
* Compression v Raw Set: 53.54598x 20.6647x
*
* ---------------------------------------------------------------------------------------------------------
* 1m iterations @ MultipleProperties w/ GenerateString(1, 1) (Ran using the synchronous methods)
* (From this we can see that in the simplest case we pay the cost for compressing the data, but when it
* doesn't improve the result (non-compressed size is better than compressed), compressed data retrieval is
* nearly the same cost as serialized-only retrieval (because the smart bit is 0)).
* ---------------------------------------------------------------------------------------------------------
* Serialized Set: 8,010,415
* Serialized Get: 3,784,092
* Compression Set: 50,185,964
* Decompression Get: 4,051,573
* Raw Set: 3,437,408
* Raw Get: 465,960
*
* No Async
* Serialized v Raw Get: 8.1210x
* Serialized v Raw Set: 2.3303x
* Compression v Raw Get: 8.6951x
* Compression v Raw Set: 14.5999x
*
* ---------------------------------------------------------------------------------------------------------
* 1m iterations @ MultipleProperties w/ GenerateString(128, 128)
* ---------------------------------------------------------------------------------------------------------
* Serialized Set: 8,138,454
* Serialized Get: 3,425,754
* Compression Set: 316,601,410
* Decompression Get: 76,957,352
* Raw Set: 3,389,203
* Raw Get: 463,274
*
* No Async
* Serialized v Raw Get: 7.3946x 5.5158x
* Serialized v Raw Set: 2.4012x 2.5692x
* Compression v Raw Get: 166.1163x 36.6555x
* Compression v Raw Set: 93.4147x 31.4675x
*
* ---------------------------------------------------------------------------------------------------------
* 1m iterations @ MultipleProperties w/ GenerateString(10000, 10000)
* ---------------------------------------------------------------------------------------------------------
* Serialized Set: 53,034,383
* Serialized Get: 3,893,312
* Compression Set: 570,493,276
* Decompression Get: 483,579,832
* Raw Set: 3,247,694
* Raw Get: 462,159
*
* No Async
* Serialized v Raw Get: 8.424x 8.2344x
* Serialized v Raw Set: 16.329x 15.6698x
* Compression v Raw Get: 1,046.349x 448.3221x
* Compression v Raw Set: 175.661x 99.6618x
*/
const int ITERATIONS = 30000;
const string KEY = "impt-key";
var value = new OneLong
{
Id = GenerateId()
};
MemoryCache cM = new MemoryCache("cM");
Stopwatch sw = Stopwatch.StartNew();
// warmup
byte[] serialize = ProtoBufSerializer.Serialize(value);
byte[] compress = SmartCompressor.Instance.Compress(serialize);
cM.Set(KEY, compress, null);
for (int i = 0; i < ITERATIONS; i++)
{
serialize = ProtoBufSerializer.Serialize(value);
//.........这里部分代码省略.........
示例5: MemorySizePerformance
private static void MemorySizePerformance()
{
/*
* Some numbers:
* ---------------------------------------------------------------------------------------------------------
* 10k objects
* ---------------------------------------------------------------------------------------------------------
* maxStringSize repeatStringSize serialized vs Raw compression vs raw
* 1 1 92.4% 93.8%
* 17 1 88.7% 90.0%
* 128 1 73.9% 74.7%
* 2 2 92.7% 93.8%
* 17 2 86.7% 89.7%
* 128 2 73.9% 74.7%
* 4 4 90.5% 91.6%
* 17 4 86.7% 89.7%
* 128 4 73.9% 68.8%
* 128 128 73.9% 56.8%
*
* 10,000 10,000 50.7% 1.8%
* 100,000 100,000 50.1% 0.2%
*/
const int MAX_STRING_SIZE = 10000;
const int REPEAT_STRING_SIZE = 10;
const int ITERATIONS = 1000;
const string KEY = "impt-key";
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
long mCs = GC.GetTotalMemory(true);
MemoryCache cM = new MemoryCache("cM");
for (int i = 0; i < ITERATIONS; i++)
{
var m = new MultipleProperties
{
Id = GenerateId(),
Name = GenerateString(MAX_STRING_SIZE, REPEAT_STRING_SIZE)
};
byte[] s = ProtoBufSerializer.Serialize(m);
byte[] c = SmartCompressor.Instance.CompressAsync(s).Result;
cM.Set(KEY + i.ToString(CultureInfo.InvariantCulture), c, null);
}
long mCe = GC.GetTotalMemory(true);
long compressMemory = mCe - mCs;
cM.Trim(100);
cM.Dispose();
// ReSharper disable once RedundantAssignment
cM = null;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
long mSs = GC.GetTotalMemory(true);
MemoryCache sM = new MemoryCache("sM");
for (int i = 0; i < ITERATIONS; i++)
{
var m = new MultipleProperties
{
Id = GenerateId(),
Name = GenerateString(MAX_STRING_SIZE, REPEAT_STRING_SIZE)
};
byte[] s = ProtoBufSerializer.Serialize(m);
sM.Set(KEY + i.ToString(CultureInfo.InvariantCulture), s, null);
}
long mSe = GC.GetTotalMemory(true);
long serializeMemory = mSe - mSs;
sM.Trim(100);
sM.Dispose();
// ReSharper disable once RedundantAssignment
sM = null;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
GC.WaitForPendingFinalizers();
long mRs = GC.GetTotalMemory(true);
MemoryCache rM = new MemoryCache("rM");
for (int i = 0; i < ITERATIONS; i++)
{
var m = new MultipleProperties
{
Id = GenerateId(),
Name = GenerateString(MAX_STRING_SIZE, REPEAT_STRING_SIZE)
};
rM.Set(KEY + i.ToString(CultureInfo.InvariantCulture), m, null);
}
//.........这里部分代码省略.........