Distribuované ukládání do mezipaměti v ASP.NET Core

Článek
09/13/2021
9 min ke čtení

Distribuovaná mezipaměť je mezipaměť, kterou sdílí víc aplikačních serverů, obvykle se udržuje jako externí služba pro aplikační servery, které k ní přistupují. distribuovaná mezipaměť může zlepšit výkon a škálovatelnost aplikace ASP.NET Core, zejména v případě, že je aplikace hostována cloudovou službou nebo serverovou farmou.

Distribuovaná mezipaměť má několik výhod oproti jiným scénářům ukládání do mezipaměti, kdy se data uložená v mezipaměti ukládají na jednotlivé aplikační servery.

Když jsou data v mezipaměti distribuována, data:

Je souvislý (konzistentní) mezi požadavky na více serverů.
Zachová se restarty serveru a nasazení aplikací.
Nepoužívá místní paměť.

Konfigurace distribuované mezipaměti je specifická pro implementaci. tento článek popisuje, jak nakonfigurovat SQL Server a Redis distribuované mezipaměti. K dispozici jsou také implementace třetích stran, například NCache (NCache na GitHub). Bez ohledu na to, která implementace je vybraná, aplikace komunikuje s mezipamětí pomocí IDistributedCache rozhraní.

Zobrazit nebo stáhnout ukázkový kód (Jak stáhnout)

Požadavky

pokud chcete použít SQL Server distribuovanou mezipaměť, přidejte odkaz na balíček do Microsoft. extensions. Ukládání do mezipaměti. Balíček SqlServer .

pokud chcete použít distribuovanou mezipaměť Redis, přidejte odkaz na balíček do Microsoft. extensions. Ukládání do mezipaměti. Balíček StackExchangeRedis

chcete-li použít distribuovanou mezipaměť NCache, přidejte odkaz na balíček do NCache. Microsoft. extensions. Ukládání do mezipaměti. Balíček OpenSource

Rozhraní IDistributedCache

IDistributedCacheRozhraní poskytuje následující metody pro manipulaci s položkami v implementaci distribuované mezipaměti:

Get, GetAsync : Přijme klíč řetězce a načte položku uloženou v mezipaměti jako byte[] pole, pokud je v mezipaměti nalezeno.
Set, SetAsync : Přidá položku (jako byte[] pole) do mezipaměti pomocí klíče řetězce.
Refresh, RefreshAsync : Aktualizuje položku v mezipaměti na základě jejího klíče a resetuje časový limit klouzavého vypršení platnosti (pokud existuje).
Remove, RemoveAsync : Odebere položku mezipaměti na základě jejího řetězcového klíče.

Vytvoření služby distribuované mezipaměti

Zaregistrujte implementaci IDistributedCache v Startup.ConfigureServices . Implementace implementované v tomto tématu zahrnuje:

Mezipaměť distribuované paměti
distribuovaná mezipaměť SQL Server
Distribuovaná mezipaměť Redis
Distribuovaná mezipaměť NCache

Mezipaměť distribuované paměti

Mezipaměť distribuované paměti ( AddDistributedMemoryCache ) je implementací rozhraní IDistributedCache , které ukládá položky v paměti. Mezipaměť distribuované paměti není skutečnou distribuovanou mezipamětí. Položky uložené v mezipaměti jsou uloženy instancí aplikace na serveru, na kterém je aplikace spuštěná.

Mezipaměť distribuované paměti je užitečnou implementací:

Ve scénářích vývoje a testování.
Pokud se jeden server používá v produkčním prostředí a spotřeba paměti není problém. Implementace vydaných mezipamětí mezipaměti úložiště dat v mezipaměti. Umožňuje implementaci skutečného distribuovaného řešení pro ukládání do mezipaměti v budoucnu, pokud je potřeba několik uzlů nebo odolnost proti chybám.

Ukázková aplikace využívá mezipaměť distribuované paměti při spuštění aplikace ve vývojovém prostředí v nástroji Startup.ConfigureServices :

services.AddDistributedMemoryCache();

