Is it possible to refactor these two similar methods that handle T and List<T>?

Question

Is there a way to unify or refactor two methods that do basically the same but the difference being of handling a type of object or a collection of the same type of object?

The following is an implementation of two methods that have very similar behavior. They handle a cache for an API, so when someone asks for a value or a set of values, it verifies that the entry is in cache already. If not, they call the method that will return from an external API: a value or a set of values. Finally the methods, update the cache and return the value/values.

public async Task<T> GetValue<T>(string cacheKey, Func<Task<T>> getItem, MemoryCacheEntryOptions memoryCacheEntryOptions = null)
{
    if (_memoryCache.TryGetValue(cacheKey, out T cacheEntry))
    {
        return cacheEntry;
    }
    else
    {
        cacheEntry = await getItem();

        return SetValue(cacheKey, cacheEntry, memoryCacheEntryOptions);
    }
}

public async Task<IList<T>> GetValues<T>(string cacheKey, Func<Task<IList<T>>> getItems, MemoryCacheEntryOptions memoryCacheEntryOptions = null)
{
    if (_memoryCache.TryGetValue(cacheKey, out IList<T> cacheEntries))
    {
        return cacheEntries;
    }
    else
    {
        cacheEntries = await getItems();

        return SetValues(cacheKey, cacheEntries, memoryCacheEntryOptions);
    }
}

Answer 1

I'm not sure I fully understand the question, but the first thing that leapt to mind is:

<T> can encompass a IList<SomeType> already.

I mean, the first 75% of GetValue() already works with using IList as the generic type:

public async Task<T> GetValue<T>(
        string cacheKey,
        Func<Task<T>> getItem,
        MemoryCacheEntryOptions memoryCacheEntryOptions = null)
{
    if (_memoryCache.TryGetValue(cacheKey, out T cacheEntry))
    {
        return cacheEntry;
    }
    else
    {
        cacheEntry = await getItem(); 

        return SetValue(cacheKey, cacheEntry, memoryCacheEntryOptions);
    }
}

... memoryCache.TryGetValue() works exactly the same, and will operate correctly. cacheEntry will be the correct type (an IList of something.) getItem() works perfectly, too, since it's a Func that returns the appropriate IList.

Literally the only thing that's different is SetValue vs SetValues. Which, from your original post, looks to be the call into the 3rd party API.

Well, it begs the question of whether SetValue() in the vendor API will work for an IList? If it does, your probably is immediately solved: just use GetValue for everything and call it a day.

Assuming that it doesn't, maybe the question would be whether something like this would work:

public async Task<T> GetValue<T>(string cacheKey, Func<Task<T>> getItem, MemoryCacheEntryOptions memoryCacheEntryOptions = null)
{
    return GetValue(cacheKey, getItem, x => SetValue(cacheKey, x, memoryCacheEntryOptions));
}
public async Task<T> GetValues<T>(string cacheKey, Func<Task<T>> getItem, MemoryCacheEntryOptions memoryCacheEntryOptions = null)
{
    return GetValue(cacheKey, getItem, x => SetValues(cacheKey, x, memoryCacheEntryOptions));
}

private async Task<T> GetValue<T>(string cacheKey, Func<Task<T>> getItem, Func<T, Task<T>> setItem)
{
    if (_memoryCache.TryGetValue(cacheKey, out T cacheEntry))
    {
        return cacheEntry;
    }
    else
    {
        cacheEntry = await getItem(); 

        return setItem(cacheEntry);
    }
}