.NET'te önbelleğe alma

Bu makalede çeşitli önbelleğe alma mekanizmaları hakkında bilgi edineceksiniz. Önbelleğe alma, verileri ara katmanda depolayarak sonraki veri almaları daha hızlı hale getirme işlemidir. Kavramsal olarak önbelleğe alma, performans iyileştirme stratejisi ve tasarım konusunda dikkat edilmesi gereken bir konudur. Önbelleğe alma, seyrek değişen (veya alınması pahalı) verileri daha hazır hale getirerek uygulama performansını önemli ölçüde artırabilir. Bu makalede iki birincil önbelleğe alma türü tanıtılarak her ikisi için de örnek kaynak kodu sağlanır:

• Microsoft.Extensions.Caching.Memory
• Microsoft.Extensions.Caching.Distributed

Önemli

.NET içinde, biri MemoryCache ad alanında, diğeri System.Runtime.Caching ad alanında bulunan iki Microsoft.Extensions.Caching sınıf vardır.

• System.Runtime.Caching.MemoryCache
• Microsoft.Extensions.Caching.Memory.MemoryCache

Bu makale önbelleğe almaya odaklansa da NuGet paketini içermez System.Runtime.Caching . MemoryCache ile ilgili tüm başvurular Microsoft.Extensions.Caching ad alanı içindedir.

Microsoft.Extensions.* paketlerin tümü bağımlılık ekleme (DI) hazır olarak gelir, hem IMemoryCache hem de IDistributedCache arabirimleri hizmetler olarak kullanılabilir.

Bellek içi önbellek

Bu bölümde Microsoft.Extensions.Caching.Memory paketi hakkında bilgi edineceksiniz. IMemoryCache'nin mevcut uygulaması, ConcurrentDictionary<TKey,TValue> üzerinde zengin özellikli bir API sunan bir sarmalayıcıdır. Önbellekteki girdiler ICacheEntry ile temsil edilir ve herhangi bir object olabilir. Bellek içi önbellek çözümü, önbelleğe alınan tüm verilerin uygulama işleminde bellek kiraladığı tek bir sunucuda çalışan uygulamalar için mükemmeldir.

Tavsiye

Çok sunuculu önbelleğe alma senaryoları için, bellek içi önbelleğe almaya alternatif olarak Dağıtılmış önbelleğe alma yaklaşımını göz önünde bulundurun.

Bellek içi önbelleğe alma API'si

Önbelleğin tüketicisi hem kayan hem de mutlak süre sonu üzerinde denetime sahiptir:

• ICacheEntry.AbsoluteExpiration
• ICacheEntry.AbsoluteExpirationRelativeToNow
• ICacheEntry.SlidingExpiration

Son kullanma süresi ayarlamak, önbellekteki öğelerin, belirlenen süre içinde erişilmezse atılmasına neden olur. Tüketicilerin MemoryCacheEntryOptions aracılığıyla önbellek girdilerini kontrol etmek için ek seçenekleri vardır. Her ICacheEntry, MemoryCacheEntryOptions ile eşleştirilir ve IChangeToken ile silinme süre sonu işlevselliğini açığa çıkarır, CacheItemPriority ile öncelik ayarlarını belirler ve ICacheEntry.Size üzerindeki kontrolü sağlar. Aşağıdaki uzantı yöntemlerini göz önünde bulundurun:

• MemoryCacheEntryExtensions.AddExpirationToken
• MemoryCacheEntryExtensions.RegisterPostEvictionCallback
• MemoryCacheEntryExtensions.SetSize
• MemoryCacheEntryExtensions.SetPriority

Bellek içi önbellek örneği

Varsayılan IMemoryCache uygulamayı kullanmak için uzantı yöntemini çağırarak AddMemoryCache tüm gerekli hizmetleri DI'ye kaydedin. Aşağıdaki kod örneğinde, GENEL ana bilgisayar DI işlevselliğini kullanıma açmak için kullanılır:

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
builder.Services.AddMemoryCache();
using IHost host = builder.Build();

