ASP.NET Core-tillståndshantering Blazor på serversidan

Kretstillståndsbeständighet

Under återgivning Blazor Web Apppå serversidan kan s bevara en användares sessionstillstånd (krets) när anslutningen till servern går förlorad under en längre tid eller proaktivt pausas, så länge en helsidesuppdatering inte utlöses. Detta gör att användarna kan återuppta sin session utan att förlora arbete som inte har sparats i följande scenarier:

• Begränsning av webbläsarflik
• Användare av mobila enheter som byter appar
• Nätverksavbrott
• Proaktiv resurshantering (att pausa inaktiva kretsar)
• Utökad navigering

Serverresurser kan frigöras om kretstillståndet kan bevaras och sedan återupptas senare:

• Även om den är frånkopplad kan en krets fortsätta att utföra arbete och förbruka PROCESSOR, minne och andra resurser. Beständiga tillstånd förbrukar bara en fast mängd minne som utvecklaren styr.
• Beständiga tillstånd representerar en delmängd av det minne som förbrukas av appen, så servern krävs inte för att hålla reda på appens komponenter och andra objekt på serversidan.

Tillståndet sparas i två scenarier:

• Komponenttillstånd: Tillstånd som komponenter använder för interaktiv serverrendering, till exempel en lista över objekt som hämtats från databasen eller ett formulär som användaren fyller i.
• Tjänster med begränsat omfång: Tillstånd som hanteras inom en tjänst på serversidan, till exempel den nuvarande användaren.

Tillstånd:

• Funktionen är endast effektiv för interaktiv serverrendering.
• Om användaren uppdaterar sidan (appen) går det bevarade tillståndet förlorat.
• Tillståndet måste vara JSON-serialiserbart. Cykliska referenser eller ORM-entiteter kanske inte serialiseras korrekt.
• Använd @key för unikhet vid återgivning av komponenter i en loop för att undvika nyckelkonflikter.
• Bevara endast nödvändigt tillstånd. Lagring av överdrivna data kan påverka prestanda.
• Ingen automatisk viloläge. Du måste uttryckligen anmäla dig och konfigurera tillståndspersistens.
• Ingen garanti för återställning. Om lagringen av tillstånd misslyckas återgår appen till standardupplevelsen för frånkoppling.

Tillståndspersistens är aktiverad som standard när AddInteractiveServerComponents anropas på AddRazorComponents i Program-filen. MemoryCache är standardimplementeringen av lagring för enskilda appinstanser och lagrar upp till 1 000 bevarade kretsar i två timmar, vilket kan konfigureras.

Använd följande alternativ för att ändra standardvärdena för den minnesinterna providern:

• PersistedCircuitInMemoryMaxRetained ({CIRCUIT COUNT} platshållare): Det maximala antalet kretsar som ska behållas. Standardvärdet är 1 000 kretsar. Använd till exempel 2000 för att behålla tillståndet för upp till 2 000 kretsar.
• PersistedCircuitInMemoryRetentionPeriod ({RETENTION PERIOD} platshållare): Den maximala kvarhållningsperioden som en TimeSpan. Standardvärdet är två timmar. Använd till exempel TimeSpan.FromHours(3) för en kvarhållningsperiod på tre timmar.

services.Configure<CircuitOptions>(options =>
{
    options.PersistedCircuitInMemoryMaxRetained = {CIRCUIT COUNT};
    options.PersistedCircuitInMemoryRetentionPeriod = {RETENTION PERIOD};
});

Beständigt komponenttillstånd mellan kretsar bygger på det befintliga PersistentComponentState API:et, som fortsätter att bevara tillståndet för förrenderade komponenter som använder ett interaktivt återgivningsläge. Mer information finns i ASP.NET coreprerendered Blazor state persistence.

[OBS] Beständig lagring av komponenttillstånd för prerendering fungerar för alla interaktiva återgivningslägen, men lagring av kretstillstånd fungerar bara för återgivningsläget Interaktiv server.

Kommentera komponentegenskaper med [PersistentState] för att aktivera beständighet för kretstillstånd. I följande exempel mappas objekten med direktivattributet@key för att ge en unik identifierare för varje komponentinstans.

@foreach (var item in Items)
{
    <ItemDisplay @key="@($"unique-prefix-{item.Id}")" Item="item" />
}

