For HybridCache, should it possible to do a Get from the cache and then do a Set separately?

[abhisheksaraiya]

So far, there is a method GetOrCreateAsync which takes in a factory and caches the item fetched by the factory if it isnt present in the cache.
But there doesnt seem to be support for doing just a Get and then deciding if a Set should be called or not based upon the condition of the item to be cached.
What i mean is that if the requirement is that a null value should not be cached then one could do so:

        string productCode = "abc1";
        var product = await _hybridCache.GetAsync(productCode);
        if (product is null)
        {
            product = GetProductFromProxy(productCode);
            if(product is not null)
                await _hybridCache.SetAsync(productCode, product, tags: new[] { product.ArticleId });
        }

This way I can Set data in cache only if they actually exist.
Also, this allows me to set tags which are part of the data itself.
The current signature of GetOrCreateAsync does not allow providing tags which might be part of the data fetched from the factory.
Am i missing something here or its part of the design?
Or is there a way to

1. avoid saving null into the cache using the factory method
2. provide tags which might be coming from the data returned by the factory method.

I know that there is a chance for stampede during cache invalidation if set is done like this but since there isnt support within the existing GetOrCreateAsync perhaps doing a Get and Set separately is an option.

[abhisheksaraiya]

Seems like it is possible this way using HybridCacheEntryFlags.DisableUnderlyingData:

        var product = await _hybridCache.GetOrCreateAsync<Product?>(productCode, factory: null,
            new HybridCacheEntryOptions() { Flags = HybridCacheEntryFlags.DisableUnderlyingData });

        if (product is null)
        {
            product = await GetProductFromProxy(varuId);
            if (product != null)
                await _hybridCache.SetAsync(varuId, product);
        }

But in some cases, it would be nice to allow the tags be passed somehow by the factory function.

[BenjaminCharlton]

I was thinking the same thing. My use case was not to retrieve a value from the cache but just to know if it's there or not.

I have these extension methods. Maybe they'd help you?

namespace Microsoft.Extensions.Caching.Hybrid;

internal static class HybridCacheExtensions
{
    private static readonly HybridCacheEntryOptions _options = new() { Flags = HybridCacheEntryFlags.DisableUnderlyingData };

    public async static Task<bool> ExistsAsync(this HybridCache cache, string key)
    {
        (var exists, _) = await TryGetValueAsync<object>(cache, key);
        return exists;
    }

    public async static Task<(bool, T?)> TryGetValueAsync<T>(this HybridCache cache, string key)
    {
        var result = await cache.GetOrCreateAsync(
            key,
            async _ => await NoOpAsync<T>(),
            _options);

        return (result != null, result);
    }

    private static async ValueTask<T> NoOpAsync<T>() => await Task.FromResult<T>(default!);
}

[jodydonetti]

This will save the default value in the cache, which is not what you want I think.

A better one should be this:

public static async ValueTask<TValue> GetOrDefaultAsync<TValue>(this HybridCache cache, string key, TValue defaultValue, CancellationToken ct = default)
{
  return await cache.GetOrCreateAsync<TValue>(key, static _ => new ValueTask<TValue>(defaultValue), new HybridCacheEntryOptions { Flags = HybridCacheEntryFlags.DisableLocalCacheWrite | HybridCacheEntryFlags.DisableDistributedCacheWrite }, cancellationToken: ct);
}

[BenjaminCharlton]

Oh yes, those flags were very helpful! Thank you @jodydonetti ! And sorry for my misleading code this morning. I'm still trying to work it all out myself.

In my use case it's not "GetOrDefault" it's "Exists". I want to know if an item with the specified key is already there or not. It was surprisingly difficult with the current API (especially to write the unit tests) but those flags you pointed out made it possible.

Here's my implementation, which I couldn't have done without your help:

namespace Microsoft.Extensions.Caching.Hybrid;