.NET iş yükünüze bağlı olarak, oluşturucu enjeksiyonu gibi farklı yöntemlerle IMemoryCache'e erişebilirsiniz. Bu örnekte, IServiceProvider örneğini host üzerinde kullanarak genel GetRequiredService<T>(IServiceProvider) uzantı yöntemini çağırırsınız.

IMemoryCache cache =
    host.Services.GetRequiredService<IMemoryCache>();

Bellek içi önbelleğe alma hizmetleri kayıtlı ve DI aracılığıyla çözümlenmiş durumdayken önbelleğe almaya başlamaya hazırsınız. Bu örnek, İngilizce 'A' ile 'Z' alfabesindeki harfler arasında yinelenir. record AlphabetLetter türü harfle ilgili başvuruyu içerir ve bir mesaj üretir.

file record AlphabetLetter(char Letter)
{
    internal string Message =>
        $"The '{Letter}' character is the {Letter - 64} letter in the English alphabet.";
}

Tavsiye

file erişim belirleyicisi AlphabetLetter türünde kullanılır, çünkü bu tür Program.cs dosyası içinde tanımlanmış ve yalnızca bu dosyadan erişilebilmektedir. Daha fazla bilgi için bkz. dosya (C# Başvurusu). Kaynak kodunun tamamını görmek için Program.cs bölümüne bakın.

Örnek, alfabe harflerini yineleyen bir yardımcı işlev içerir:

static async ValueTask IterateAlphabetAsync(
    Func<char, Task> asyncFunc)
{
    for (char letter = 'A'; letter <= 'Z'; ++letter)
    {
        await asyncFunc(letter);
    }

    Console.WriteLine();
}

Yukarıdaki C# kodunda:

• Func<char, Task> asyncFunc her yinelemede, mevcut letter iletilerek bekleniyor.
• Tüm harfler işlendikten sonra konsola boş bir satır yazılır.

Önbelleğe öğe eklemek için Create veya Set API'lerinden birini çağırın.

var addLettersToCacheTask = IterateAlphabetAsync(letter =>
{
    MemoryCacheEntryOptions options = new()
    {
        AbsoluteExpirationRelativeToNow =
            TimeSpan.FromMilliseconds(MillisecondsAbsoluteExpiration)
    };

    _ = options.RegisterPostEvictionCallback(OnPostEviction);

    AlphabetLetter alphabetLetter =
        cache.Set(
            letter, new AlphabetLetter(letter), options);

    Console.WriteLine($"{alphabetLetter.Letter} was cached.");

    return Task.Delay(
        TimeSpan.FromMilliseconds(MillisecondsDelayAfterAdd));
});
await addLettersToCacheTask;

Yukarıdaki C# kodunda:

• Değişken addLettersToCacheTask'ye devredilir ve IterateAlphabetAsync beklenir.
• Func<char, Task> asyncFunc lambda ile argüman edilir.
• MemoryCacheEntryOptions örneği, şu an itibarıyla mutlak bir son kullanma tarihine sahip olarak oluşturulur.
• Tahliye sonrası geri çağırma işlemi kaydedildi.
• Bir AlphabetLetter nesne örneği oluşturulur ve ve Setile birlikte letter içine options geçirilir.
• Harf konsola önbelleğe alınmış olarak yazılır.
• Son olarak, bir Task.Delay döndürülür.

Alfabedeki her harf için, bir önbellek girdisi bir süre sonu ve çıkarma işlemi sonrasında geri çağırma ile yazılır.

Çıkarma işleminden sonra geri çağırma işlevi, konsola çıkarılan değerin ayrıntılarını yazar.

static void OnPostEviction(
    object key, object? letter, EvictionReason reason, object? state)
{
    if (letter is AlphabetLetter alphabetLetter)
    {
        Console.WriteLine($"{alphabetLetter.Letter} was evicted for {reason}.");
    }
};

Artık önbellek tamamlandığı için başka bir IterateAlphabetAsync çağrısı bekleniyor, ancak bu kez IMemoryCache.TryGetValue çağrısı yapacaksınız:

var readLettersFromCacheTask = IterateAlphabetAsync(letter =>
{
    if (cache.TryGetValue(letter, out object? value) &&
        value is AlphabetLetter alphabetLetter)
    {
        Console.WriteLine($"{letter} is still in cache. {alphabetLetter.Message}");
    }

    return Task.CompletedTask;
});
await readLettersFromCacheTask;

Eğer cache, letter anahtarını içeriyorsa ve value, bir AlphabetLetter örneğiyse, konsola yazdırılır. letter Anahtar önbellekte olmadığında çıkarıldı ve çıkarılma sonrası geri çağırma işlevi tetiklendi.

Ek uzantı yöntemleri

IMemoryCache işlevsellik açısından birçok uzantı yöntemi sunar ve bu yöntemler arasında zaman uyumsuz bir GetOrCreateAsync bulunmaktadır:

• CacheExtensions.Get
• CacheExtensions.GetOrCreate
• CacheExtensions.GetOrCreateAsync
• CacheExtensions.Set
• CacheExtensions.TryGetValue

Hepsini bir araya getirin

Örnek uygulama kaynak kodunun tamamı üst düzey bir programdır ve iki NuGet paketi gerektirir:

• Microsoft.Extensions.Caching.Memory
• Microsoft.Extensions.Hosting

using Microsoft.Extensions.Caching.Memory;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
builder.Services.AddMemoryCache();
using IHost host = builder.Build();

IMemoryCache cache =
    host.Services.GetRequiredService<IMemoryCache>();

const int MillisecondsDelayAfterAdd = 50;
const int MillisecondsAbsoluteExpiration = 750;

static void OnPostEviction(
    object key, object? letter, EvictionReason reason, object? state)
{
    if (letter is AlphabetLetter alphabetLetter)
    {
        Console.WriteLine($"{alphabetLetter.Letter} was evicted for {reason}.");
    }
};

static async ValueTask IterateAlphabetAsync(
    Func<char, Task> asyncFunc)
{
    for (char letter = 'A'; letter <= 'Z'; ++letter)
    {
        await asyncFunc(letter);
    }

    Console.WriteLine();
}

var addLettersToCacheTask = IterateAlphabetAsync(letter =>
{
    MemoryCacheEntryOptions options = new()
    {
        AbsoluteExpirationRelativeToNow =
            TimeSpan.FromMilliseconds(MillisecondsAbsoluteExpiration)
    };

    _ = options.RegisterPostEvictionCallback(OnPostEviction);

    AlphabetLetter alphabetLetter =
        cache.Set(
            letter, new AlphabetLetter(letter), options);

    Console.WriteLine($"{alphabetLetter.Letter} was cached.");

    return Task.Delay(
        TimeSpan.FromMilliseconds(MillisecondsDelayAfterAdd));
});
await addLettersToCacheTask;

var readLettersFromCacheTask = IterateAlphabetAsync(letter =>
{
    if (cache.TryGetValue(letter, out object? value) &&
        value is AlphabetLetter alphabetLetter)
    {
        Console.WriteLine($"{letter} is still in cache. {alphabetLetter.Message}");
    }

    return Task.CompletedTask;
});
await readLettersFromCacheTask;

await host.RunAsync();

file record AlphabetLetter(char Letter)
{
    internal string Message =>
        $"The '{Letter}' character is the {Letter - 64} letter in the English alphabet.";
}

Önbelleğe alınmış girdilerin süresinin sona ermesi ve çıkarılması üzerindeki davranış değişikliklerini gözlemlemek için MillisecondsDelayAfterAdd ve MillisecondsAbsoluteExpiration değerlerini ayarlamaktan çekinmeyin. Aşağıda, bu kodun çalıştırılmasından elde edilen örnek çıkış verilmiştir. .NET olaylarının belirlenimci olmayan yapısı nedeniyle çıkışınız farklı olabilir.

A was cached.
B was cached.
C was cached.
D was cached.
E was cached.
F was cached.
G was cached.
H was cached.
I was cached.
J was cached.
K was cached.
L was cached.
M was cached.
N was cached.
O was cached.
P was cached.
Q was cached.
R was cached.
S was cached.
T was cached.
U was cached.
V was cached.
W was cached.
X was cached.
Y was cached.
Z was cached.

A was evicted for Expired.
C was evicted for Expired.
B was evicted for Expired.
E was evicted for Expired.
D was evicted for Expired.
F was evicted for Expired.
H was evicted for Expired.
K was evicted for Expired.
L was evicted for Expired.
J was evicted for Expired.
G was evicted for Expired.
M was evicted for Expired.
N was evicted for Expired.
I was evicted for Expired.
P was evicted for Expired.
R was evicted for Expired.
O was evicted for Expired.
Q was evicted for Expired.
S is still in cache. The 'S' character is the 19 letter in the English alphabet.
T is still in cache. The 'T' character is the 20 letter in the English alphabet.
U is still in cache. The 'U' character is the 21 letter in the English alphabet.
V is still in cache. The 'V' character is the 22 letter in the English alphabet.
W is still in cache. The 'W' character is the 23 letter in the English alphabet.
X is still in cache. The 'X' character is the 24 letter in the English alphabet.
Y is still in cache. The 'Y' character is the 25 letter in the English alphabet.
Z is still in cache. The 'Z' character is the 26 letter in the English alphabet.

Mutlak süre sonu (MemoryCacheEntryOptions.AbsoluteExpirationRelativeToNow) ayarlandığından, önbelleğe alınan tüm öğeler sonunda çıkarılır.

İşçi Servisi önbellekleme

Verileri önbelleğe almaya yönelik yaygın stratejilerden biri, önbelleği tüketen veri hizmetlerinden bağımsız olarak güncelleştirmektir. Çalışan Hizmeti şablonu, BackgroundService diğer uygulama kodundan bağımsız (veya arka planda) çalıştığından harika bir örnektir. uygulamasını barındıran bir IHostedServiceuygulama çalışmaya başladığında, buna karşılık gelen uygulama (bu örnekte BackgroundService veya "çalışan") aynı işlemde çalışmaya başlar. Bu barındırılan hizmetler, uzantı metoduyla singleton olarak DI'ye AddHostedService<THostedService>(IServiceCollection) kaydedilir. Diğer hizmetler herhangi bir hizmet ömrüyle DI'ye kaydedilebilir.

Önemli

Hizmet ömrünün anlaşılması çok önemlidir. Bellek içi önbelleğe alma hizmetlerinin tümünü kaydetmek için AddMemoryCache çağırdığınızda, hizmetler birer singleton olarak kaydedilir.

Fotoğraf hizmeti senaryosu

HTTP üzerinden erişilebilen üçüncü taraf API'sini kullanan bir fotoğraf hizmeti geliştirdiğinizi düşünün. Bu fotoğraf verileri çok sık değişmez, ancak çok fazladır. Her fotoğraf basit bir record ile temsil edilir:

namespace CachingExamples.Memory;

public readonly record struct Photo(
    int AlbumId,
    int Id,
    string Title,
    string Url,
    string ThumbnailUrl);

Aşağıdaki örnekte, DI'ye kayıtlı birkaç hizmet göreceksiniz. Her hizmetin tek bir sorumluluğu vardır.

using CachingExamples.Memory;

HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);

