Useful to avoid multiple requests to the same Task<T> (e.g. an HTTP GET operation). You probably want to registered the loader as a scoped or singleton service. Bare in mind that GetOrAdd is *not* atomic, although you can use your loader safely since it is thread-safe (usage of Lazy<Task<T>> to avoid multiple operations to resolve Task<T>).

BaseLoader.cs

public abstract class BaseLoader<T> : IBaseLoader<T>
    where T : class
{
    private readonly ConcurrentDictionary<string, Lazy<Task<T?>>> cache = new();

    public Task<T?> LoadAsync(string key, Func<Task<T?>> factory)
    {
        return cache.GetOrAdd(key, (_) => new Lazy<Task<T?>>(factory)).Value;
    }
}

CategoriesLoader.cs

public class CategoriesLoader : BaseLoader<Category>, ICategoriesLoader
{
    private const string CategoryCacheKey = "Category:{0}";

    public Task<Category?> LoadAsync(byte id, CancellationToken cancellationToken)
    {
        var key = string.Format(CategoryCacheKey, id);

        return LoadAsync(key, () => GetCategoryByIdTask());
    }
}

IBaseLoader.cs

public interface IBaseLoader<T>
    where T : class
{
    Task<T?> LoadAsync(string key, Func<Task<T?>> factory);
}

ICategoriesLoader.cs

public interface ICategoriesLoader
{
    Task<Category?> LoadAsync(byte id, CancellationToken cancellationToken);
}