internal static class HybridCacheExtensions
{
    /// <summary>
    /// Returns true if the cache contains an item with a matching key.
    /// </summary>
    /// <param name="cache">An instance of <see cref="HybridCache"/></param>
    /// <param name="key">The name (key) of the item to search for in the cache.</param>
    /// <returns>True if the item exists already. False if it doesn't.</returns>
    /// <remarks>Will never add or alter the state of any items in the cache.</remarks>
    public async static Task<bool> ExistsAsync(this HybridCache cache, string key)
    {
        (var exists, _) = await TryGetValueAsync<object>(cache, key);
        return exists;
    }

    /// <summary>
    /// Returns true if the cache contains an item with a matching key, along with the value of the matching cache entry.
    /// </summary>
    /// <typeparam name="T">The type of the value of the item in the cache.</typeparam>
    /// <param name="cache">An instance of <see cref="HybridCache"/></param>
    /// <param name="key">The name (key) of the item to search for in the cache.</param>
    /// <returns>A tuple of <see cref="bool"/> and the object (if found) retrieved from the cache.</returns>
    /// <remarks>Will never add or alter the state of any items in the cache.</remarks>
    public async static Task<(bool, T?)> TryGetValueAsync<T>(this HybridCache cache, string key)
    {
        var result = await cache.GetOrCreateAsync<object, object>(
            key,
            null!,
            DoNothing,
            Options,
            null,
            CancellationToken.None);

        return (result is not null, (T)result!);
    }

    /// <summary>
    /// These flags stop the extension methods from adding or modifying any items in the cache.
    /// </summary>
    /// <remarks>
    /// Need to declare these options as internal so that unit tests can find and use them.
    /// </remarks>
    internal static readonly HybridCacheEntryOptions Options = new()
    {
        Flags = HybridCacheEntryFlags.DisableUnderlyingData | HybridCacheEntryFlags.DisableLocalCacheWrite | HybridCacheEntryFlags.DisableDistributedCacheWrite
    };

    /// <summary>
    /// Does nothing.
    /// </summary>
    /// <remarks>Need to declare this as internal so that unit tests can pass it to a mock of the <see cref="HybridCache"/>.</remarks>
    internal static async ValueTask<object> DoNothing(object _, CancellationToken __)
    {
        return await ValueTask.FromResult<object>(null!);
    }
}

[jodydonetti]

Hi @BenjaminCharlton , happy it helped.

A couple of things to note:

• if you use HybridCacheEntryFlags.DisableUnderlyingData you don't need the factory, since it will not be called, and you can just pass null (or null! to not have compiler warnings)
• in the TryGetValueAsync method you are comparing the result to null, but null can actually be the cached value (which is a best practice, to avoid auto-DDoS-ing yourself with requests for non existing data, think /product/999999999 to your http api)

What I would do instead is to not disable the factory execution (so, no HybridCacheEntryFlags.DisableUnderlyingData) and, in the factory itself, update a value declared outside, right before the inner GetOrCreateAsync call.

Something like this:

public static async ValueTask<TValue> GetOrDefaultAsync<TValue>(this HybridCache cache, string key, TValue defaultValue, CancellationToken ct = default)
{
	return await cache.GetOrCreateAsync<TValue>(
		key,
		_ => new ValueTask<TValue>(defaultValue),
		new HybridCacheEntryOptions { Flags = HybridCacheEntryFlags.DisableLocalCacheWrite | HybridCacheEntryFlags.DisableDistributedCacheWrite },
		cancellationToken: ct
	);
}

public static async ValueTask<(bool Exists, TValue? Value)> TryGetAsync<TValue>(this HybridCache cache, string key, CancellationToken ct = default)
{
	var exists = true;
	var value = await cache.GetOrCreateAsync<TValue>(
		key,
		_ =>
		{
			exists = false;
			return new ValueTask<TValue>(default(TValue)!);
		},
		new HybridCacheEntryOptions { Flags = HybridCacheEntryFlags.DisableLocalCacheWrite | HybridCacheEntryFlags.DisableDistributedCacheWrite },
		cancellationToken: ct
	);
	return (exists, value);
}

public static async ValueTask<bool> ExistsAsync<TValue>(this HybridCache cache, string key, CancellationToken ct = default)
{
	(var exists, _) = await cache.TryGetAsync<TValue>(key, ct);
	return exists;
}

