Real-Time Examples of Cache Proxy Design Pattern in C#

Back to: Design Patterns in C# With Real-Time Examples

Real-Time Examples of Cache Proxy Design Pattern in C#

In this article, I will discuss Real-Time Examples of Cache Proxy Design Patterns in C#. Please read our previous article, discussing Real-Time Examples of the Remote Proxy Design Pattern in C#. At the end of this article, you will understand the following pointers.

1. What is the Cache Proxy Design Pattern in C#?
2. Multiple Real-Time Examples of Cache Proxy Design Pattern in C#
3. Advantages and Disadvantages of Cache Proxy Design Pattern in C#
4. When to use Cache Proxy Design Pattern in C#?

Cache Proxy Design Pattern in C#

The Proxy design pattern provides a surrogate or placeholder for another object to control access to it. The Cache Proxy is a type of proxy that maintains a cache to store the results of expensive or frequently used operations so they can be returned without recomputing the results. Here is a simple example of the Cache Proxy design pattern in C#:

using System;
using System.Collections.Generic;

namespace CacheProxyDesignPattern
{
    // The Service Interface
    public interface IService
    {
        string GetData(int key);
    }

    // The Actual Service (could be some slow or expensive operations)
    public class ActualService : IService
    {
        public string GetData(int key)
        {
            Console.WriteLine("Fetching data for key: " + key);
            return "Data for " + key;
        }
    }

    // The Cache Proxy Service
    public class CacheProxyService : IService
    {
        private readonly IService _service;
        private readonly Dictionary<int, string> _cache = new Dictionary<int, string>();

        public CacheProxyService(IService service)
        {
            _service = service;
        }

        public string GetData(int key)
        {
            if (_cache.ContainsKey(key))
            {
                Console.WriteLine("Returning cached data for key: " + key);
                return _cache[key];
            }

            string result = _service.GetData(key);
            _cache[key] = result;
            return result;
        }
    }
    
    //Client Code
    //Testing Cache Proxy Design Pattern
    public class Program
    {
        public static void Main()
        {
            IService service = new CacheProxyService(new ActualService());

            Console.WriteLine(service.GetData(1)); // Fetching data for key: 1
            Console.WriteLine(service.GetData(1)); // Returning cached data for key: 1
            Console.WriteLine(service.GetData(2)); // Fetching data for key: 2
            Console.ReadKey();
        }
    }
}

In this example, the CacheProxyService class wraps an instance of the ActualService class. It maintains a dictionary as a cache to store the results of the GetData method. When a client requests data with a specific key, the proxy first checks if the data is already in the cache. If it is, the cached data is returned; otherwise, the actual service is called to fetch the data, and the result is then stored in the cache for future requests. You will get the following output when you run the above application.

Real-Time Example of Cache Proxy Design Pattern in C#

Let’s consider a real-time example related to accessing user profile pictures. Suppose you’re developing a social networking application where users can view their friends’ profile pictures. Every time a user views a friend’s profile, the system fetches the friend’s profile picture. Retrieving the profile picture from the database or a file system each time is inefficient, especially if it’s a frequent operation.

Implementing a Cache Proxy for the profile picture retrieval operation allows you to cache the images and serve them faster without repeatedly hitting the database or file system. Here’s a simplistic demonstration of this using the Cache Proxy Design Pattern in C#:

using System;
using System.Collections.Generic;

namespace CacheProxyDesignPattern
{
    public interface IProfilePictureService
    {
        byte[] GetProfilePicture(int userId);
    }

    public class DatabaseProfilePictureService : IProfilePictureService
    {
        public byte[] GetProfilePicture(int userId)
        {
            Console.WriteLine($"Fetching profile picture for user {userId} from database...");
            // Simulating database fetch with a byte array.
            // Simplified representation of a user's image.
            byte[] barray = new byte[1000];
            return barray; 
        }
    }

    public class CachedProfilePictureService : IProfilePictureService
    {
        private readonly IProfilePictureService _service;
        private readonly Dictionary<int, byte[]> _cache = new Dictionary<int, byte[]>();

        public CachedProfilePictureService(IProfilePictureService service)
        {
            _service = service;
        }