builder.Services.AddMemoryCache();
builder.Services.AddHttpClient<CacheWorker>();
builder.Services.AddHostedService<CacheWorker>();
builder.Services.AddScoped<PhotoService>();
builder.Services.AddSingleton(typeof(CacheSignal<>));

using IHost host = builder.Build();

await host.StartAsync();

Yukarıdaki C# kodunda:

• Genel konak varsayılan değerlerle oluşturulur.
• Bellek içi önbellek hizmetleri AddMemoryCache olarak kaydedilir.
• HttpClient örneği, CacheWorker ile AddHttpClient<TClient>(IServiceCollection) sınıfı için kaydedilir.
• CacheWorker sınıfı AddHostedService<THostedService>(IServiceCollection) ile kaydedilir.
• PhotoService sınıfı AddScoped<TService>(IServiceCollection) ile kaydedilir.
• CacheSignal<T> sınıfı AddSingleton ile kaydedilir.
• host yapılandırıcıdan oluşturulur ve eşzamanlı olmayan şekilde başlatılır.

PhotoService verilen ölçütlere (veyafilter) uyan fotoğrafları almakla sorumludur:

using Microsoft.Extensions.Caching.Memory;

namespace CachingExamples.Memory;

public sealed class PhotoService(
        IMemoryCache cache,
        CacheSignal<Photo> cacheSignal,
        ILogger<PhotoService> logger)
{
    public async IAsyncEnumerable<Photo> GetPhotosAsync(Func<Photo, bool>? filter = default)
    {
        try
        {
            await cacheSignal.WaitAsync();

            Photo[] photos =
                (await cache.GetOrCreateAsync(
                    "Photos", _ =>
                    {
                        logger.LogWarning("This should never happen!");

                        return Task.FromResult(Array.Empty<Photo>());
                    }))!;

            // If no filter is provided, use a pass-thru.
            filter ??= _ => true;

            foreach (Photo photo in photos)
            {
                if (!default(Photo).Equals(photo) && filter(photo))
                {
                    yield return photo;
                }
            }
        }
        finally
        {
            cacheSignal.Release();
        }
    }
}

