Ejemplo n.º 1
0
        public static void Main(string[] args)
        {
            // Runs several concurrent threads that access an item that periodically expires and is re-created.
            MemoryCache cache = new MemoryCache(new MemoryCacheOptions());
            string key = "MyKey";

            var options = new MemoryCacheEntryOptions().SetAbsoluteExpiration(TimeSpan.FromMilliseconds(50));

            var tasks = new List<Task>();
            for (int threads = 0; threads < 100; threads++)
            {
                var task = Task.Run(() =>
                {
                    for (int i = 0; i < 110000; i++)
                    {
                        object value;
                        if(!cache.TryGetValue(key, out value))
                        {
                            // Fake expensive object creation.
                            for (int j = 0; j < 1000000; j++)
                            {
                            }

                            cache.Set(key, new object(), options);
                        }
                    }
                });
                tasks.Add(task);
            }

            Console.WriteLine("Running");
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("Done");
        }
Ejemplo n.º 2
0
 public PhotoController()
 {
     _cache = new MemoryCache(new MemoryCacheOptions { CompactOnMemoryPressure = false, ExpirationScanFrequency = new TimeSpan(0, 0, 30) });
     _cache.Set(_cacheKey, new[]
     {
         new { Thumbnail = "DSC00597_small.jpeg", FullSize = "DSC00597.Jpg", Raw = "DSC00597.ARW" },
         new { Thumbnail = "DSC00601_small.jpeg", FullSize = "DSC00601.Jpg", Raw = "DSC00601.ARW" },
         new { Thumbnail = "DSC00605_small.jpeg", FullSize = "DSC00605.Jpg", Raw = "DSC00605.ARW" },
         new { Thumbnail = "DSC00609_small.jpeg", FullSize = "DSC00609.Jpg", Raw = "DSC00609.ARW" },
         new { Thumbnail = "DSC00615_small.jpeg", FullSize = "DSC00615.Jpg", Raw = "DSC00615.ARW" },
         new { Thumbnail = "DSC00620_small.jpeg", FullSize = "DSC00620.Jpg", Raw = "DSC00620.ARW" },
         new { Thumbnail = "DSC00625_small.jpeg", FullSize = "DSC00625.Jpg", Raw = "DSC00625.ARW" },
         new { Thumbnail = "DSC00629_small.jpeg", FullSize = "DSC00629.Jpg", Raw = "DSC00629.ARW" },
         new { Thumbnail = "DSC00598_small.jpeg", FullSize = "DSC00598.Jpg", Raw = "DSC00598.ARW" },
         new { Thumbnail = "DSC00602_small.jpeg", FullSize = "DSC00602.Jpg", Raw = "DSC00602.ARW" },
         new { Thumbnail = "DSC00606_small.jpeg", FullSize = "DSC00606.Jpg", Raw = "DSC00606.ARW" },
         new { Thumbnail = "DSC00610_small.jpeg", FullSize = "DSC00610.Jpg", Raw = "DSC00610.ARW" },
         new { Thumbnail = "DSC00617_small.jpeg", FullSize = "DSC00617.Jpg", Raw = "DSC00617.ARW" },
         new { Thumbnail = "DSC00621_small.jpeg", FullSize = "DSC00621.Jpg", Raw = "DSC00621.ARW" },
         new { Thumbnail = "DSC00626_small.jpeg", FullSize = "DSC00626.Jpg", Raw = "DSC00626.ARW" },
         new { Thumbnail = "DSC00630_small.jpeg", FullSize = "DSC00630.Jpg", Raw = "DSC00630.ARW" },
         new { Thumbnail = "DSC00599_small.jpeg", FullSize = "DSC00599.Jpg", Raw = "DSC00599.ARW" },
         new { Thumbnail = "DSC00603_small.jpeg", FullSize = "DSC00603.Jpg", Raw = "DSC00603.ARW" },
         new { Thumbnail = "DSC00607_small.jpeg", FullSize = "DSC00607.Jpg", Raw = "DSC00607.ARW" },
         new { Thumbnail = "DSC00611_small.jpeg", FullSize = "DSC00611.Jpg", Raw = "DSC00611.ARW" },
         new { Thumbnail = "DSC00618_small.jpeg", FullSize = "DSC00618.Jpg", Raw = "DSC00618.ARW" },
         new { Thumbnail = "DSC00622_small.jpeg", FullSize = "DSC00622.Jpg", Raw = "DSC00622.ARW" },
         new { Thumbnail = "DSC00627_small.jpeg", FullSize = "DSC00627.Jpg", Raw = "DSC00627.ARW" },
         new { Thumbnail = "DSC00600_small.jpeg", FullSize = "DSC00600.Jpg", Raw = "DSC00600.ARW" },
         new { Thumbnail = "DSC00604_small.jpeg", FullSize = "DSC00604.Jpg", Raw = "DSC00604.ARW" },
         new { Thumbnail = "DSC00608_small.jpeg", FullSize = "DSC00608.Jpg", Raw = "DSC00608.ARW" },
         new { Thumbnail = "DSC00614_small.jpeg", FullSize = "DSC00614.Jpg", Raw = "DSC00614.ARW" },
         new { Thumbnail = "DSC00619_small.jpeg", FullSize = "DSC00619.Jpg", Raw = "DSC00619.ARW" },
         new { Thumbnail = "DSC00623_small.jpeg", FullSize = "DSC00623.Jpg", Raw = "DSC00623.ARW" },
         new { Thumbnail = "DSC00628_small.jpeg", FullSize = "DSC00628.Jpg", Raw = "DSC00628.ARW" },
     });
 }