What do you think?

PS: the main problem that remains is that, since we are disabling writing on L1, if the value is present in L2 we are not taking it in L1 for the next access, meaning we'll go to L2 every single time (bad for perf etc). But with the current api surface area there's no other way.

[BenjaminCharlton]

I had faith that this would work, of course, but I wanted to unit test it properly. I found it difficult to make a mock cache that would call the Func<> when I needed it to simulate a cache miss. Here's the implementation after following your good advice, just in case it helps anybody else (or helps to train any AIs that are browsing the internet for answers!) I made other improvements on the above including getting rid of the superfluous 'internal's once I understood how.

namespace Microsoft.Extensions.Caching.Hybrid;

internal static class HybridCacheExtensions
{
    private static readonly HybridCacheEntryOptions _options = new HybridCacheEntryOptions()
    {
        Flags = HybridCacheEntryFlags.DisableLocalCacheWrite | HybridCacheEntryFlags.DisableDistributedCacheWrite
    };

    /// <summary>
    /// Returns true if the cache contains an item with a matching key.
    /// </summary>
    /// <param name="cache">An instance of <see cref="HybridCache"/></param>
    /// <param name="key">The name (key) of the item to search for in the cache.</param>
    /// <returns>True if the item exists already. False if it doesn't.</returns>
    /// <remarks>Will never add or alter the state of any items in the cache.</remarks>
    public async static Task<bool> ExistsAsync(this HybridCache cache, string key, CancellationToken cancellation = default)
    {
        (var exists, _) = await TryGetValueAsync<object>(cache, key);
        return exists;
    }

    /// <summary>
    /// Returns true if the cache contains an item with a matching key, along with the value of the matching cache entry.
    /// </summary>
    /// <typeparam name="T">The type of the value of the item in the cache.</typeparam>
    /// <param name="cache">An instance of <see cref="HybridCache"/></param>
    /// <param name="key">The name (key) of the item to search for in the cache.</param>
    /// <returns>A tuple of <see cref="bool"/> and the object (if found) retrieved from the cache.</returns>
    /// <remarks>Will never add or alter the state of any items in the cache.</remarks>
    public async static Task<(bool, T?)> TryGetValueAsync<T>(this HybridCache cache, string key, CancellationToken cancellation = default)
    {
        var exists = true;

        var result = await cache.GetOrCreateAsync<object, T>(
            key,
            null!,
            (_, _) =>
            {
                exists = false;
                return new ValueTask<T>(default(T)!);
            },
            _options,
            null,
            CancellationToken.None);

        return (exists, result);
    }
}

And the unit tests:

using Microsoft.Extensions.Caching.Hybrid;

namespace InMyCountry.WebApi.Tests;

[TestClass]
public class HybridCacheExtensionsTests
{
    private Mock<HybridCache> _cacheMock;
    private readonly HybridCacheEntryFlags _flags = HybridCacheEntryFlags.DisableLocalCacheWrite | HybridCacheEntryFlags.DisableDistributedCacheWrite;

    [TestInitialize]
    public void TestInitialize()
    {
        _cacheMock = new Mock<HybridCache>();
    }

    [TestMethod]
    public async Task ExistsAsync_WhenKeyExists_ShouldReturnTrue()
    {
        // Arrange
        string key = "test-key";
        var expectedValue = "test-value";

        _cacheMock
            .Setup(cache => cache.GetOrCreateAsync(
                key,
                null!,
                It.IsAny<Func<object, CancellationToken, ValueTask<object>>>(),
                It.Is<HybridCacheEntryOptions>(value => value.Flags == _flags),
                null,
                CancellationToken.None))
            .ReturnsAsync(expectedValue);

        // Act
        var exists = await HybridCacheExtensions.ExistsAsync(_cacheMock.Object, key);

        // Assert
        Assert.IsTrue(exists);
    }

