diff --git a/AspNetCore.sln b/AspNetCore.sln index 68269bb213ca..8547083d378e 100644 --- a/AspNetCore.sln +++ b/AspNetCore.sln @@ -1788,6 +1788,12 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NotReferencedInWasmCodePack EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Components.WasmRemoteAuthentication", "src\Components\test\testassets\Components.WasmRemoteAuthentication\Components.WasmRemoteAuthentication.csproj", "{8A021D6D-7935-4AB3-BB47-38D4FF9B0D13}" EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Hybrid", "Hybrid", "{2D64CA23-6E81-488E-A7D3-9BDF87240098}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Caching.Hybrid", "src\Caching\Hybrid\src\Microsoft.Extensions.Caching.Hybrid.csproj", "{2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.Extensions.Caching.Hybrid.Tests", "src\Caching\Hybrid\test\Microsoft.Extensions.Caching.Hybrid.Tests.csproj", "{CF63C942-895A-4F6B-888A-7653D7C4991A}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -10789,6 +10795,38 @@ Global {8A021D6D-7935-4AB3-BB47-38D4FF9B0D13}.Release|x64.Build.0 = Release|Any CPU {8A021D6D-7935-4AB3-BB47-38D4FF9B0D13}.Release|x86.ActiveCfg = Release|Any CPU {8A021D6D-7935-4AB3-BB47-38D4FF9B0D13}.Release|x86.Build.0 = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|arm64.ActiveCfg = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|arm64.Build.0 = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|x64.ActiveCfg = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|x64.Build.0 = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|x86.ActiveCfg = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Debug|x86.Build.0 = Debug|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|Any CPU.Build.0 = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|arm64.ActiveCfg = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|arm64.Build.0 = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|x64.ActiveCfg = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|x64.Build.0 = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|x86.ActiveCfg = Release|Any CPU + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9}.Release|x86.Build.0 = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|arm64.ActiveCfg = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|arm64.Build.0 = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|x64.ActiveCfg = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|x64.Build.0 = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|x86.ActiveCfg = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Debug|x86.Build.0 = Debug|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|Any CPU.Build.0 = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|arm64.ActiveCfg = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|arm64.Build.0 = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|x64.ActiveCfg = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|x64.Build.0 = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|x86.ActiveCfg = Release|Any CPU + {CF63C942-895A-4F6B-888A-7653D7C4991A}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -11672,6 +11710,9 @@ Global {15D08EA7-8C63-45FB-8B4D-C5F8E43B433E} = {05A169C7-4F20-4516-B10A-B13C5649D346} {433F91E4-E39D-4EB0-B798-2998B3969A2C} = {6126DCE4-9692-4EE2-B240-C65743572995} {8A021D6D-7935-4AB3-BB47-38D4FF9B0D13} = {6126DCE4-9692-4EE2-B240-C65743572995} + {2D64CA23-6E81-488E-A7D3-9BDF87240098} = {0F39820F-F4A5-41C6-9809-D79B68F032EF} + {2B60E6D3-9E7C-427A-AD4E-BBE9A6D935B9} = {2D64CA23-6E81-488E-A7D3-9BDF87240098} + {CF63C942-895A-4F6B-888A-7653D7C4991A} = {2D64CA23-6E81-488E-A7D3-9BDF87240098} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {3E8720B3-DBDD-498C-B383-2CC32A054E8F} diff --git a/eng/ProjectReferences.props b/eng/ProjectReferences.props index 7686ce1e869c..caac54022a4d 100644 --- a/eng/ProjectReferences.props +++ b/eng/ProjectReferences.props @@ -5,6 +5,7 @@ --> + diff --git a/eng/ShippingAssemblies.props b/eng/ShippingAssemblies.props index bd06923b2454..d0cae638afbb 100644 --- a/eng/ShippingAssemblies.props +++ b/eng/ShippingAssemblies.props @@ -104,6 +104,7 @@ + diff --git a/src/Caching/Caching.slnf b/src/Caching/Caching.slnf index dcecdb8a91c7..63610b8e28d5 100644 --- a/src/Caching/Caching.slnf +++ b/src/Caching/Caching.slnf @@ -2,6 +2,8 @@ "solution": { "path": "..\\..\\AspNetCore.sln", "projects": [ + "src\\Caching\\Hybrid\\src\\Microsoft.Extensions.Caching.Hybrid.csproj", + "src\\Caching\\Hybrid\\test\\Microsoft.Extensions.Caching.Hybrid.Tests.csproj", "src\\Caching\\SqlServer\\src\\Microsoft.Extensions.Caching.SqlServer.csproj", "src\\Caching\\SqlServer\\test\\Microsoft.Extensions.Caching.SqlServer.Tests.csproj", "src\\Caching\\StackExchangeRedis\\src\\Microsoft.Extensions.Caching.StackExchangeRedis.csproj", diff --git a/src/Caching/Hybrid/src/HybridCacheBuilderExtensions.cs b/src/Caching/Hybrid/src/HybridCacheBuilderExtensions.cs new file mode 100644 index 000000000000..a27240f66418 --- /dev/null +++ b/src/Caching/Hybrid/src/HybridCacheBuilderExtensions.cs @@ -0,0 +1,64 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Microsoft.Extensions.DependencyInjection; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Configuration extension methods for / . +/// +public static class HybridCacheBuilderExtensions +{ + /// + /// Serialize values of type with the specified serializer from . + /// + public static IHybridCacheBuilder WithSerializer(this IHybridCacheBuilder builder, IHybridCacheSerializer serializer) + { + builder.Services.AddSingleton>(serializer); + return builder; + } + + /// + /// Serialize values of type with the serializer of type . + /// + public static IHybridCacheBuilder WithSerializer(this IHybridCacheBuilder builder) + where TImplementation : class, IHybridCacheSerializer + { + builder.Services.AddSingleton, TImplementation>(); + return builder; + } + + /// + /// Add as an additional serializer factory, which can provide serializers for multiple types. + /// + public static IHybridCacheBuilder WithSerializerFactory(this IHybridCacheBuilder builder, IHybridCacheSerializerFactory factory) + { + builder.Services.AddSingleton(factory); + return builder; + } + + /// + /// Add a factory of type as an additional serializer factory, which can provide serializers for multiple types. + /// + public static IHybridCacheBuilder WithSerializerFactory< +#if NET5_0_OR_GREATER + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] +#endif + TImplementation>(this IHybridCacheBuilder builder) + where TImplementation : class, IHybridCacheSerializerFactory + { + builder.Services.AddSingleton(); + return builder; + } +} diff --git a/src/Caching/Hybrid/src/HybridCacheOptions.cs b/src/Caching/Hybrid/src/HybridCacheOptions.cs new file mode 100644 index 000000000000..62407b9bf6a9 --- /dev/null +++ b/src/Caching/Hybrid/src/HybridCacheOptions.cs @@ -0,0 +1,48 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Options for configuring the default implementation. +/// +public class HybridCacheOptions +{ + /// + /// Default global options to be applied to operations; if options are + /// specified at the individual call level, the non-null values are merged (with the per-call + /// options being used in preference to the global options). If no value is specified for a given + /// option (globally or per-call), the implementation may choose a reasonable default. + /// + public HybridCacheEntryOptions? DefaultEntryOptions { get; set; } + + /// + /// Disallow compression for this instance. + /// + public bool DisableCompression { get; set; } + + /// + /// The maximum size of cache items; attempts to store values over this size will be logged + /// and the value will not be stored in cache. + /// + /// The default value is 1 MiB. + public long MaximumPayloadBytes { get; set; } = 1 << 20; // 1MiB + + /// + /// The maximum permitted length (in characters) of keys; attempts to use keys over this size will be logged. + /// + /// The default value is 1024 characters. + public int MaximumKeyLength { get; set; } = 1024; // characters + + /// + /// Use "tags" data as dimensions on metric reporting; if enabled, care should be used to ensure that + /// tags do not contain data that should not be visible in metrics systems. + /// + public bool ReportTagMetrics { get; set; } +} diff --git a/src/Caching/Hybrid/src/HybridCacheServiceExtensions.cs b/src/Caching/Hybrid/src/HybridCacheServiceExtensions.cs new file mode 100644 index 000000000000..bcbde7462a39 --- /dev/null +++ b/src/Caching/Hybrid/src/HybridCacheServiceExtensions.cs @@ -0,0 +1,60 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Microsoft.Extensions.Caching.Hybrid.Internal; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.DependencyInjection.Extensions; +using Microsoft.Extensions.Internal; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Configuration extension methods for . +/// +public static class HybridCacheServiceExtensions +{ + /// + /// Adds support for multi-tier caching services. + /// + /// A builder instance that allows further configuration of the system. + public static IHybridCacheBuilder AddHybridCache(this IServiceCollection services, Action setupAction) + { +#if NET7_0_OR_GREATER + ArgumentNullException.ThrowIfNull(setupAction); +#else + _ = setupAction ?? throw new ArgumentNullException(nameof(setupAction)); +#endif + AddHybridCache(services); + services.Configure(setupAction); + return new HybridCacheBuilder(services); + } + + /// + /// Adds support for multi-tier caching services. + /// + /// A builder instance that allows further configuration of the system. + public static IHybridCacheBuilder AddHybridCache(this IServiceCollection services) + { +#if NET7_0_OR_GREATER + ArgumentNullException.ThrowIfNull(services); +#else + _ = services ?? throw new ArgumentNullException(nameof(services)); +#endif + + services.TryAddSingleton(TimeProvider.System); + services.AddOptions(); + services.AddMemoryCache(); + services.AddDistributedMemoryCache(); // we need a backend; use in-proc by default + services.TryAddSingleton(); + services.TryAddSingleton>(InbuiltTypeSerializer.Instance); + services.TryAddSingleton>(InbuiltTypeSerializer.Instance); + services.TryAddSingleton(); + return new HybridCacheBuilder(services); + } +} diff --git a/src/Caching/Hybrid/src/IHybridCacheBuilder.cs b/src/Caching/Hybrid/src/IHybridCacheBuilder.cs new file mode 100644 index 000000000000..fae49c030fc3 --- /dev/null +++ b/src/Caching/Hybrid/src/IHybridCacheBuilder.cs @@ -0,0 +1,27 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Microsoft.Extensions.DependencyInjection; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Helper API for configuring . +/// +public interface IHybridCacheBuilder +{ + /// + /// Gets the services collection associated with this instance. + /// + IServiceCollection Services { get; } +} + +internal sealed class HybridCacheBuilder(IServiceCollection services) : IHybridCacheBuilder +{ + public IServiceCollection Services { get; } = services; +} diff --git a/src/Caching/Hybrid/src/Internal/DefaultHybridCache.cs b/src/Caching/Hybrid/src/Internal/DefaultHybridCache.cs new file mode 100644 index 000000000000..0ec73b682118 --- /dev/null +++ b/src/Caching/Hybrid/src/Internal/DefaultHybridCache.cs @@ -0,0 +1,62 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.Caching.Distributed; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Options; + +namespace Microsoft.Extensions.Caching.Hybrid.Internal; + +/// +/// The inbuilt ASP.NET implementation of . +/// +internal sealed class DefaultHybridCache : HybridCache +{ + private readonly IDistributedCache _backendCache; + private readonly IServiceProvider _services; + private readonly HybridCacheOptions _options; + + public DefaultHybridCache(IOptions options, IDistributedCache backendCache, IServiceProvider services) + { + _backendCache = backendCache ?? throw new ArgumentNullException(nameof(backendCache)); + _services = services ?? throw new ArgumentNullException(nameof(services)); + _options = options.Value; + } + + internal HybridCacheOptions Options => _options; + + public override ValueTask GetOrCreateAsync(string key, TState state, Func> underlyingDataCallback, HybridCacheEntryOptions? options = null, IReadOnlyCollection? tags = null, CancellationToken token = default) + => underlyingDataCallback(state, token); // pass-thru without caching for initial API pass + + public override ValueTask RemoveKeyAsync(string key, CancellationToken token = default) + => default; // no cache, nothing to remove + + public override ValueTask RemoveTagAsync(string tag, CancellationToken token = default) + => default; // no cache, nothing to remove + + public override ValueTask SetAsync(string key, T value, HybridCacheEntryOptions? options = null, IReadOnlyCollection? tags = null, CancellationToken token = default) + => default; // no cache, nothing to set + + internal IHybridCacheSerializer GetSerializer() + { + // unused API, primarily intended to show configuration is working; + // the real version would memoize the result + var service = _services.GetService>(); + if (service is null) + { + foreach (var factory in _services.GetServices()) + { + if (factory.TryCreateSerializer(out var current)) + { + service = current; + } + } + } + return service ?? throw new InvalidOperationException("No serializer configured for type: " + typeof(T).Name); + } +} diff --git a/src/Caching/Hybrid/src/Internal/DefaultJsonSerializerFactory.cs b/src/Caching/Hybrid/src/Internal/DefaultJsonSerializerFactory.cs new file mode 100644 index 000000000000..e925a033951f --- /dev/null +++ b/src/Caching/Hybrid/src/Internal/DefaultJsonSerializerFactory.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Diagnostics.CodeAnalysis; +using System.Text.Json; + +namespace Microsoft.Extensions.Caching.Hybrid.Internal; + +internal sealed class DefaultJsonSerializerFactory : IHybridCacheSerializerFactory +{ + public bool TryCreateSerializer([NotNullWhen(true)] out IHybridCacheSerializer? serializer) + { + // no restriction + serializer = new DefaultJsonSerializer(); + return true; + } + + internal sealed class DefaultJsonSerializer : IHybridCacheSerializer + { + T IHybridCacheSerializer.Deserialize(ReadOnlySequence source) + { + var reader = new Utf8JsonReader(source); +#pragma warning disable IL2026, IL3050 // AOT bits + return JsonSerializer.Deserialize(ref reader)!; +#pragma warning restore IL2026, IL3050 + } + + void IHybridCacheSerializer.Serialize(T value, IBufferWriter target) + { + using var writer = new Utf8JsonWriter(target); +#pragma warning disable IL2026, IL3050 // AOT bits + JsonSerializer.Serialize(writer, value, JsonSerializerOptions.Default); +#pragma warning restore IL2026, IL3050 + } + } + +} diff --git a/src/Caching/Hybrid/src/Internal/InbuiltTypeSerializer.cs b/src/Caching/Hybrid/src/Internal/InbuiltTypeSerializer.cs new file mode 100644 index 000000000000..a043fc1ca203 --- /dev/null +++ b/src/Caching/Hybrid/src/Internal/InbuiltTypeSerializer.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Buffers; +using System.Diagnostics; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; + +namespace Microsoft.Extensions.Caching.Hybrid.Internal; + +internal sealed class InbuiltTypeSerializer : IHybridCacheSerializer, IHybridCacheSerializer +{ + public static InbuiltTypeSerializer Instance { get; } = new(); + + string IHybridCacheSerializer.Deserialize(ReadOnlySequence source) + { +#if NET5_0_OR_GREATER + return Encoding.UTF8.GetString(source); +#else + if (source.IsSingleSegment && MemoryMarshal.TryGetArray(source.First, out var segment)) + { + // we can use the existing single chunk as-is + return Encoding.UTF8.GetString(segment.Array, segment.Offset, segment.Count); + } + + var length = checked((int)source.Length); + var oversized = ArrayPool.Shared.Rent(length); + source.CopyTo(oversized); + var s = Encoding.UTF8.GetString(oversized, 0, length); + ArrayPool.Shared.Return(oversized); + return s; +#endif + } + + void IHybridCacheSerializer.Serialize(string value, IBufferWriter target) + { +#if NET5_0_OR_GREATER + Encoding.UTF8.GetBytes(value, target); +#else + var length = Encoding.UTF8.GetByteCount(value); + var oversized = ArrayPool.Shared.Rent(length); + var actual = Encoding.UTF8.GetBytes(value, 0, value.Length, oversized, 0); + Debug.Assert(actual == length); + target.Write(new(oversized, 0, length)); + ArrayPool.Shared.Return(oversized); +#endif + } + + byte[] IHybridCacheSerializer.Deserialize(ReadOnlySequence source) + => source.ToArray(); + + void IHybridCacheSerializer.Serialize(byte[] value, IBufferWriter target) + => target.Write(value); +} diff --git a/src/Caching/Hybrid/src/Microsoft.Extensions.Caching.Hybrid.csproj b/src/Caching/Hybrid/src/Microsoft.Extensions.Caching.Hybrid.csproj new file mode 100644 index 000000000000..49671f048347 --- /dev/null +++ b/src/Caching/Hybrid/src/Microsoft.Extensions.Caching.Hybrid.csproj @@ -0,0 +1,30 @@ + + + + Multi-level caching implementation building on and extending IDistributedCache + $(DefaultNetCoreTargetFramework);$(DefaultNetFxTargetFramework);netstandard2.0 + true + cache;distributedcache;hybrid + true + false + true + true + + + + + + + + + + + + + + + + + + + diff --git a/src/Caching/Hybrid/src/PublicAPI.Shipped.txt b/src/Caching/Hybrid/src/PublicAPI.Shipped.txt new file mode 100644 index 000000000000..ab058de62d44 --- /dev/null +++ b/src/Caching/Hybrid/src/PublicAPI.Shipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/src/Caching/Hybrid/src/PublicAPI.Unshipped.txt b/src/Caching/Hybrid/src/PublicAPI.Unshipped.txt new file mode 100644 index 000000000000..47e46d6d30ce --- /dev/null +++ b/src/Caching/Hybrid/src/PublicAPI.Unshipped.txt @@ -0,0 +1,60 @@ +#nullable enable +abstract Microsoft.Extensions.Caching.Hybrid.HybridCache.GetOrCreateAsync(string! key, TState state, System.Func>! factory, Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions? options = null, System.Collections.Generic.IReadOnlyCollection? tags = null, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +abstract Microsoft.Extensions.Caching.Hybrid.HybridCache.RemoveKeyAsync(string! key, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +abstract Microsoft.Extensions.Caching.Hybrid.HybridCache.RemoveTagAsync(string! tag, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +abstract Microsoft.Extensions.Caching.Hybrid.HybridCache.SetAsync(string! key, T value, Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions? options = null, System.Collections.Generic.IReadOnlyCollection? tags = null, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +Microsoft.Extensions.Caching.Distributed.IBufferDistributedCache +Microsoft.Extensions.Caching.Distributed.IBufferDistributedCache.Set(string! key, System.Buffers.ReadOnlySequence value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions! options) -> void +Microsoft.Extensions.Caching.Distributed.IBufferDistributedCache.SetAsync(string! key, System.Buffers.ReadOnlySequence value, Microsoft.Extensions.Caching.Distributed.DistributedCacheEntryOptions! options, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +Microsoft.Extensions.Caching.Distributed.IBufferDistributedCache.TryGet(string! key, System.Buffers.IBufferWriter! destination) -> bool +Microsoft.Extensions.Caching.Distributed.IBufferDistributedCache.TryGetAsync(string! key, System.Buffers.IBufferWriter! destination, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +Microsoft.Extensions.Caching.Hybrid.HybridCache +Microsoft.Extensions.Caching.Hybrid.HybridCache.GetOrCreateAsync(string! key, System.Func>! factory, Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions? options = null, System.Collections.Generic.IReadOnlyCollection? tags = null, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +Microsoft.Extensions.Caching.Hybrid.HybridCache.HybridCache() -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheBuilderExtensions +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableCompression = 32 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableDistributedCache = Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableDistributedCacheRead | Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableDistributedCacheWrite -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableDistributedCacheRead = 4 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableDistributedCacheWrite = 8 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableLocalCache = Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableLocalCacheRead | Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableLocalCacheWrite -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableLocalCacheRead = 1 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableLocalCacheWrite = 2 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.DisableUnderlyingData = 16 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags.None = 0 -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.Expiration.get -> System.TimeSpan? +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.Expiration.init -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.Flags.get -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryFlags? +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.Flags.init -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.HybridCacheEntryOptions() -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.LocalCacheExpiration.get -> System.TimeSpan? +Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions.LocalCacheExpiration.init -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.DefaultEntryOptions.get -> Microsoft.Extensions.Caching.Hybrid.HybridCacheEntryOptions? +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.DefaultEntryOptions.set -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.DisableCompression.get -> bool +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.DisableCompression.set -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.HybridCacheOptions() -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.MaximumKeyLength.get -> int +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.MaximumKeyLength.set -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.MaximumPayloadBytes.get -> long +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.MaximumPayloadBytes.set -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.ReportTagMetrics.get -> bool +Microsoft.Extensions.Caching.Hybrid.HybridCacheOptions.ReportTagMetrics.set -> void +Microsoft.Extensions.Caching.Hybrid.HybridCacheServiceExtensions +Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder +Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder.Services.get -> Microsoft.Extensions.DependencyInjection.IServiceCollection! +Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializer +Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializer.Deserialize(System.Buffers.ReadOnlySequence source) -> T +Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializer.Serialize(T value, System.Buffers.IBufferWriter! target) -> void +Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializerFactory +Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializerFactory.TryCreateSerializer(out Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializer? serializer) -> bool +static Microsoft.Extensions.Caching.Hybrid.HybridCacheBuilderExtensions.WithSerializer(this Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! builder) -> Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! +static Microsoft.Extensions.Caching.Hybrid.HybridCacheBuilderExtensions.WithSerializer(this Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! builder, Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializer! serializer) -> Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! +static Microsoft.Extensions.Caching.Hybrid.HybridCacheBuilderExtensions.WithSerializerFactory(this Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! builder, Microsoft.Extensions.Caching.Hybrid.IHybridCacheSerializerFactory! factory) -> Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! +static Microsoft.Extensions.Caching.Hybrid.HybridCacheBuilderExtensions.WithSerializerFactory(this Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! builder) -> Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! +static Microsoft.Extensions.Caching.Hybrid.HybridCacheServiceExtensions.AddHybridCache(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services) -> Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! +static Microsoft.Extensions.Caching.Hybrid.HybridCacheServiceExtensions.AddHybridCache(this Microsoft.Extensions.DependencyInjection.IServiceCollection! services, System.Action! setupAction) -> Microsoft.Extensions.Caching.Hybrid.IHybridCacheBuilder! +virtual Microsoft.Extensions.Caching.Hybrid.HybridCache.RemoveKeysAsync(System.Collections.Generic.IEnumerable! keys, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +virtual Microsoft.Extensions.Caching.Hybrid.HybridCache.RemoveTagsAsync(System.Collections.Generic.IEnumerable! tags, System.Threading.CancellationToken token = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask diff --git a/src/Caching/Hybrid/src/Runtime/HybridCache.cs b/src/Caching/Hybrid/src/Runtime/HybridCache.cs new file mode 100644 index 000000000000..a2aaad2c0f26 --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/HybridCache.cs @@ -0,0 +1,124 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.Collections; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.Caching.Distributed; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Provides multi-tier caching services building on backends. +/// +public abstract class HybridCache +{ + /// + /// Asynchronously gets the value associated with the key if it exists, or generates a new entry using the provided key and a value from the given factory if the key is not found. + /// + /// The type of the data being considered. + /// The type of additional state required by . + /// The key of the entry to look for or create. + /// Provides the underlying data service is the data is not available in the cache. + /// Additional state required for . + /// Additional options for this cache entry. + /// The tags to associate with this cache item. + /// The used to propagate notifications that the operation should be canceled. + /// The data, either from cache or the underlying data service. + [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Delegate differences make this unambiguous")] + public abstract ValueTask GetOrCreateAsync(string key, TState state, Func> factory, + HybridCacheEntryOptions? options = null, IReadOnlyCollection? tags = null, CancellationToken token = default); + + /// + /// Asynchronously gets the value associated with the key if it exists, or generates a new entry using the provided key and a value from the given factory if the key is not found. + /// + /// The type of the data being considered. + /// The key of the entry to look for or create. + /// Provides the underlying data service is the data is not available in the cache. + /// Additional options for this cache entry. + /// The tags to associate with this cache item. + /// The used to propagate notifications that the operation should be canceled. + /// The data, either from cache or the underlying data service. + [System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "Delegate differences make this unambiguous")] + public ValueTask GetOrCreateAsync(string key, Func> factory, + HybridCacheEntryOptions? options = null, IReadOnlyCollection? tags = null, CancellationToken token = default) + => GetOrCreateAsync(key, factory, WrappedCallbackCache.Instance, options, tags, token); + + private static class WrappedCallbackCache // per-T memoized helper that allows GetOrCreateAsync and GetOrCreateAsync to share an implementation + { + // for the simple usage scenario (no TState), pack the original callback as the "state", and use a wrapper function that just unrolls and invokes from the state + public static readonly Func>, CancellationToken, ValueTask> Instance = static (callback, ct) => callback(ct); + } + + /// + /// Asynchronously sets or overwrites the value associated with the key. + /// + /// The type of the data being considered. + /// The key of the entry to create. + /// The value to assign for this cache entry. + /// Additional options for this cache entry. + /// The tags to associate with this cache entry. + /// The used to propagate notifications that the operation should be canceled. + public abstract ValueTask SetAsync(string key, T value, HybridCacheEntryOptions? options = null, IReadOnlyCollection? tags = null, CancellationToken token = default); + + /// + /// Asynchronously removes the value associated with the key if it exists. + /// + public abstract ValueTask RemoveKeyAsync(string key, CancellationToken token = default); + + /// + /// Asynchronously removes the value associated with the key if it exists. + /// + /// Implementors should treat null as empty + public virtual ValueTask RemoveKeysAsync(IEnumerable keys, CancellationToken token = default) + { + return keys switch + { + // for consistency with GetOrCreate/Set: interpret null as "none" + null or ICollection { Count: 0 } => default, + ICollection { Count: 1 } => RemoveTagAsync(keys.Single(), token), + _ => ForEachAsync(this, keys, token), + }; + + // default implementation is to call RemoveKeyAsync for each key in turn + static async ValueTask ForEachAsync(HybridCache @this, IEnumerable keys, CancellationToken token) + { + foreach (var key in keys) + { + await @this.RemoveKeyAsync(key, token).ConfigureAwait(false); + } + } + } + + /// + /// Asynchronously removes the value associated with the specified tags. + /// + /// Implementors should treat null as empty + public virtual ValueTask RemoveTagsAsync(IEnumerable tags, CancellationToken token = default) + { + return tags switch + { + // for consistency with GetOrCreate/Set: interpret null as "none" + null or ICollection { Count: 0 } => default, + ICollection { Count: 1 } => RemoveTagAsync(tags.Single(), token), + _ => ForEachAsync(this, tags, token), + }; + + // default implementation is to call RemoveTagAsync for each key in turn + static async ValueTask ForEachAsync(HybridCache @this, IEnumerable keys, CancellationToken token) + { + foreach (var key in keys) + { + await @this.RemoveTagAsync(key, token).ConfigureAwait(false); + } + } + } + + /// + /// Asynchronously removes the value associated with the specified tag. + /// + public abstract ValueTask RemoveTagAsync(string tag, CancellationToken token = default); +} diff --git a/src/Caching/Hybrid/src/Runtime/HybridCacheEntryFlags.cs b/src/Caching/Hybrid/src/Runtime/HybridCacheEntryFlags.cs new file mode 100644 index 000000000000..b6a51b11691f --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/HybridCacheEntryFlags.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Additional flags that apply to a operation. +/// +[Flags] +public enum HybridCacheEntryFlags +{ + /// + /// No additional flags. + /// + None = 0, + /// + /// Disables reading from the local in-process cache. + /// + DisableLocalCacheRead = 1 << 0, + /// + /// Disables writing to the local in-process cache. + /// + DisableLocalCacheWrite = 1 << 1, + /// + /// Disables both reading from and writing to the local in-process cache. + /// + DisableLocalCache = DisableLocalCacheRead | DisableLocalCacheWrite, + /// + /// Disables reading from the secondary distributed cache. + /// + DisableDistributedCacheRead = 1 << 2, + /// + /// Disables writing to the secondary distributed cache. + /// + DisableDistributedCacheWrite = 1 << 3, + /// + /// Disables both reading from and writing to the secondary distributed cache. + /// + DisableDistributedCache = DisableDistributedCacheRead | DisableDistributedCacheWrite, + /// + /// Only fetches the value from cache; does not attempt to access the underlying data store. + /// + DisableUnderlyingData = 1 << 4, + /// + /// Disables compression for this payload. + /// + DisableCompression = 1 << 5, +} diff --git a/src/Caching/Hybrid/src/Runtime/HybridCacheEntryOptions.cs b/src/Caching/Hybrid/src/Runtime/HybridCacheEntryOptions.cs new file mode 100644 index 000000000000..a5416cce9692 --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/HybridCacheEntryOptions.cs @@ -0,0 +1,32 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Additional options (expiration, etc.) that apply to a operation. When options +/// can be specified at multiple levels (for example, globally and per-call), the values are composed; the +/// most granular non-null value is used, with null values being inherited. If no value is specified at +/// any level, the implementation may choose a reasonable default. +/// +public sealed class HybridCacheEntryOptions +{ + /// + /// Overall cache duration of this entry, passed to the backend distributed cache. + /// + public TimeSpan? Expiration { get; init; } // overall cache duration + + /// + /// Cache duration in local cache; when retrieving a cached value + /// from an external cache store, this value will be used to calculate the local + /// cache expiration, not exceeding the remaining overall cache lifetime. + /// + public TimeSpan? LocalCacheExpiration { get; init; } // TTL in L1 + + /// + /// Additional flags that apply to this usage. + /// + public HybridCacheEntryFlags? Flags { get; init; } +} diff --git a/src/Caching/Hybrid/src/Runtime/IBufferDistributedCache.cs b/src/Caching/Hybrid/src/Runtime/IBufferDistributedCache.cs new file mode 100644 index 000000000000..994d52766a9d --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/IBufferDistributedCache.cs @@ -0,0 +1,52 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Threading; +using System.Threading.Tasks; + +namespace Microsoft.Extensions.Caching.Distributed; // intentional for parity with IDistributedCache + +/// +/// Represents a distributed cache of serialized values, with support for low allocation data transfer. +/// +public interface IBufferDistributedCache : IDistributedCache +{ + /// + /// Attempt to retrieve an existing cache item. + /// + /// The unique key for the cache item. + /// The target to write the cache contents on success. + /// true if the cache item is found, false otherwise. + /// This is functionally similar to , but avoids the array allocation. + bool TryGet(string key, IBufferWriter destination); + + /// + /// Asynchronously attempt to retrieve an existing cache entry. + /// + /// The unique key for the cache entry. + /// The target to write the cache contents on success. + /// The used to propagate notifications that the operation should be canceled. + /// true if the cache entry is found, false otherwise. + /// This is functionally similar to , but avoids the array allocation. + ValueTask TryGetAsync(string key, IBufferWriter destination, CancellationToken token = default); + + /// + /// Sets or overwrites a cache item. + /// + /// The key of the entry to create. + /// The value for this cache entry. + /// The cache options for the entry. + /// This is functionally similar to , but avoids the array allocation. + void Set(string key, ReadOnlySequence value, DistributedCacheEntryOptions options); + + /// + /// Asynchronously sets or overwrites a cache entry. + /// + /// The key of the entry to create. + /// The value for this cache entry. + /// The cache options for the value. + /// The used to propagate notifications that the operation should be canceled. + /// This is functionally similar to , but avoids the array allocation. + ValueTask SetAsync(string key, ReadOnlySequence value, DistributedCacheEntryOptions options, CancellationToken token = default); +} diff --git a/src/Caching/Hybrid/src/Runtime/IHybridCacheSerializer.cs b/src/Caching/Hybrid/src/Runtime/IHybridCacheSerializer.cs new file mode 100644 index 000000000000..f5c869a71772 --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/IHybridCacheSerializer.cs @@ -0,0 +1,24 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Per-type serialization/deserialization support for . +/// +/// The type being serialized/deserialized. +public interface IHybridCacheSerializer +{ + /// + /// Deserialize a value from the provided . + /// + T Deserialize(ReadOnlySequence source); + + /// + /// Serialize , writing to the provided . + /// + void Serialize(T value, IBufferWriter target); +} + diff --git a/src/Caching/Hybrid/src/Runtime/IHybridCacheSerializerFactory.cs b/src/Caching/Hybrid/src/Runtime/IHybridCacheSerializerFactory.cs new file mode 100644 index 000000000000..d500ddfb2ba9 --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/IHybridCacheSerializerFactory.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Diagnostics.CodeAnalysis; + +namespace Microsoft.Extensions.Caching.Hybrid; + +/// +/// Factory provider for per-type instances. +/// +public interface IHybridCacheSerializerFactory +{ + /// + /// Request a serializer for the provided type, if possible. + /// + /// The type being serialized/deserialized. + /// The serializer. + /// true if the factory supports this type, false otherwise. + bool TryCreateSerializer([NotNullWhen(true)] out IHybridCacheSerializer? serializer); +} diff --git a/src/Caching/Hybrid/src/Runtime/readme.md b/src/Caching/Hybrid/src/Runtime/readme.md new file mode 100644 index 000000000000..1e2289449f0b --- /dev/null +++ b/src/Caching/Hybrid/src/Runtime/readme.md @@ -0,0 +1,2 @@ +These types are intended to be added to be relocated to `Microsoft.Extensions.Caching.Abstractions`; their inclusion +here is a preview placeholder diff --git a/src/Caching/Hybrid/test/BasicConfig.json b/src/Caching/Hybrid/test/BasicConfig.json new file mode 100644 index 000000000000..374114fb1dba --- /dev/null +++ b/src/Caching/Hybrid/test/BasicConfig.json @@ -0,0 +1,12 @@ +{ + "no_entry_options": { + "MaximumKeyLength": 937 + }, + "with_entry_options": { + "MaximumKeyLength": 937, + "DefaultEntryOptions": { + "LocalCacheExpiration": "00:02:00", + "Flags": "DisableCompression,DisableLocalCacheRead" + } + } +} diff --git a/src/Caching/Hybrid/test/Microsoft.Extensions.Caching.Hybrid.Tests.csproj b/src/Caching/Hybrid/test/Microsoft.Extensions.Caching.Hybrid.Tests.csproj new file mode 100644 index 000000000000..c589f1499cc8 --- /dev/null +++ b/src/Caching/Hybrid/test/Microsoft.Extensions.Caching.Hybrid.Tests.csproj @@ -0,0 +1,20 @@ + + + + $(DefaultNetCoreTargetFramework);$(DefaultNetFxTargetFramework) + enable + enable + + + + + + + + + + PreserveNewest + + + + diff --git a/src/Caching/Hybrid/test/ServiceConstructionTests.cs b/src/Caching/Hybrid/test/ServiceConstructionTests.cs new file mode 100644 index 000000000000..d9515816f222 --- /dev/null +++ b/src/Caching/Hybrid/test/ServiceConstructionTests.cs @@ -0,0 +1,162 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Buffers; +using System.Runtime.CompilerServices; +using Microsoft.Extensions.Caching.Hybrid.Internal; +using Microsoft.Extensions.Configuration; +using Microsoft.Extensions.Configuration.Json; +using Microsoft.Extensions.DependencyInjection; + +#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously +#pragma warning disable CS8769 // Nullability of reference types in type of parameter doesn't match implemented member (possibly because of nullability attributes). + +namespace Microsoft.Extensions.Caching.Hybrid.Tests; +public class ServiceConstructionTests +{ + [Fact] + public void CanCreateDefaultService() + { + var services = new ServiceCollection(); + services.AddHybridCache(); + using var provider = services.BuildServiceProvider(); + Assert.IsType(provider.GetService()); + } + + [Fact] + public void CanCreateServiceWithManualOptions() + { + var services = new ServiceCollection(); + services.AddHybridCache(options => + { + options.MaximumKeyLength = 937; + options.DefaultEntryOptions = new() { Expiration = TimeSpan.FromSeconds(120), Flags = HybridCacheEntryFlags.DisableLocalCacheRead }; + }); + using var provider = services.BuildServiceProvider(); + var obj = Assert.IsType(provider.GetService()); + var options = obj.Options; + Assert.Equal(937, options.MaximumKeyLength); + var defaults = options.DefaultEntryOptions; + Assert.NotNull(defaults); + Assert.Equal(TimeSpan.FromSeconds(120), defaults.Expiration); + Assert.Equal(HybridCacheEntryFlags.DisableLocalCacheRead, defaults.Flags); + Assert.Null(defaults.LocalCacheExpiration); // wasn't specified + } + + [Fact] + public void CanParseOptions_NoEntryOptions() + { + var source = new JsonConfigurationSource { Path = "BasicConfig.json" }; + var configBuilder = new ConfigurationBuilder { Sources = { source } }; + var config = configBuilder.Build(); + var options = new HybridCacheOptions(); + ConfigurationBinder.Bind(config, "no_entry_options", options); + + Assert.Equal(937, options.MaximumKeyLength); + Assert.Null(options.DefaultEntryOptions); + } + [Fact] + public void CanParseOptions_WithEntryOptions() // in particular, check we can parse the timespan and [Flags] enums + { + var source = new JsonConfigurationSource { Path = "BasicConfig.json" }; + var configBuilder = new ConfigurationBuilder { Sources = { source } }; + var config = configBuilder.Build(); + var options = new HybridCacheOptions(); + ConfigurationBinder.Bind(config, "with_entry_options", options); + + Assert.Equal(937, options.MaximumKeyLength); + var defaults = options.DefaultEntryOptions; + Assert.NotNull(defaults); + Assert.Equal(HybridCacheEntryFlags.DisableCompression | HybridCacheEntryFlags.DisableLocalCacheRead, defaults.Flags); + Assert.Equal(TimeSpan.FromSeconds(120), defaults.LocalCacheExpiration); + Assert.Null(defaults.Expiration); // wasn't specified + } + + [Fact] + public async Task BasicStatelessUsage() + { + var services = new ServiceCollection(); + services.AddHybridCache(); + using var provider = services.BuildServiceProvider(); + var cache = provider.GetRequiredService(); + + var expected = Guid.NewGuid().ToString(); + var actual = await cache.GetOrCreateAsync(Me(), async _ => expected); + Assert.Equal(expected, actual); + } + + [Fact] + public async Task BasicStatefulUsage() + { + var services = new ServiceCollection(); + services.AddHybridCache(); + using var provider = services.BuildServiceProvider(); + var cache = provider.GetRequiredService(); + + var expected = Guid.NewGuid().ToString(); + var actual = await cache.GetOrCreateAsync(Me(), expected, async (state, _) => state); + Assert.Equal(expected, actual); + } + + [Fact] + public void DefaultSerializerConfiguration() + { + var services = new ServiceCollection(); + services.AddHybridCache(); + using var provider = services.BuildServiceProvider(); + var cache = Assert.IsType(provider.GetRequiredService()); + + Assert.IsType(cache.GetSerializer()); + Assert.IsType(cache.GetSerializer()); + Assert.IsType>(cache.GetSerializer()); + Assert.IsType>(cache.GetSerializer()); + } + + [Fact] + public void CustomSerializerConfiguration() + { + var services = new ServiceCollection(); + services.AddHybridCache().WithSerializer(); + using var provider = services.BuildServiceProvider(); + var cache = Assert.IsType(provider.GetRequiredService()); + + Assert.IsType(cache.GetSerializer()); + Assert.IsType>(cache.GetSerializer()); + } + + [Fact] + public void CustomSerializerFactoryConfiguration() + { + var services = new ServiceCollection(); + services.AddHybridCache().WithSerializerFactory(); + using var provider = services.BuildServiceProvider(); + var cache = Assert.IsType(provider.GetRequiredService()); + + Assert.IsType(cache.GetSerializer()); + Assert.IsType>(cache.GetSerializer()); + } + + class Customer { } + class Order { } + + class CustomerSerializer : IHybridCacheSerializer + { + Customer IHybridCacheSerializer.Deserialize(ReadOnlySequence source) => throw new NotImplementedException(); + void IHybridCacheSerializer.Serialize(Customer value, IBufferWriter target) => throw new NotImplementedException(); + } + + class CustomFactory : IHybridCacheSerializerFactory + { + bool IHybridCacheSerializerFactory.TryCreateSerializer(out IHybridCacheSerializer? serializer) + { + if (typeof(T) == typeof(Customer)) + { + serializer = (IHybridCacheSerializer)new CustomerSerializer(); + return true; + } + serializer = null; + return false; + } + } + private static string Me([CallerMemberName] string caller = "") => caller; +}