IMemoryCache in .NET Core with Example

In .NET Core, managing caching efficiently can significantly enhance the performance of applications. The IMemoryCache interface plays a pivotal role in caching data in memory, providing a simple and effective way to store and retrieve cached data within your applications. This post aims to provide an in-depth understanding of IMemoryCache and its implementation with illustrative examples.

What is IMemoryCache?

IMemoryCache is an interface provided by the .NET Core framework, designed to cache data in memory within an application. It enables developers to temporarily store frequently accessed data, reducing the need to fetch it from the original source repeatedly.

Implementation Example

Let's explore a basic example of how to use IMemoryCache in a .NET Core application.

1. Step1:Adding the required namespace

   Firstly, ensure you have the necessary namespace imported at the top of your file:

       using Microsoft.Extensions.Caching.Memory;
       

2. Step2:Setting up the Cache

   In your application, you can configure the IMemoryCache instance in the ConfigureServices method of the Startup.cs file:

       public void ConfigureServices(IServiceCollection services)
   {
       services.AddMemoryCache();
       // Other service configurations...
   }
       

3. Step 3: Caching Data

   Now, let's cache data using IMemoryCache

   private readonly IMemoryCache _memoryCache;
   
   public ExampleService(IMemoryCache memoryCache)
   {
       _memoryCache = memoryCache;
   }
   
   public void CacheData(string key, object data)
   {
       // Store data in the cache with an expiration time
       _memoryCache.Set(key, data, TimeSpan.FromMinutes(10));
   }
   
   public object GetCachedData(string key)
   {
       // Retrieve data from the cache
       if (_memoryCache.TryGetValue(key, out object cachedData))
       {
           return cachedData;
       }
       return null;
   }
   
       

   In this example, CacheData method allows you to store data in the cache with a specific expiration time, while GetCachedData retrieves the cached data based on the provided key.

4. Step 4: Utilizing Cached Data

   You can now utilize the cached data in your application, fetching it from the cache instead of generating or retrieving it again from the original source.

       // Fetch data from cache or source
   var cachedResult = GetCachedData("myCachedDataKey");
   if (cachedResult == null)
   {
       // If data doesn't exist in the cache, fetch from the source and cache it
       var dataFromSource = FetchDataFromSource();
       CacheData("myCachedDataKey", dataFromSource);
       cachedResult = dataFromSource;
   }
   // Use cachedResult...
   
       

IMemoryCache in .NET Core provides a powerful way to manage in-memory caching, optimizing the performance of applications by reducing resource-intensive operations. By efficiently caching data, you can enhance the responsiveness and scalability of your .NET Core applications.

This post covered the basics of IMemoryCache along with a practical implementation example to get you started. Experiment with caching strategies and leverage the capabilities of IMemoryCache to optimize your applications effectively.

Happy coding!! 😊