Yukarıdaki C# kodunda:

• Oluşturucu bir IMemoryCache, CacheSignal<Photo>ve ILoggergerektirir.
• Yöntemi GetPhotosAsync :
  • Bir Func<Photo, bool> filter parametre tanımlar ve döndürür IAsyncEnumerable<Photo>.
  • Serbest bırakılması için _cacheSignal.WaitAsync() çağrısı yapıp bekler, önbelleğe erişmeden önce önbelleğin doldurulmasını sağlar.
  • _cache.GetOrCreateAsync() çağrısını yapar ve önbellekteki tüm fotoğrafları zaman uyumsuz bir şekilde alır.
  • factory argümanı bir uyarı kaydediyor ve boş bir fotoğraf dizisi döndürüyor; bu asla olmamalıdır.
  • Önbellekteki her fotoğraf tek tek işlenir, filtrelenir ve yield return ile somutlaştırılır.
  • Son olarak önbellek sinyali sıfırlanır.

Bu hizmetin tüketicileri, GetPhotosAsync yöntemini çağırmak ve fotoğrafları buna göre işlemek için serbesttir. Önbellek fotoğrafları içerdiğinden hayır HttpClient gerekli değildir.

Zaman uyumsuz sinyal, genel tür kısıtlamalı tekil bir örnek içinde kapsüllenmiş SemaphoreSlim örneğine dayanır. CacheSignal<T> bir örneğine dayanan SemaphoreSlim üzerinde çalışır.