distribuovaná mezipaměť SQL Server

distributed SQL Server Cache implementation ( AddDistributedSqlServerCache ) umožňuje distribuované mezipaměti používat jako záložní úložiště databázi SQL Server. chcete-li vytvořit tabulku položek SQL Server v mezipaměti v instanci SQL Server, můžete použít sql-cache nástroj. Nástroj vytvoří tabulku se zadaným názvem a schématem.

vytvořte tabulku v SQL Server spuštěním sql-cache create příkazu. zadejte instanci SQL Server ( Data Source ), databázi ( Initial Catalog ), schéma (například dbo ) a název tabulky (například TestCache ):

dotnet sql-cache create "Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Zpráva, která označuje, že nástroj byl úspěšný, je zaznamenána do protokolu:

Table and index were created successfully.

Tabulka vytvořená sql-cache nástrojem má následující schéma:

Tabulka mezipaměti SqlServer

Poznámka

Aplikace by měla manipulovat s hodnotami mezipaměti pomocí instance IDistributedCache , nikoli SqlServerCache .

Ukázková aplikace implementuje SqlServerCache v prostředí bez vývoje Startup.ConfigureServices :

services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = 
        _config["DistCache_ConnectionString"];
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Poznámka

A ConnectionString (a volitelně SchemaName a TableName ) se obvykle ukládají mimo správu zdrojového kódu (například uložené správcem tajných klíčů nebo v appsettings.json / appSettings. { ENVIRONMENT}. JSON soubory. Připojovací řetězec může obsahovat přihlašovací údaje, které by měly být zachovány ze systémů správy zdrojového kódu.

Distribuované Redis Cache

Redis je open source úložiště dat v paměti, které se často používá jako distribuovaná mezipaměť. můžete nakonfigurovat Azure Redis Cache pro aplikaci hostovanou v Azure ASP.NET Core a použít Azure Redis Cache pro místní vývoj.

Aplikace konfiguruje implementaci mezipaměti pomocí RedisCache instance ( AddStackExchangeRedisCache ).

Vytvořte službu Azure cache pro Redis.
Zkopírujte primární připojovací řetězec (StackExchange. Redis) do Konfigurace.
- Místní vývoj: uložte připojovací řetězec pomocí správce tajných klíčů.
- Azure: uložte připojovací řetězec v konfiguraci App Service nebo jiném zabezpečeném úložišti.

Následující kód povoluje mezipaměť Azure pro Redis:

public void ConfigureServices(IServiceCollection services)
{
    if (_hostContext.IsDevelopment())
    {
        services.AddDistributedMemoryCache();
    }
    else
    {
        services.AddStackExchangeRedisCache(options =>
        {
            options.Configuration = _config["MyRedisConStr"];
            options.InstanceName = "SampleInstance";
        });
    }

    services.AddRazorPages();
}

Předchozí kód předpokládá, že primární připojovací řetězec (StackExchange. Redis) byl uložen v konfiguraci s názvem klíče MyRedisConStr .

Další informace najdete v článku, který se věnuje službě Azure Cache for Redis.

v tomto GitHub problému najdete diskuzi o alternativních přístupech k místní mezipaměti Redis.

Distribuovaná mezipaměť NCache

NCache je open source distribuovaná mezipaměť v paměti vyvinutá nativně v rozhraní .NET a .NET Core. NCache funguje místně i nakonfigurovaná jako cluster distribuovaných mezipamětí pro ASP.NET Core aplikaci běžící v Azure nebo na jiných hostujících platformách.

pokud chcete nainstalovat a nakonfigurovat NCache na místním počítači, přečtěte si téma Začínáme příručka pro Windows (.net a .net Core).

Konfigurace NCache:

Nainstalovat NCache open source NuGet.
Nakonfigurujte cluster mezipaměti v Client. ncconf.

Do souboru Startup.ConfigureServices přidejte následující kód:

services.AddNCacheDistributedCache(configuration =>    
{        
    configuration.CacheName = "demoClusteredCache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Použít distribuovanou mezipaměť

Chcete-li použít IDistributedCache rozhraní, vyžádejte si instanci IDistributedCache z libovolného konstruktoru v aplikaci. Instance je poskytována vložením závislosti (di).

Po spuštění ukázkové aplikace je vložena IDistributedCache do Startup.Configure . Aktuální čas je uložen v mezipaměti pomocí IHostApplicationLifetime (Další informace najdete v tématu Generic host: IHostApplicationLifetime):

public void Configure(IApplicationBuilder app, IWebHostEnvironment env, 
    IHostApplicationLifetime lifetime, IDistributedCache cache)
{
    lifetime.ApplicationStarted.Register(() =>
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        cache.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
    });

Ukázková aplikace se vloží IDistributedCache do IndexModel pro použití stránkou indexu.

Pokaždé, když je načtena stránka indexu, je v mezipaměti kontrolována doba uložená v mezipaměti OnGetAsync . Pokud doba v mezipaměti nevypršela, zobrazí se čas. Pokud uplynula 20 sekund od poslední posledního přistupu k době ukládání do mezipaměti (při poslední načtení této stránky), stránka zobrazuje časový limit v mezipaměti.

Okamžitě aktualizovat čas uložený v mezipaměti na aktuální čas výběrem tlačítka obnovit čas v mezipaměti . Tlačítko aktivuje OnPostResetCachedTime metodu obslužné rutiny.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string CachedTimeUTC { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Poznámka

Pro instance není nutné používat singleton nebo vymezenou dobu života IDistributedCache (alespoň pro předdefinované implementace).

Můžete také vytvořit IDistributedCache instanci, kdykoli budete možná potřebovat místo použití di, ale vytvoření instance v kódu může ztížit testování a porušování explicitních závislostí.

Doporučení

Při rozhodování, která implementace nástroje IDistributedCache je pro vaši aplikaci nejvhodnější, vezměte v úvahu následující skutečnosti:

Stávající infrastruktura
Požadavky na výkon
Náklady
Prostředí týmu

Ukládání do mezipaměti řešení obvykle spoléhají na úložiště v paměti, které poskytuje rychlé načítání dat uložených v mezipaměti, ale paměť je omezeným prostředkem a je nákladná k rozšíření. Ukládat běžně používaná data do mezipaměti.

obecně platí, že mezipaměť Redis poskytuje vyšší propustnost a nižší latenci než mezipaměť SQL Server. Srovnávací testy se ale obvykle vyžadují k určení charakteristik výkonu pro strategie ukládání do mezipaměti.

když se SQL Server používá jako úložiště zálohování distribuované mezipaměti, použití stejné databáze pro mezipaměť a běžné ukládání a načítání dat aplikace může negativně ovlivnit výkon obou. pro úložiště záloh distribuované mezipaměti doporučujeme použít vyhrazenou instanci SQL Server.

Další zdroje informací

Distribuovaná mezipaměť má několik výhod oproti jiným scénářům ukládání do mezipaměti, kdy se data uložená v mezipaměti ukládají na jednotlivé aplikační servery.

Když jsou data v mezipaměti distribuována, data:

Je souvislý (konzistentní) mezi požadavky na více serverů.
Zachová se restarty serveru a nasazení aplikací.
Nepoužívá místní paměť.

Zobrazit nebo stáhnout ukázkový kód (Jak stáhnout)

Požadavky

pokud chcete použít SQL Server distribuovanou mezipaměť, odkazujte na metapackage Microsoft.AspNetCore.App nebo přidejte odkaz na balíček do Microsoft. extensions. Ukládání do mezipaměti. Balíček SqlServer .

pokud chcete použít distribuovanou mezipaměť Redis, odkazujte na Microsoft.AspNetCore.App metapackage a přidejte odkaz na balíček do Microsoft. extensions. Ukládání do mezipaměti. Balíček StackExchangeRedis Balíček Redis není součástí Microsoft.AspNetCore.App balíčku, takže musíte odkazovat na balíček Redis samostatně v souboru projektu.

pokud chcete použít distribuovanou mezipaměť NCache, odkazujte na Microsoft.AspNetCore.App metapackage a přidejte odkaz na balíček do NCache. Microsoft. extensions. Ukládání do mezipaměti. Balíček OpenSource Balíček NCache není součástí Microsoft.AspNetCore.App balíčku, takže musíte odkazovat na balíček NCache samostatně v souboru projektu.

Rozhraní IDistributedCache

IDistributedCacheRozhraní poskytuje následující metody pro manipulaci s položkami v implementaci distribuované mezipaměti:

Get, GetAsync : Přijme klíč řetězce a načte položku uloženou v mezipaměti jako byte[] pole, pokud je v mezipaměti nalezeno.
Set, SetAsync : Přidá položku (jako byte[] pole) do mezipaměti pomocí klíče řetězce.
Refresh, RefreshAsync : Aktualizuje položku v mezipaměti na základě jejího klíče a resetuje časový limit klouzavého vypršení platnosti (pokud existuje).
Remove, RemoveAsync : Odebere položku mezipaměti na základě jejího řetězcového klíče.

Vytvoření služby distribuované mezipaměti

Zaregistrujte implementaci IDistributedCache v Startup.ConfigureServices . Implementace implementované v tomto tématu zahrnuje:

Mezipaměť distribuované paměti
distribuovaná mezipaměť SQL Server
Distribuovaná mezipaměť Redis
Distribuovaná mezipaměť NCache

Mezipaměť distribuované paměti

Mezipaměť distribuované paměti je užitečnou implementací:

Ve scénářích vývoje a testování.
Pokud se jeden server používá v produkčním prostředí a spotřeba paměti není problém. Implementace vydaných mezipamětí mezipaměti úložiště dat v mezipaměti. Umožňuje implementaci skutečného distribuovaného řešení pro ukládání do mezipaměti v budoucnu, pokud je potřeba několik uzlů nebo odolnost proti chybám.

Ukázková aplikace využívá mezipaměť distribuované paměti při spuštění aplikace ve vývojovém prostředí v nástroji Startup.ConfigureServices :

services.AddDistributedMemoryCache();

distribuovaná mezipaměť SQL Server

dotnet sql-cache create "Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Zpráva, která označuje, že nástroj byl úspěšný, je zaznamenána do protokolu:

Table and index were created successfully.

Tabulka vytvořená sql-cache nástrojem má následující schéma:

Tabulka mezipaměti SqlServer

Poznámka

Aplikace by měla manipulovat s hodnotami mezipaměti pomocí instance IDistributedCache , nikoli SqlServerCache .

Ukázková aplikace implementuje SqlServerCache v prostředí bez vývoje Startup.ConfigureServices :

services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = 
        _config["DistCache_ConnectionString"];
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Poznámka

Distribuované Redis Cache

Redis je open source úložiště dat v paměti, které se často používá jako distribuovaná mezipaměť. Redis můžete použít místně a můžete nakonfigurovat Azure Redis Cache pro aplikace ASP.NET Core hostované pro Azure.

Aplikace konfiguruje implementaci mezipaměti pomocí RedisCache instance ( AddStackExchangeRedisCache ) v nevývojovém prostředí v Startup.ConfigureServices :

services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = "localhost";
    options.InstanceName = "SampleInstance";
});

Instalace Redis na místní počítač:

Nainstalujte balíček Redis pro čokolády.
Spusťte redis-server z příkazového řádku.

Distribuovaná mezipaměť NCache

pokud chcete nainstalovat a nakonfigurovat NCache na místním počítači, přečtěte si téma Začínáme příručka pro Windows (.net a .net Core).

Konfigurace NCache:

Nainstalovat NCache open source NuGet.
Nakonfigurujte cluster mezipaměti v Client. ncconf.

Do souboru Startup.ConfigureServices přidejte následující kód:

services.AddNCacheDistributedCache(configuration =>    
{        
    configuration.CacheName = "demoClusteredCache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Použít distribuovanou mezipaměť

Chcete-li použít IDistributedCache rozhraní, vyžádejte si instanci IDistributedCache z libovolného konstruktoru v aplikaci. Instance je poskytována vložením závislosti (di).

Po spuštění ukázkové aplikace je vložena IDistributedCache do Startup.Configure . Aktuální čas je uložen v mezipaměti s použitím IApplicationLifetime (Další informace najdete v tématu webový hostitel: rozhraní IApplicationLifetime):

public void Configure(IApplicationBuilder app, IHostingEnvironment env, 
    IApplicationLifetime lifetime, IDistributedCache cache)
{
    lifetime.ApplicationStarted.Register(() =>
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        cache.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
    });

Ukázková aplikace se vloží IDistributedCache do IndexModel pro použití stránkou indexu.

Okamžitě aktualizovat čas uložený v mezipaměti na aktuální čas výběrem tlačítka obnovit čas v mezipaměti . Tlačítko aktivuje OnPostResetCachedTime metodu obslužné rutiny.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string CachedTimeUTC { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Poznámka

Pro instance není nutné používat singleton nebo vymezenou dobu života IDistributedCache (alespoň pro předdefinované implementace).

Doporučení

Při rozhodování, která implementace nástroje IDistributedCache je pro vaši aplikaci nejvhodnější, vezměte v úvahu následující skutečnosti:

Stávající infrastruktura
Požadavky na výkon
Náklady
Prostředí týmu

Další zdroje informací

Distribuovaná mezipaměť má několik výhod oproti jiným scénářům ukládání do mezipaměti, kdy se data uložená v mezipaměti ukládají na jednotlivé aplikační servery.

Když jsou data v mezipaměti distribuována, data:

Je souvislý (konzistentní) mezi požadavky na více serverů.
Zachová se restarty serveru a nasazení aplikací.
Nepoužívá místní paměť.

Zobrazit nebo stáhnout ukázkový kód (Jak stáhnout)

Požadavky

pokud chcete použít distribuovanou mezipaměť Redis, odkazujte na Microsoft.AspNetCore.App metapackage a přidejte odkaz na balíček do Microsoft. extensions. Ukládání do mezipaměti. Balíček Redis Balíček Redis není součástí Microsoft.AspNetCore.App balíčku, takže musíte odkazovat na balíček Redis samostatně v souboru projektu.

Rozhraní IDistributedCache

IDistributedCacheRozhraní poskytuje následující metody pro manipulaci s položkami v implementaci distribuované mezipaměti:

Get, GetAsync : Přijme klíč řetězce a načte položku uloženou v mezipaměti jako byte[] pole, pokud je v mezipaměti nalezeno.
Set, SetAsync : Přidá položku (jako byte[] pole) do mezipaměti pomocí klíče řetězce.
Refresh, RefreshAsync : Aktualizuje položku v mezipaměti na základě jejího klíče a resetuje časový limit klouzavého vypršení platnosti (pokud existuje).
Remove, RemoveAsync : Odebere položku mezipaměti na základě jejího řetězcového klíče.

Vytvoření služby distribuované mezipaměti

Zaregistrujte implementaci IDistributedCache v Startup.ConfigureServices . Implementace implementované v tomto tématu zahrnuje:

Mezipaměť distribuované paměti
distribuovaná mezipaměť SQL Server
Distribuovaná mezipaměť Redis
Distribuovaná mezipaměť NCache

Mezipaměť distribuované paměti

Mezipaměť distribuované paměti je užitečnou implementací:

Ve scénářích vývoje a testování.
Pokud se jeden server používá v produkčním prostředí a spotřeba paměti není problém. Implementace vydaných mezipamětí mezipaměti úložiště dat v mezipaměti. Umožňuje implementaci skutečného distribuovaného řešení pro ukládání do mezipaměti v budoucnu, pokud je potřeba několik uzlů nebo odolnost proti chybám.

Ukázková aplikace využívá mezipaměť distribuované paměti při spuštění aplikace ve vývojovém prostředí v nástroji Startup.ConfigureServices :

services.AddDistributedMemoryCache();

distribuovaná mezipaměť SQL Server

dotnet sql-cache create "Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Zpráva, která označuje, že nástroj byl úspěšný, je zaznamenána do protokolu:

Table and index were created successfully.

Tabulka vytvořená sql-cache nástrojem má následující schéma:

Tabulka mezipaměti SqlServer

Poznámka

Aplikace by měla manipulovat s hodnotami mezipaměti pomocí instance IDistributedCache , nikoli SqlServerCache .

Ukázková aplikace implementuje SqlServerCache v prostředí bez vývoje Startup.ConfigureServices :

services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = 
        _config["DistCache_ConnectionString"];
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Poznámka

Distribuované Redis Cache

Aplikace konfiguruje implementaci mezipaměti pomocí RedisCache instance ( AddDistributedRedisCache ):

services.AddDistributedRedisCache(options =>
{
    options.Configuration = "localhost";
    options.InstanceName = "SampleInstance";
});

Instalace Redis na místní počítač:

Nainstalujte balíček Redis pro čokolády.
Spusťte redis-server z příkazového řádku.

Distribuovaná mezipaměť NCache

pokud chcete nainstalovat a nakonfigurovat NCache na místním počítači, přečtěte si téma Začínáme příručka pro Windows (.net a .net Core).

Konfigurace NCache:

Nainstalovat NCache open source NuGet.
Nakonfigurujte cluster mezipaměti v Client. ncconf.

Do souboru Startup.ConfigureServices přidejte následující kód:

services.AddNCacheDistributedCache(configuration =>    
{        
    configuration.CacheName = "demoClusteredCache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Použít distribuovanou mezipaměť

Chcete-li použít IDistributedCache rozhraní, vyžádejte si instanci IDistributedCache z libovolného konstruktoru v aplikaci. Instance je poskytována vložením závislosti (di).

public void Configure(IApplicationBuilder app, IHostingEnvironment env, 
    IApplicationLifetime lifetime, IDistributedCache cache)
{
    lifetime.ApplicationStarted.Register(() =>
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        cache.Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
    });

Ukázková aplikace se vloží IDistributedCache do IndexModel pro použití stránkou indexu.

Okamžitě aktualizovat čas uložený v mezipaměti na aktuální čas výběrem tlačítka obnovit čas v mezipaměti . Tlačítko aktivuje OnPostResetCachedTime metodu obslužné rutiny.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string CachedTimeUTC { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Poznámka

Pro instance není nutné používat singleton nebo vymezenou dobu života IDistributedCache (alespoň pro předdefinované implementace).

Doporučení

Při rozhodování, která implementace nástroje IDistributedCache je pro vaši aplikaci nejvhodnější, vezměte v úvahu následující skutečnosti:

Stávající infrastruktura
Požadavky na výkon
Náklady
Prostředí týmu

Distribuované ukládání do mezipaměti v ASP.NET Core

Ohodnoťte vaše zkušenosti

Požadavky

Rozhraní IDistributedCache

Vytvoření služby distribuované mezipaměti

Mezipaměť distribuované paměti

distribuovaná mezipaměť SQL Server

Distribuované Redis Cache

Distribuovaná mezipaměť NCache

Použít distribuovanou mezipaměť

Doporučení

Další zdroje informací

Požadavky

Rozhraní IDistributedCache

Vytvoření služby distribuované mezipaměti

Mezipaměť distribuované paměti

distribuovaná mezipaměť SQL Server

Distribuované Redis Cache

Distribuovaná mezipaměť NCache

Použít distribuovanou mezipaměť

Doporučení

Další zdroje informací

Požadavky

Rozhraní IDistributedCache

Vytvoření služby distribuované mezipaměti

Mezipaměť distribuované paměti

distribuovaná mezipaměť SQL Server

Distribuované Redis Cache

Distribuovaná mezipaměť NCache

Použít distribuovanou mezipaměť

Doporučení

Další zdroje informací