Using Both

To use both you have to combine two methods. First create the IMyCacheService Interface to implement additional methods:

public interface IMyCacheService: IRENCacheService
{
    Task<T> GetSingleAsync<T>(string cacheKey, Func<T, bool> predicate, CancellationToken cancellationToken = default);
}

Then create MyCacheService class that inherits from RENInMemoryCacheService and IMyCacheService and contains overriden method(s):

public class MyCacheService : RENInMemoryCacheService, IMyCacheService
{
    public MyCacheService(IMemoryCache cache) : base(cache) { }

    public override async Task<T> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
    {
        Console.WriteLine("Getting custom...");
        //custom implementations
        return base.Get<T>(cacheKey);
    }

    // This method can share the same name as one of it's ancestor's functions
    // but since this method has different signatur it's okay!
    public async Task<T> GetSingleAsync<T>(string cacheKey, Func<T,bool> predicate, CancellationToken cancellationToken = default)
    {
        Console.WriteLine("Getting single custom...");
        var result = await base.GetAsync<IEnumerable<T>>(cacheKey, cancellationToken);
        return result == null ? default : result.SingleOrDefault(predicate);
    }
}

In Program.cs we need to register MyCacheService class from interface IMyCacheService since it contains the additional method.

builder.Services.AddScoped<IMyCacheService, MyCacheService>();

Then you can use your final cache service like this:

public class HomeController : ControllerBase
{
    private readonly IMyCacheService _customCacheService;
    private readonly IRENRepository<User> _userRepository;

    public HomeController(IRENUnitOfWork<RENDbContext> uow, IMyCacheService customCacheService)
    {
        _userRepository = uow.GetRENRepository<User>();
        _customCacheService = customCacheService;
    }

    [HttpGet]
    [Route("Index")]
    public async Task<IActionResult> Index()
    {
        var cacheKey = "users";
        var users = await _customCacheService.GetAsync<List<User>>(cacheKey);
    
        if (users != null) return Ok(users);
        users = await _userRepository.GetListAsync();
        await _customCacheService.SetAsync(cacheKey, users);
    
        return Ok(users);
    }

    [HttpGet]
    [Route("GetUser")]
    public async Task<IActionResult> Index([FromQuery] int Id)
    {
        var cacheKey = $"users_{Id}";
        var user = await _customCacheService.GetAsync<User>(cacheKey);
        if (user != null) return Ok(user);

        var allUsersCacheKey = "users";
        user = await _customCacheService.GetSingleAsync<User>(allUsersCacheKey, _ => _.Id == Id);
        if (user != null) return Ok(user);

        user = await _userRepository.GetSingleAsync(_ => _.Id == Id);
        await _customCacheService.SetAsync(cacheKey, user);

        return Ok(user);
    }
}