namespace CachingExamples.Memory;

public sealed class CacheSignal<T>
{
    private readonly SemaphoreSlim _semaphore = new(1, 1);

    /// <summary>
    /// Exposes a <see cref="Task"/> that represents the asynchronous wait operation.
    /// When signaled (consumer calls <see cref="Release"/>), the 
    /// <see cref="Task.Status"/> is set as <see cref="TaskStatus.RanToCompletion"/>.
    /// </summary>
    public Task WaitAsync() => _semaphore.WaitAsync();

    /// <summary>
    /// Exposes the ability to signal the release of the <see cref="WaitAsync"/>'s operation.
    /// Callers who were waiting, will be able to continue.
    /// </summary>
    public void Release() => _semaphore.Release();
}

Yukarıdaki C# kodunda, dekoratör deseni bir örneğini SemaphoreSlimsarmak için kullanılır. CacheSignal<T> tekil olarak kaydedildiğinden, tüm hizmet ömrü boyunca herhangi bir genel türle (bu örnekte, Photo) kullanılabilir. Önbelleğin tohumlama işleminin sinyalini verme sorumluluğundadır.

CacheWorker, BackgroundService sınıfının bir alt sınıfıdır:

using System.Net.Http.Json;
using Microsoft.Extensions.Caching.Memory;

namespace CachingExamples.Memory;