Ejemplo n.º 3
0
        public void Main()
        {
            IMemoryCache cache = new MemoryCache(new MemoryCacheOptions());
            object result;
            string key = "Key";
            object newObject = new object();
            object state = new object();

            // Basic CRUD operations:

            // Create / Overwrite
            result = cache.Set(key, newObject);
            result = cache.Set(key, new object());

            // Retrieve, null if not found
            result = cache.Get(key);

            // Retrieve
            bool found = cache.TryGetValue(key, out result);

            // Delete
            cache.Remove(key);

            // Cache entry configuration:

            // Stays in the cache as long as possible
            result = cache.Set(
                key,
                new object(),
                new MemoryCacheEntryOptions().SetPriority(CacheItemPriority.NeverRemove));

            // Automatically remove if not accessed in the given time
            result = cache.Set(
                key,
                new object(),
                new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromMinutes(5)));

            // Automatically remove at a certain time
            result = cache.Set(
                key,
                new object(),
                new MemoryCacheEntryOptions().SetAbsoluteExpiration(DateTimeOffset.UtcNow.AddDays(2)));

            // Automatically remove at a certain time, which is relative to UTC now
            result = cache.Set(
                key,
                new object(),
                new MemoryCacheEntryOptions().SetAbsoluteExpiration(relative: TimeSpan.FromMinutes(10)));

            // Automatically remove if not accessed in the given time
            // Automatically remove at a certain time (if it lives that long)
            result = cache.Set(
                key,
                new object(),
                new MemoryCacheEntryOptions()
                .SetSlidingExpiration(TimeSpan.FromMinutes(5))
                .SetAbsoluteExpiration(DateTimeOffset.UtcNow.AddDays(2)));

            // Callback when evicted
            var options = new MemoryCacheEntryOptions()
                .RegisterPostEvictionCallback(
                (echoKey, value, reason, substate) =>
                {
                    Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason);
                });
            result = cache.Set(key, new object(), options);

            // Remove on token expiration
            var cts = new CancellationTokenSource();
            options = new MemoryCacheEntryOptions()
                .AddExpirationToken(new CancellationChangeToken(cts.Token))
                .RegisterPostEvictionCallback(
                (echoKey, value, reason, substate) =>
                {
                    Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason);
                });
            result = cache.Set(key, new object(), options);

            // Fire the token to see the registered callback being invoked
            cts.Cancel();

            // Expire an entry if the dependent entry expires
            using (var link = cache.CreateLinkingScope())
            {
                cts = new CancellationTokenSource();
                cache.Set("key1", "value1", new MemoryCacheEntryOptions()
                    .AddExpirationToken(new CancellationChangeToken(cts.Token)));

                // expire this entry if the entry with key "key1" expires.
                cache.Set("key2", "value2", new MemoryCacheEntryOptions()
                    .AddEntryLink(link)
                    .RegisterPostEvictionCallback(
                    (echoKey, value, reason, substate) =>
                    {
                        Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason);
                    }));
            }

            // Fire the token to see the registered callback being invoked
            cts.Cancel();
        }