    [TestMethod]
    public async Task ExistsAsync_WhenKeyDoesNotExist_ShouldReturnFalse()
    {
        // Arrange
        string key = "test-key";

        _cacheMock
            .Setup(cache => cache.GetOrCreateAsync(
                key,
                null!,
                It.IsAny<Func<object, CancellationToken, ValueTask<object>>>(),
                It.Is<HybridCacheEntryOptions>(value => value.Flags == _flags),
                null,
                CancellationToken.None))
            .Returns((
                string key,
                object? state,
                Func<object, CancellationToken, ValueTask<object>> factory,
                HybridCacheEntryOptions? options,
                IEnumerable<string>? tags,
                CancellationToken token) =>
            {
                return factory(state!, token);
            });

        // Act
        var exists = await HybridCacheExtensions.ExistsAsync(_cacheMock.Object, key);

        // Assert
        Assert.IsFalse(exists);
    }

    [TestMethod]
    public async Task TryGetValueAsync_WhenKeyExists_ShouldReturnTrueAndValueAsString()
    {
        // Arrange
        string key = "test-key";
        var expectedValue = "test-value";

        _cacheMock
            .Setup(cache => cache.GetOrCreateAsync(
                key,
                null!,
                It.IsAny<Func<object, CancellationToken, ValueTask<string>>>(),
                It.Is<HybridCacheEntryOptions>(value => value.Flags == _flags),
                null,
                CancellationToken.None))
            .ReturnsAsync(expectedValue);

        // Act
        var (exists, value) = await HybridCacheExtensions.TryGetValueAsync<string>(_cacheMock.Object, key);

        // Assert
        Assert.IsTrue(exists);
        Assert.AreEqual(expectedValue, value);
    }

    [TestMethod]
    public async Task TryGetValueAsync_WhenKeyExists_ShouldReturnTrueAndValueAsInteger()
    {
        // Arrange
        string key = "test-key";
        var expectedValue = 5;

        _cacheMock
            .Setup(cache => cache.GetOrCreateAsync(
                key,
                null!,
                It.IsAny<Func<object, CancellationToken, ValueTask<int>>>(),
                It.Is<HybridCacheEntryOptions>(value => value.Flags == _flags),
                null,
                CancellationToken.None))
            .ReturnsAsync(expectedValue);

        // Act
        var (exists, value) = await HybridCacheExtensions.TryGetValueAsync<int>(_cacheMock.Object, key);

        // Assert
        Assert.IsTrue(exists);
        Assert.AreEqual(expectedValue, value);
    }

    [TestMethod]
    public async Task TryGetValueAsync_WhenKeyExistsButValueIsNull_ShouldReturnTrueAndNullValue()
    {
        // Arrange
        string key = "test-key";

        _cacheMock
            .Setup(cache => cache.GetOrCreateAsync(
                key,
                null!,
                It.IsAny<Func<object, CancellationToken, ValueTask<object>>>(),
                It.Is<HybridCacheEntryOptions>(value => value.Flags == _flags),
                null,
                CancellationToken.None))
            .ReturnsAsync(null!);

        // Act
        var (exists, value) = await HybridCacheExtensions.TryGetValueAsync<int?>(_cacheMock.Object, key);

        // Assert
        Assert.IsTrue(exists);
        Assert.IsNull(value);
    }

    [TestMethod]
    public async Task TryGetValueAsync_WhenKeyDoesNotExist_ShouldReturnFalseAndNull()
    {
        // Arrange
        string key = "test-key";

        _cacheMock.Setup(cache => cache.GetOrCreateAsync(
            key,
            null,
            It.IsAny<Func<object?, CancellationToken, ValueTask<string>>>(),
            It.Is<HybridCacheEntryOptions>(value => value.Flags == _flags),
            null,
            CancellationToken.None))
            .Returns((
                string key,
                object? state,
                Func<object?, CancellationToken, ValueTask<string>> factory,
                HybridCacheEntryOptions? options,
                IEnumerable<string>? tags,
                CancellationToken token) =>
            {
                return factory(state, token);
            });

        // Act
        var (exists, value) = await HybridCacheExtensions.TryGetValueAsync<string>(_cacheMock.Object, key);

        // Assert
        Assert.IsFalse(exists);
        Assert.IsNull(value);
    }
}