public sealed class CacheWorker(
    ILogger<CacheWorker> logger,
    HttpClient httpClient,
    CacheSignal<Photo> cacheSignal,
    IMemoryCache cache) : BackgroundService
{
    private readonly TimeSpan _updateInterval = TimeSpan.FromHours(3);

    private bool _isCacheInitialized = false;

    private const string Url = "https://jsonplaceholder.typicode.com/photos";

    public override async Task StartAsync(CancellationToken cancellationToken)
    {
        await cacheSignal.WaitAsync();
        await base.StartAsync(cancellationToken);
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (!stoppingToken.IsCancellationRequested)
        {
            logger.LogInformation("Updating cache.");

            try
            {
                Photo[]? photos =
                    await httpClient.GetFromJsonAsync<Photo[]>(
                        Url, stoppingToken);

                if (photos is { Length: > 0 })
                {
                    cache.Set("Photos", photos);
                    logger.LogInformation(
                        "Cache updated with {Count:#,#} photos.", photos.Length);
                }
                else
                {
                    logger.LogWarning(
                        "Unable to fetch photos to update cache.");
                }
            }
            finally
            {
                if (!_isCacheInitialized)
                {
                    cacheSignal.Release();
                    _isCacheInitialized = true;
                }
            }

            try
            {
                logger.LogInformation(
                    "Will attempt to update the cache in {Hours} hours from now.",
                    _updateInterval.Hours);

                await Task.Delay(_updateInterval, stoppingToken);
            }
            catch (OperationCanceledException)
            {
                logger.LogWarning("Cancellation acknowledged: shutting down.");
                break;
            }
        }
    }
}

Yukarıdaki C# kodunda:

• Oluşturucu bir ILogger, HttpClientve IMemoryCachegerektirir.
• _updateInterval üç saat için tanımlanır.
• Yöntemi ExecuteAsync :
  • Uygulama çalışırken döngüler.
  • "https://jsonplaceholder.typicode.com/photos" için bir HTTP isteği yapar ve yanıtı Photo objeleri olarak eşler.
  • Fotoğraf dizisi, IMemoryCache'da "Photos" anahtarının altında yerleştirilir.
  • _cacheSignal.Release() çağrılır ve sinyali bekleyen tüm tüketiciler serbest bırakılır.
  • Çağrı Task.Delay, güncelleme aralığına göre bekleniyor.
  • Üç saat geciktirildikten sonra önbellek yeniden güncelleştirilir.

Aynı süreçteki tüketiciler IMemoryCache fotoğrafları isteyebilir, ancak önbelleği güncellemekten sorumlu olan CacheWorker'dır.

Dağıtık önbellekleme

Bazı senaryolarda, birden çok uygulama sunucusu için olduğu gibi dağıtılmış önbellek gerekir. Dağıtılmış önbellek, bellek içi önbelleğe alma yaklaşımından daha yüksek ölçek genişletmeyi destekler. Dağıtılmış önbellek kullanmak, önbellek belleğini harici bir sürece aktarır, ancak ek ağ G/Ç gerektirir ve biraz daha fazla gecikme süresi (nominal olsa bile) ortaya çıkarır.

Dağıtılmış önbelleğe alma soyutlamaları NuGet paketinin Microsoft.Extensions.Caching.Memory bir parçasıdır ve bir AddDistributedMemoryCache uzantı yöntemi bile vardır.

Dikkat

yalnızca AddDistributedMemoryCache geliştirme ve/veya test senaryolarında kullanılmalıdır ve uygulanabilir bir üretim uygulaması değildir .

Aşağıdaki paketlerden herhangi bir kullanılabilir uygulamasını IDistributedCache göz önünde bulundurun:

• Microsoft.Extensions.Caching.SqlServer
• Microsoft.Extensions.Caching.StackExchangeRedis
• NCache.Microsoft.Extensions.Caching.OpenSource

Dağıtılmış önbelleğe alma API'si