Ejemplo n.º 4
0
        public async Task ProcessAsync_FlowsEntryLinkThatAllowsAddingTriggersToAddedEntry()
        {
            // Arrange
            var id = "some-id";
            var expectedContent = new DefaultTagHelperContent();
            expectedContent.SetContent("some-content");
            var tokenSource = new CancellationTokenSource();
            var cache = new MemoryCache(new MemoryCacheOptions());
            var cacheEntryOptions = new MemoryCacheEntryOptions()
                .AddExpirationTrigger(new CancellationTokenTrigger(tokenSource.Token));
            var tagHelperContext = new TagHelperContext(
                allAttributes: new TagHelperAttributeList(),
                items: new Dictionary<object, object>(),
                uniqueId: id,
                getChildContentAsync: () =>
                {
                    TagHelperContent tagHelperContent;
                    if(!cache.TryGetValue("key1", out tagHelperContent))
                    {
                        tagHelperContent = expectedContent;
                        cache.Set("key1", tagHelperContent, cacheEntryOptions);
                    }

                    return Task.FromResult(tagHelperContent);
                });
            var tagHelperOutput = new TagHelperOutput("cache", new TagHelperAttributeList { { "attr", "value" } });
            tagHelperOutput.PreContent.SetContent("<cache>");
            tagHelperOutput.PostContent.SetContent("</cache>");
            var cacheTagHelper = new CacheTagHelper(cache)
            {
                ViewContext = GetViewContext(),
            };
            var key = cacheTagHelper.GenerateKey(tagHelperContext);

            // Act - 1
            await cacheTagHelper.ProcessAsync(tagHelperContext, tagHelperOutput);
            TagHelperContent cachedValue;
            var result = cache.TryGetValue(key, out cachedValue);

            // Assert - 1
            Assert.Equal(expectedContent.GetContent(), tagHelperOutput.Content.GetContent());
            Assert.True(result);
            Assert.Equal(expectedContent, cachedValue);

            // Act - 2
            tokenSource.Cancel();
            result = cache.TryGetValue(key, out cachedValue);

            // Assert - 2
            Assert.False(result);
            Assert.Null(cachedValue);
        }
Ejemplo n.º 5
0
        public void Main()
        {
            IMemoryCache cache = new MemoryCache(new MemoryCacheOptions());
            object result;
            string key = "Key";
            object newObject = new object();
            object state = new object();

            // Basic CRUD operations:

            // Create / Overwrite
            result = cache.Set(key, newObject);
            result = cache.Set(key, context => new object());
            result = cache.Set(key, state, context => new object());

            // Retrieve, null if not found
            result = cache.Get(key);

            // Retrieve
            bool found = cache.TryGetValue(key, out result);

            // Delete
            cache.Remove(key);

            // Conditional operations:

            // Retrieve / Create when we want to lazily create the object.
            result = cache.GetOrSet(key, context => new object());

            // Retrieve / Create when we want to lazily create the object.
            result = cache.GetOrSet(key, state, context => new object());

            // Cache entry configuration:

            // Stays in the cache as long as possible
            result = cache.GetOrSet(key, state, context =>
            {
                context.SetPriority(CachePreservationPriority.NeverRemove);
                return new object();
            });

            // Automatically remove if not accessed in the given time
            result = cache.GetOrSet(key, state, context =>
            {
                context.SetSlidingExpiration(TimeSpan.FromMinutes(5));
                return new object();
            });

            // Automatically remove at a certain time
            result = cache.GetOrSet(key, state, context =>
            {
                context.SetAbsoluteExpiration(new DateTime(2014, 12, 31));
                // or relative:
                // context.SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
                return new object();
            });

            // Automatically remove if not accessed in the given time
            // Automatically remove at a certain time (if it lives that long)
            result = cache.GetOrSet(key, state, context =>
            {
                context.SetSlidingExpiration(TimeSpan.FromMinutes(5));

                context.SetAbsoluteExpiration(new DateTime(2014, 12, 31));
                // or relative:
                // context.SetAbsoluteExpiration(TimeSpan.FromMinutes(5));
                return new object();
            });

            // Callback when evicted
            result = cache.GetOrSet(key, state, context =>
            {
                context.RegisterPostEvictionCallback((echoKey, value, reason, substate) =>
                    Console.WriteLine(echoKey + ": '" + value + "' was evicted due to " + reason), state: null);
                return new object();
            });

            // Remove on trigger
            var cts = new CancellationTokenSource();
            result = cache.GetOrSet(key, state, context =>
            {
                context.AddExpirationTrigger(new CancellationTokenTrigger(cts.Token));
                return new object();
            });

            result = cache.GetOrSet(key, context =>
            {
                var link = new EntryLink();

                var inner1 = cache.GetOrSet("subkey1", link, subContext =>
                {
                    return "SubValue1";
                });

                string inner2;
                using (link.FlowContext())
                {
                    inner2 = cache.GetOrSet("subkey2", subContext =>
                    {
                        return "SubValue2";
                    });
                }

                context.AddEntryLink(link);

                return inner1 + inner2;
            });
        }