# Using Both (Extend & Override)

REN’s Redis cache service is also built to be **overridden** and customized—just like the in-memory cache! All the main methods are `virtual`, which means you can provide your own Redis-specific behavior and business logic whenever you need it.

***

## How to Override?&#x20;

### **1. Create a New Service that Overrides Existing Methods**

Inherit from `RENRedisCacheService` and override any method you wish to customize:

```csharp
public class ExtendedAndOverridedRENRedisCacheService(IConnectionMultiplexer connectionMultiplexer) : RENRedisCacheService(connectionMultiplexer), IExtendedRENRedisCacheService
{
    public void AdditionalMethod()
    {
        Console.WriteLine("ExtendedAndOverridedRENRedisCacheService AdditionalMethod called.");
        // Implement your additional logic here
    }

    public override void Set<T>(string cacheKey, T data, TimeSpan? absoluteExpiration = null, TimeSpan? slidingExpiration = null)
    {
        Console.WriteLine("ExtendedAndOverridedRENRedisCacheService Set called.");
        // You can add custom logic here before calling the base method
        base.Set(cacheKey, absoluteExpiration, slidingExpiration);
    }
}
```

***

### **2. Register Your Custom Implementation**

Tell the DI container to use your custom service for all cache operations. Register it like this:

```csharp
builder.Services.AddRENCaching<IExtendedRENRedisCacheService, ExtendedAndOverridedRENRedisCacheService>(RegisterRENCaching.CacheType.Redis);
```

In this example, `OverridedRENRedisCacheService` is passed as the generic type parameter `TCacheService`. The registration method (shown below) ensures your service is used for all Redis cache operations:

```csharp
public static void AddRENCaching<TCacheService>(this IServiceCollection services, CacheType cacheType)
    where TCacheService : IRENCacheService
{
    switch (cacheType)
    {
        case CacheType.InMemory:
            AddInMemoryRENCache<TCacheService>(services);
            break;
        case CacheType.Redis:
            AddRedisRENCache<TCacheService>(services);
            break;
        default:
            throw new ArgumentOutOfRangeException(nameof(cacheType), cacheType, null);
    }
}
```

* If you select `CacheType.Redis`, your overridden class will be registered for all Redis cache actions.
* If you select `CacheType.InMemory`, it would register for in-memory cache.
* If you pass an unsupported type, you’ll get a clear error.

{% hint style="success" %}
## **Pro Tip:**

This pattern lets you swap out or customize cache behavior for Redis (or any other provider) simply by changing the type in the registration—no need to touch the rest of your application.
{% endhint %}

***

### **3. Use Your Overridden Service in Your Application**

Now, wherever you inject `IRENCacheService`, your overridden Redis service will be used:

```csharp
[Route("api/[controller]")]
[ApiController]
public class ExtendedAndOverridedRedisCacheController(IExtendedRENRedisCacheService cacheService) : ControllerBase
{
    [HttpGet("additional-method")]
    public IActionResult AdditionalMethod(string key)
    {
        cacheService.AdditionalMethod();
        return Ok();
    }

    [HttpPost("set")]
    public IActionResult SetCache([FromQuery] string key, [FromBody] object value)
    {
        cacheService.Set(key, value, TimeSpan.FromMinutes(10));
        return Ok("Value cached.");
    }
}
```