Dağıtılmış önbelleğe alma API'leri, bellek içi önbelleğe alma API'lerinden biraz daha temeldir. Anahtar-değer çiftleri biraz daha temeldir. Bellek içi önbelleğe alma anahtarları bir objecttabanlıyken, dağıtılmış anahtarlar bir string'dır. Bellek içi önbelleğe alma ile, değer kesin türde bir genel değer olabilirken, dağıtılmış önbelleğe almadaki değerler byte[] olarak saklanır. Bu, çeşitli uygulamaların kesin olarak belirlenmiş genel değerleri kullanıma sunmadığını söylemek değildir, ancak bu bir uygulama ayrıntısıdır.

Değer oluşturma

Dağıtılmış önbellekte değer oluşturmak için ayarlanan API'lerden birini çağırın:

• IDistributedCache.SetAsync
• IDistributedCache.Set

Bellek içi önbellek örneğindeki AlphabetLetter kaydını kullanarak, nesneyi JSON olarak serileştirip string'yi byte[] olarak kodlayabilirsiniz.

DistributedCacheEntryOptions options = new()
{
    AbsoluteExpirationRelativeToNow =
        TimeSpan.FromMilliseconds(MillisecondsAbsoluteExpiration)
};

AlphabetLetter alphabetLetter = new(letter);
string json = JsonSerializer.Serialize(alphabetLetter);
byte[] bytes = Encoding.UTF8.GetBytes(json);

await cache.SetAsync(letter.ToString(), bytes, options);

Bellek içi önbellekleme gibi önbellek girişleri de önbellekte varlıklarının ince bir şekilde ayarlanmasına yardımcı olacak seçeneklere sahip olabilir. Bu durumda DistributedCacheEntryOptions.

Uzantı yöntemleri oluşturma

string temsillerini bir byte[] içine kodlamaktan kaçınmaya yardımcı olan, değerler oluşturmak için birkaç kullanışlı uzantı yöntemi vardır.

• DistributedCacheExtensions.SetStringAsync
• DistributedCacheExtensions.SetString

Değerleri okuma

Dağıtılmış önbellekteki değerleri okumak için get API'lerinden birini çağırın:

• IDistributedCache.GetAsync
• IDistributedCache.Get

AlphabetLetter? alphabetLetter = null;
byte[]? bytes = await cache.GetAsync(letter.ToString());
if (bytes is { Length: > 0 })
{
    string json = Encoding.UTF8.GetString(bytes);
    alphabetLetter = JsonSerializer.Deserialize<AlphabetLetter>(json);
}

Önbellek girdisi önbellekten okunduktan sonra, UTF8 kodlamalı string gösterimini byte[] alabilirsiniz.

Uzantı yöntemlerini inceleme

Okuma değerleri için nesnelerin temsillerine kod çözmeyi byte[]string önlemeye yardımcı olan birkaç kolaylık tabanlı uzantı yöntemi vardır:

• DistributedCacheExtensions.GetStringAsync
• DistributedCacheExtensions.GetString

Değerleri güncelleştirme

Dağıtılmış önbellekteki değerleri tek bir API çağrısıyla güncelleştirmenin bir yolu yoktur; bunun yerine, değerlerin kayan süre sonu değerleri yenileme API'lerinden biriyle sıfırlanabilir:

• IDistributedCache.RefreshAsync
• IDistributedCache.Refresh

Gerçek değerin güncelleştirilmesi gerekiyorsa, değeri silip yeniden eklemeniz gerekir.

Değerleri silme

Dağıtılmış önbellekteki değerleri silmek için kaldırma API'lerinden birini çağırın:

• IDistributedCache.RemoveAsync
• IDistributedCache.Remove

Tavsiye

Yukarıda belirtilen API'lerin zaman uyumlu sürümleri olsa da, dağıtılmış önbellek uygulamalarının ağ G/Ç'sine bağlı olduğunu göz önünde bulundurun. Bu nedenle, zaman uyumsuz API'lerin kullanılması daha sık tercih edilir.

Ayrıca bakınız

• .NET'te bağımlılık ekleme
• .NET Genel Sunucu
• .NET'te Çalışan Hizmetleri
• .NET geliştiricileri için Azure
• ASP.NET Core'da bellek içi önbellek
• ASP.NET Core'da dağıtılmış önbelleğe alma