        public byte[] GetProfilePicture(int userId)
        {
            if (_cache.ContainsKey(userId))
            {
                Console.WriteLine($"Returning cached profile picture for user {userId}.");
                return _cache[userId];
            }

            var picture = _service.GetProfilePicture(userId);
            _cache[userId] = picture;
            return picture;
        }
    }
    
    //Client Code
    //Testing Cache Proxy Design Pattern
    public class Program
    {
        public static void Main()
        {
            IProfilePictureService service = new CachedProfilePictureService(new DatabaseProfilePictureService());

            var pic1 = service.GetProfilePicture(1); // Fetches from database.
            var pic2 = service.GetProfilePicture(1); // Returns from cache.
            var pic3 = service.GetProfilePicture(2); // Fetches from database.
            Console.ReadKey();
        }
    }
}

In this example, when the client requests a user’s profile picture, the CachedProfilePictureService checks its cache. If the profile picture is already in the cache, it returns the cached version. If not, it fetches the image from the DatabaseProfilePictureService (which simulates fetching from a database) and then stores it in the cache for future requests. This way, frequently viewed profile pictures are served faster, reducing the load on the database.

Real-Time Example of Cache Proxy Design Pattern in C#

Let’s understand another real-world example. This time, let’s consider web requests to an API for weather information. Imagine you’re developing an application where users can request the current weather information for a particular city. The application fetches this data from a remote weather API. Each API call could have latency and be rate-limited or charged based on the number of requests. It’s reasonable to cache the weather information briefly, as it doesn’t change every second and can be considered “good enough” for most user-facing applications for a few minutes or even hours. Here’s a demonstration using the Cache Proxy Design Pattern in C#:

using System;
using System.Collections.Generic;
using System.Threading;
namespace CacheProxyDesignPattern
{
    public interface IWeatherService
    {
        string GetWeather(string city);
    }

    public class RemoteWeatherService : IWeatherService
    {
        public string GetWeather(string city)
        {
            // Simulate a delay for the external API call.
            Thread.Sleep(2000);
            Console.WriteLine($"Fetching weather data for {city} from remote API...");
            return $"{city}: 25°C, Sunny"; // A mock representation. In reality, we'd call an API here.
        }
    }

    public class CachedWeatherService : IWeatherService
    {
        private readonly IWeatherService _service;
        private readonly Dictionary<string, (string weather, DateTime timestamp)> _cache = new Dictionary<string, (string, DateTime)>();
        private readonly TimeSpan cacheDuration = TimeSpan.FromMinutes(10);

        public CachedWeatherService(IWeatherService service)
        {
            _service = service;
        }

        public string GetWeather(string city)
        {
            if (_cache.ContainsKey(city))
            {
                var (weather, timestamp) = _cache[city];
                if (DateTime.UtcNow - timestamp < cacheDuration)
                {
                    Console.WriteLine($"Returning cached weather data for {city}.");
                    return weather;
                }
            }

            var freshWeather = _service.GetWeather(city);
            _cache[city] = (freshWeather, DateTime.UtcNow);
            return freshWeather;
        }
    }

    //Client Code
    //Testing Cache Proxy Design Pattern
    public class Program
    {
        public static void Main()
        {
            IWeatherService service = new CachedWeatherService(new RemoteWeatherService());

            Console.WriteLine(service.GetWeather("London")); // Fetches from remote API.
            Console.WriteLine(service.GetWeather("London")); // Returns from cache.
            Console.WriteLine(service.GetWeather("Paris"));  // Fetches from remote API.
            Console.ReadKey();
        }
    }
}

In this example, the CachedWeatherService checks its cache when a client requests weather information for a city. If the weather data is available and not expired (e.g., older than 10 minutes in this example), it returns the cached data. If not, it fetches fresh weather data from the RemoteWeatherService (which simulates calling a remote weather API) and then caches it for future requests.

Advantages and Disadvantages of Cache Proxy Design Pattern in C#

The Cache Proxy Design Pattern offers both advantages and disadvantages:

Advantages of Cache Proxy Design Pattern in C#:

• Performance Improvement: The most evident benefit is the speedup achieved by serving results from the cache instead of re-computing or re-fetching them, especially when the original operation is costly in terms of time or resources.
• Reduced Network Traffic: If the actual service is hosted remotely, caching results locally can reduce the amount of data that must be transferred over the network.
• Cost Savings: Reducing the number of calls to a service, especially if it’s a third-party service that charges per call, can lead to cost savings.
• Availability: Even if the main service goes down temporarily, the proxy can still serve cached results, increasing the system’s availability.
• Consistency: For operations that are expected to return the same result within short time frames (e.g., fetching unchanged database rows, unchanged configurations, etc.), caching ensures consistent results without hitting the actual service repeatedly.

Disadvantages of Cache Proxy Design Pattern in C#:

• Stale Data: The cache might serve outdated or stale data if it’s not synchronized with the service. This is especially problematic in scenarios where real-time or near-real-time data is crucial.
• Cache Management Overhead: Cache invalidation is often said to be one of the two hard problems in computer science. Deciding when and how to invalidate or refresh the cache can be tricky.
• Memory Usage: Storing results in a cache that consumes memory. This might lead to issues in systems with limited memory or a vast amount of data.
• Increased Complexity: Introducing a Cache Proxy adds an extra layer of complexity to the system, which could lead to maintenance challenges, especially if not designed properly.
• Write Operations: Caching is generally beneficial for read-heavy operations. Maintaining cache consistency can become a challenge in scenarios where write operations are prevalent, as each write might require an update or invalidation in the cache.
• Possible Bugs: Incorrectly implemented cache logic can introduce subtle bugs, like serving cached data when it’s supposed to be bypassed.

While the Cache Proxy Design Pattern can be beneficial in many scenarios, analyzing the specific use case, the importance of data freshness and the system’s requirements before implementing it is essential. Proper testing, monitoring, and fine-tuning are also crucial to ensure the cache effectively serves its intended purpose.

When to use Cache Proxy Design Pattern in C#?

The Cache Proxy Design Pattern is useful when you need to optimize certain aspects of your system, primarily related to resource access or computations. Here are some scenarios when you might consider using the Cache Proxy Design Pattern in C#:

• Expensive Operations: If an operation, such as a database query or a complex calculation, is expensive in terms of time or computational resources, it makes sense to cache its results if the same operation with the same inputs is likely to be repeated.
• Rate-limited Services: If you’re accessing a third-party service or API with rate limits, caching can help you stay within the rate limits by reducing the number of calls you make to that service.
• Reducing Network Latency: For systems that rely on remote data fetches (like accessing data over a network), caching the data locally can drastically reduce the time it takes to retrieve the data subsequently.
• Cost Efficiency: If you’re dealing with services that charge based on the number of requests (like many cloud services), caching can help reduce the costs.
• Bandwidth Conservation: By serving data from the cache, you can reduce the amount of data transferred over a network, which is particularly useful for applications with limited bandwidth.
• Enhancing Availability: If there’s a possibility that the primary data source might be unavailable or face downtime, caching can serve as a backup to provide data when the main source is unreachable.
• Temporary Data Storage: For scenarios where data doesn’t change often (e.g., configuration settings), a cache can act as a quick-access temporary storage, ensuring that the system doesn’t have to fetch unchanged data repeatedly.
• Mitigating Variable Response Times: For services with fluctuating response times, a cache can help provide a consistent experience to the end-user.

However, while considering the Cache Proxy Pattern, it’s also essential to be aware of the challenges and responsibilities it introduces:

• Stale Data: Caching can lead to situations where users are presented with outdated or stale data.
• Cache Management: Cache invalidation and eviction strategies need to be carefully designed. The saying “There are only two hard things in Computer Science: cache invalidation and naming things” humorously highlights this challenge.
• Memory Overhead: Caching will consume additional system memory, especially in-memory caching.
• Complexity: Introducing caching adds another layer of complexity to your system, leading to potential bugs or unexpected behaviors if not managed correctly.

In the next article, I will discuss the Real-Time Examples of Logging Proxy Design Patterns in C#. Here, in this article, I try to explain the Real-Time Examples of Cache Proxy Design Patterns in C#. I hope you enjoy this Cache Proxy Design Pattern in Real-time Examples using the C# article.