@code {
    [PersistentState]
    public List<Item> Items { get; set; }

    protected override async Task OnInitializedAsync()
    {
        Items ??= await LoadItemsAsync();
    }
}

Om du vill spara tillstånd för begränsade tjänster kommenterar du tjänstegenskaper med [PersistentState], lägger till tjänsten i tjänstsamlingen och anropar RegisterPersistentService tilläggsmetoden med tjänsten:

public class CustomUserService
{
    [PersistentState]
    public string UserData { get; set; }
}

services.AddScoped<CustomUserService>();

services.AddRazorComponents()
  .AddInteractiveServerComponents()
  .RegisterPersistentService<CustomUserService>(RenderMode.InteractiveAuto);

[OBS] Föregående exempel bevarar UserData tillståndet när tjänsten används i komponentförbehärskning för både interaktiv server- och interaktiv WebAssembly-återgivning eftersom RenderMode.InteractiveAuto har angetts till RegisterPersistentService. Beständighet för kretstillstånd är dock endast tillgänglig för återgivningsläget Interaktiv Server.

Om du vill hantera distribuerad tillståndspersistens (och för att fungera som standardmekanismen för tillståndspersistens när det konfigureras) tilldelar du appen en HybridCache (API: HybridCache), som konfigurerar sin egen beständighetsperiod (PersistedCircuitDistributedRetentionPeriod, åtta timmar som standard). HybridCache används eftersom det ger en enhetlig metod för distribuerad lagring som inte kräver separata paket för varje lagringsprovider.

I följande exempel implementeras en HybridCache med Redis-lagringsprovidern:

services.AddHybridCache()
    .AddRedis("{CONNECTION STRING}");

services.AddRazorComponents()
    .AddInteractiveServerComponents();

I föregående exempel {CONNECTION STRING} representerar platshållaren Anslutningssträngen för Redis Cache, som ska tillhandahållas med en säker metod, till exempel Secret Manager-verktyget i utvecklingsmiljön eller Azure Key Vault med Azure Managed Identities för Azure-distribuerade appar i alla miljöer.

Pausa och återuppta kretsar

Pausa och återuppta kretsar för att implementera anpassade principer som förbättrar skalbarheten för en app.

När en krets pausas lagras information om kretsen i webbläsarlagring på klientsidan och kretsen avlägsnas, vilket frigör serverresurser. När kretsen återupptas upprättas en ny krets och initieras med hjälp av det bevarade tillståndet.

Från en JavaScript-händelsehanterare:

• Anropa Blazor.pause för att pausa en krets.
• Anropa Blazor.resume för att återuppta en krets.

I följande exempel förutsätts att en krets inte krävs för en app som inte är synlig:

window.addEventListener('visibilitychange', () => {
  if (document.visibilityState === 'hidden') {
    Blazor.pause();
  } else if (document.visibilityState === 'visible') {
    Blazor.resume();
  }
});

Bibehåll tillstånd över kretsar

I allmänhet upprätthåller du tillstånd över kretsar där användare aktivt skapar data, inte bara läser data som redan finns.

För att bevara tillståndet mellan kretsar måste appen spara data till någon annan lagringsplats än serverns minne. Tillståndsbeständighet är inte automatiskt. Du måste vidta åtgärder när du utvecklar appen för att implementera tillståndskänslig datapersistence.

Data persistens krävs vanligtvis bara för värdefullt tillstånd som användarna har lagt ner ansträngning på att skapa. I följande exempel kan ett beständigt tillstånd spara tid eller underlätta kommersiell verksamhet:

• Webbformulär i flera steg: Det är tidskrävande för en användare att återigen ange information för flera steg i ett sådant formulär om deras information går förlorad. En användare förlorar tillståndet i det här scenariot om de navigerar bort från formuläret och returnerar senare.
• Kundvagnar: Alla kommersiellt viktiga komponenter i en app som representerar potentiella intäkter kan bibehållas. En användare som förlorar sin stat, och därmed sin kundvagn, kan köpa färre produkter eller tjänster när de återvänder till webbplatsen senare.

En app kan bara bevara apptillstånd. UIs kan inte bevaras, till exempel komponentinstanser och deras återgivningsträd. Komponenter och återgivningsträd är vanligtvis inte serialiserbara. För att bevara användargränssnittets tillstånd, till exempel de expanderade noderna i en trädvykontroll, måste appen använda anpassad kod för att modellera beteendet för användargränssnittstillståndet som serialiserbart apptillstånd.