Proteger aplicativos Blazor do lado do servidor do ASP.NET Core

  • Artigo

Observação

Esta não é a versão mais recente deste artigo. Para informações sobre a versão vigente, confira a Versão do .NET 8 deste artigo.

Importante

Essas informações relacionam-se ao produto de pré-lançamento, que poderá ser substancialmente modificado antes do lançamento comercial. A Microsoft não oferece nenhuma garantia, explícita ou implícita, quanto às informações fornecidas aqui.

Para informações sobre a versão vigente, confira a Versão do .NET 8 deste artigo.

Este artigo explica como proteger aplicativos Blazor do lado do servidor como aplicativos ASP.NET Core.

Os aplicativos Blazor do lado do servidor são configurados para segurança da mesma forma que os aplicativos ASP.NET Core. Para obter mais informações, consulte os artigos em Tópicos de segurança do ASP.NET Core.

O contexto de autenticação só é estabelecido quando o aplicativo é iniciado, ou seja, quando o aplicativo se conecta pela primeira vez ao WebSocket. O contexto de autenticação é mantido durante o tempo de vida do circuito. Os aplicativos revalidam periodicamente o estado de autenticação do usuário, atualmente a cada 30 minutos por padrão.

Se o aplicativo precisar capturar usuários para serviços personalizados ou reagir a atualizações para o usuário, confira Cenários de segurança adicionais do Blazor do ASP.NET Core do lado do servidor.

Blazor difere de aplicativos Web tradicionais renderizados pelo servidor que fazem novas solicitações HTTP com cookies em cada navegação de página. A autenticação é verificada durante eventos de navegação. No entanto, cookies não estão envolvidos. Cookies são enviados somente ao fazer uma solicitação HTTP para um servidor, o que não ocorre quando o usuário navega em um aplicativo Blazor. Durante a navegação, o estado de autenticação do usuário é verificado dentro do circuito Blazor, que você pode atualizar a qualquer momento no servidor usando a abstração RevalidatingAuthenticationStateProvider.

Importante

Não é recomendável implementar um NavigationManager personalizado para obter validação de autenticação durante a navegação. Se o aplicativo precisar executar a lógica de estado de autenticação personalizada durante a navegação, use um personalizado AuthenticationStateProvider.

Observação

Os exemplos de código neste artigo adotam tipos de referência anuláveis (NRTs) e análise estática de estado nulo do compilador do .NET, que têm suporte no ASP.NET Core no .NET 6 ou posterior. Ao usar o ASP.NET Core 5.0 ou anterior, remova a designação de tipo nulo (?) dos exemplos deste artigo.

Modelo de projeto

Crie um novo aplicativo Blazor do lado do servidor seguindo as diretrizes em Ferramentas para Blazor do ASP.NET Core.

Depois de escolher o modelo de aplicativo do lado do servidor e configurar o projeto, selecione a autenticação do aplicativo em Tipo de autenticação:

  • Nenhum (padrão): nenhuma autenticação.
  • Contas individuais: as contas de usuário são armazenadas no aplicativo usando ASP.NET Core Identity.
  • Nenhum (padrão): nenhuma autenticação.
  • Contas individuais: as contas de usuário são armazenadas no aplicativo usando ASP.NET Core Identity.
  • Plataforma de identidade da Microsoft: para obter mais informações, confira Autenticação e autorização no Blazor do ASP.NET Core.
  • Windows: use a Autenticação do Windows.

Interface do usuário BlazorIdentity (contas individuais)

Blazor dá suporte à geração de uma interface do usuário Identity completa baseada em Blazor quando você escolhe a opção de autenticação para Contas Individuais.

O modelo de Aplicativo Web Blazor faz o scaffold de código do Identity em um banco de dados do SQL Server. A versão da linha de comando usa SQLite por padrão e inclui um banco de dados SQLite para Identity.

O modelo lida com o seguinte:

  • Adiciona componentes do IdentityRazor e lógica relacionada para tarefas de autenticação de rotina, como conectar e desconectar usuários.
  • Adiciona os pacotes e dependências relacionados a Identity.
  • Faz referência aos pacotes Identity em _Imports.razor.
  • Cria uma classe de usuário Identity personalizada (ApplicationUser).
  • Cria e registra um contexto de banco de dados EF Core (ApplicationDbContext).
  • Configura o roteamento para os pontos de extremidade Identity internos.
  • Inclui validação de Identity e lógica de negócios.

Para inspecionar os componentes Blazor da estrutura Identity, acesse-os nas pastas Pages e Shared da pasta Account no modelo de projeto de Aplicativo Web Blazor (fonte de referência).

Quando você escolhe os modos de renderização interativa WebAssembly ou renderização automática, o servidor lida com todas as solicitações de autenticação e autorização, e os componentes Identity são renderizados estaticamente no servidor no projeto principal do aplicativo Web Blazor. O modelo de projeto inclui uma classe PersistentAuthenticationStateProvider (fonte de referência) no projeto .Client para sincronizar o estado de autenticação do usuário entre o servidor e o navegador. A classe é uma implementação personalizada de AuthenticationStateProvider. O provedor usa a classe PersistentComponentState para pré-renderizar o estado de autenticação e persisti-lo na página.

BlazorIdentity depende de instâncias DbContext não criadas por uma fábrica, o que é intencional porque DbContext é suficiente para que os componentes Identity do modelo de projeto sejam renderizados estaticamente sem dar suporte à interatividade.

No projeto principal de um Aplicativo Web Blazor, o provedor de estado de autenticação se chama IdentityRevalidatingAuthenticationStateProvider (fonte de referência) (somente as soluções de interatividade do servidor) ou PersistingRevalidatingAuthenticationStateProvider (fonte de referência) (soluções de interatividade WebAssembly ou Automático).

Para obter uma descrição sobre como os modos de renderização interativos globais são aplicados a componentes nãoIdentity e, ao mesmo tempo, impõem SSR estático para os componentes Identity, consulte ASP.NET Core Blazor Modos de renderização.

Para obter mais informações sobre como persistir o estado pré-renderizado, confira Pré-renderizar componentes do ASP.NET Core Razor.

Para obter mais informações sobre a interface do usuário do BlazorIdentity, bem como diretrizes de como integrar logons externos por meio de sites sociais, confira Novidades da identidade no .NET 8.

Observação

Os links de documentação para a fonte de referência do .NET geralmente carregam o branch padrão do repositório, que representa o desenvolvimento atual da próxima versão do .NET. Para selecionar uma marca para uma versão específica, use a lista suspensa para Alternar branches ou marcas. Para saber mais, confira Como selecionar uma marca de versão do código-fonte do ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Gerenciar o estado da autenticação em Blazor Aplicativos Web

Esta seção se aplica a Aplicativos Web Blazor que adotam:

  • Renderização interativa no lado do servidor (SSR interativo) e CSR.
  • Renderização no lado do cliente (CSR).

Um provedor de estado de autenticação do lado do cliente é usado somente em Blazor e não está integrado ao sistema de autenticação do ASP.NET Core. Durante a pré-renderização, Blazor respeita os metadados definidos na página e usa o sistema de autenticação ASP.NET Core para determinar se o usuário está autenticado. Quando um usuário navega de uma página para outra, é usado um provedor de autenticação no lado do cliente. Quando o usuário atualiza a página (recarrega a página inteira), o provedor de estado de autenticação do lado do cliente não está envolvido na decisão de autenticação no servidor. Como o estado do usuário não é mantido pelo servidor, qualquer estado de autenticação mantido no lado do cliente é perdido.

Para resolver isso, a melhor abordagem é realizar a autenticação no sistema de autenticação do ASP.NET Core. O provedor de estado de autenticação no lado do cliente só se encarrega de refletir o estado de autenticação do usuário. Exemplos de como fazer isso com provedores de estado de autenticação são demonstrados pelo modelo de projeto Blazor de Aplicativo Web:

Observação

Os links de documentação para a fonte de referência do .NET geralmente carregam o branch padrão do repositório, que representa o desenvolvimento atual da próxima versão do .NET. Para selecionar uma marca para uma versão específica, use a lista suspensa para Alternar branches ou marcas. Para saber mais, confira Como selecionar uma marca de versão do código-fonte do ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Scaffold Identity

Para obter mais informações sobre scaffolding Identity em um aplicativo Blazor do lado do servidor, confira Scaffolding Identity em projetos ASP.NET Core.

Faça scaffold Identity em um aplicativo Blazor do lado do servidor:

Declarações e tokens adicionais de provedores externos

Para armazenar declarações adicionais de provedores externos, consulte Persistir declarações e tokens adicionais de provedores externos no ASP.NET Core.

Serviço de Aplicativo do Azure no Linux com o Identity Server

Especifique o emissor explicitamente ao implantar no Serviço de Aplicativo do Azure no Linux com o Identity Server. Para obter mais informações, confira Usar o Identity para proteger um back-end da API Web para SPAs.

Implementar um AuthenticationStateProvider personalizado

Se o aplicativo exigir um provedor personalizado, implemente AuthenticationStateProvider e substitua GetAuthenticationStateAsync.

No exemplo a seguir, todos os usuários são autenticados com o nome de usuário mrfibuli.

CustomAuthStateProvider.cs:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    public override Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var identity = new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.Name, "mrfibuli"),
        }, "Custom Authentication");

        var user = new ClaimsPrincipal(identity);

        return Task.FromResult(new AuthenticationState(user));
    }
}

O serviço CustomAuthStateProvider é registrado no arquivo Program:

using Microsoft.AspNetCore.Components.Authorization;

...

builder.Services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

O serviço CustomAuthStateProvider é registrado no arquivo Programapós a chamada para AddServerSideBlazor:

using Microsoft.AspNetCore.Components.Authorization;

...

builder.Services.AddServerSideBlazor();

...

builder.Services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

O serviço CustomAuthStateProvider é registrado no Startup.ConfigureServices de Startup.csapós a chamada para AddServerSideBlazor:

using Microsoft.AspNetCore.Components.Authorization;

...

services.AddServerSideBlazor();

...

services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Confirme ou adicione um AuthorizeRouteView ao componente Router.

No componente Routes (Components/Routes.razor):

<Router ...>
    <Found ...>
        <AuthorizeRouteView RouteData="routeData" 
            DefaultLayout="typeof(Layout.MainLayout)" />
        ...
    </Found>
</Router>

Adicione serviços de estado de autenticação em cascata à coleção de serviços no arquivo Program:

builder.Services.AddCascadingAuthenticationState();

Observação

Quando você cria um aplicativo Blazor de um dos modelos de projeto Blazor com a autenticação habilitada, o aplicativo inclui a AuthorizeRouteView e a chamada para AddCascadingAuthenticationState. Para obter mais informações, consulte Autenticação e autorização Blazor do ASP.NET Core com informações adicionais apresentadas na seção Personalizar conteúdo não autorizado com o componente Router.

Confirme ou adicione um AuthorizeRouteView e CascadingAuthenticationState ao componente Router:

<CascadingAuthenticationState>
    <Router ...>
        <Found ...>
            <AuthorizeRouteView RouteData="routeData" 
                DefaultLayout="typeof(MainLayout)" />
            ...
        </Found>
    </Router>
</CascadingAuthenticationState>

Observação

Ao criar um aplicativo Blazor a partir de um dos modelos de projeto Blazor com a autenticação habilitada, o aplicativo inclui os componentes AuthorizeRouteView e CascadingAuthenticationState mostrados no exemplo anterior. Para obter mais informações, consulte Autenticação e autorização Blazor do ASP.NET Core com informações adicionais apresentadas na seção Personalizar conteúdo não autorizado com o componente Router.

Um AuthorizeView demonstra o nome do usuário autenticado em qualquer componente:

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

Para obter diretrizes sobre o uso do AuthorizeView, consulte Autenticação e autorização Blazor do ASP.NET Core.

Notificação sobre mudanças no estado de autenticação

Um AuthenticationStateProvider personalizado pode invocar NotifyAuthenticationStateChanged na classe base AuthenticationStateProvider para notificar os consumidores sobre a alteração de estado de autenticação a ser gerada novamente.

O exemplo a seguir baseia-se na implementação de um AuthenticationStateProvider personalizado seguindo as diretrizes na seção Implementar um AuthenticationStateProvider personalizado .

A implementação CustomAuthStateProvider a seguir expõe um método personalizado, AuthenticateUser, para conectar um usuário e notificar os consumidores sobre a alteração do estado de autenticação.

CustomAuthStateProvider.cs:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    public override Task<AuthenticationState> GetAuthenticationStateAsync()
    {
        var identity = new ClaimsIdentity();
        var user = new ClaimsPrincipal(identity);

        return Task.FromResult(new AuthenticationState(user));
    }

    public void AuthenticateUser(string userIdentifier)
    {
        var identity = new ClaimsIdentity(new[]
        {
            new Claim(ClaimTypes.Name, userIdentifier),
        }, "Custom Authentication");

        var user = new ClaimsPrincipal(identity);

        NotifyAuthenticationStateChanged(
            Task.FromResult(new AuthenticationState(user)));
    }
}

Em um componente :

@inject AuthenticationStateProvider AuthenticationStateProvider

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        ((CustomAuthStateProvider)AuthenticationStateProvider)
            .AuthenticateUser(userIdentifier);
    }
}

@inject AuthenticationStateProvider AuthenticationStateProvider

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        ((CustomAuthStateProvider)AuthenticationStateProvider)
            .AuthenticateUser(userIdentifier);
    }
}

A abordagem anterior pode ser aprimorada para disparar notificações de alterações de estado de autenticação por meio de um serviço personalizado. O AuthenticationService a seguir mantém a entidade de segurança de declarações do usuário atual em um campo de suporte (currentUser) com um evento (UserChanged) que AuthenticationStateProvider pode assinar, em que o evento invoca NotifyAuthenticationStateChanged. Com a configuração adicional mais adiante nesta seção, AuthenticationService pode ser injetado em um componente com lógica que define o CurrentUser para disparar o evento UserChanged.

using System.Security.Claims;

public class AuthenticationService
{
    public event Action<ClaimsPrincipal>? UserChanged;
    private ClaimsPrincipal? currentUser;

    public ClaimsPrincipal CurrentUser
    {
        get { return currentUser ?? new(); }
        set
        {
            currentUser = value;

            if (UserChanged is not null)
            {
                UserChanged(currentUser);
            }
        }
    }
}

No arquivo Program, registre o AuthenticationService no contêiner de injeção de dependência:

builder.Services.AddScoped<AuthenticationService>();

No Startup.ConfigureServices de Startup.cs, registre o AuthenticationService no contêiner de injeção de dependência:

services.AddScoped<AuthenticationService>();

O CustomAuthStateProvider a seguir assina o evento AuthenticationService.UserChanged. GetAuthenticationStateAsync retorna o estado de autenticação do usuário. Inicialmente, o estado de autenticação é baseado no valor de AuthenticationService.CurrentUser. Quando há uma alteração no usuário, um novo estado de autenticação é criado com o novo usuário (new AuthenticationState(newUser)) para chamadas para GetAuthenticationStateAsync:

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Components.Authorization;

public class CustomAuthStateProvider : AuthenticationStateProvider
{
    private AuthenticationState authenticationState;

    public CustomAuthStateProvider(AuthenticationService service)
    {
        authenticationState = new AuthenticationState(service.CurrentUser);

        service.UserChanged += (newUser) =>
        {
            authenticationState = new AuthenticationState(newUser);

            NotifyAuthenticationStateChanged(
                Task.FromResult(new AuthenticationState(newUser)));
        };
    }

    public override Task<AuthenticationState> GetAuthenticationStateAsync() =>
        Task.FromResult(authenticationState);
}

O método SignIn do componente a seguir cria uma entidade de segurança de declarações para que o identificador do usuário seja definido em AuthenticationService.CurrentUser:

@inject AuthenticationService AuthenticationService

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        var currentUser = AuthenticationService.CurrentUser;

        var identity = new ClaimsIdentity(
            new[]
            {
                new Claim(ClaimTypes.Name, userIdentifier),
            },
            "Custom Authentication");

        var newUser = new ClaimsPrincipal(identity);

        AuthenticationService.CurrentUser = newUser;
    }
}

@inject AuthenticationService AuthenticationService

<input @bind="userIdentifier" />
<button @onclick="SignIn">Sign in</button>

<AuthorizeView>
    <Authorized>
        <p>Hello, @context.User.Identity?.Name!</p>
    </Authorized>
    <NotAuthorized>
        <p>You're not authorized.</p>
    </NotAuthorized>
</AuthorizeView>

@code {
    public string userIdentifier = string.Empty;

    private void SignIn()
    {
        var currentUser = AuthenticationService.CurrentUser;

        var identity = new ClaimsIdentity(
            new[]
            {
                new Claim(ClaimTypes.Name, userIdentifier),
            },
            "Custom Authentication");

        var newUser = new ClaimsPrincipal(identity);

        AuthenticationService.CurrentUser = newUser;
    }
}

Injetar AuthenticationStateProvider para serviços com escopo para um componente

Não tente resolver AuthenticationStateProvider dentro de um escopo personalizado porque isso resulta na criação de uma nova instância do AuthenticationStateProvider que não está inicializada corretamente.

Para acessar o AuthenticationStateProvider dentro de um serviço com escopo para um componente, injete o AuthenticationStateProvider com a diretiva @inject ou o atributo [Inject] e passe-o para o serviço como um parâmetro. Essa abordagem garante que a instância correta inicializada do AuthenticationStateProvider seja usada para cada instância de aplicativo de usuário.

ExampleService.cs:

public class ExampleService
{
    public async Task<string> ExampleMethod(AuthenticationStateProvider authStateProvider)
    {
        var authState = await authStateProvider.GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity is not null && user.Identity.IsAuthenticated)
        {
            return $"{user.Identity.Name} is authenticated.";
        }
        else
        {
            return "The user is NOT authenticated.";
        }
    }
}

Registre o serviço como com escopo. Em um aplicativo Blazor do lado do servidor, os serviços com escopo têm um tempo de vida igual à duração do circuito de conexão do cliente.

No arquivo Program:

builder.Services.AddScoped<ExampleService>();

No Startup.ConfigureServices do Startup.cs:

services.AddScoped<ExampleService>();

No seguinte componente InjectAuthStateProvider:

InjectAuthStateProvider.razor:

@page "/inject-auth-state-provider"
@inherits OwningComponentBase
@inject AuthenticationStateProvider AuthenticationStateProvider

<h1>Inject <code>AuthenticationStateProvider</code> Example</h1>

<p>@message</p>

@code {
    private string? message;
    private ExampleService? ExampleService { get; set; }

    protected override async Task OnInitializedAsync()
    {
        ExampleService = ScopedServices.GetRequiredService<ExampleService>();

        message = await ExampleService.ExampleMethod(AuthenticationStateProvider);
    }
}

@page "/inject-auth-state-provider"
@inject AuthenticationStateProvider AuthenticationStateProvider
@inherits OwningComponentBase

<h1>Inject <code>AuthenticationStateProvider</code> Example</h1>

<p>@message</p>

@code {
    private string? message;
    private ExampleService? ExampleService { get; set; }

    protected override async Task OnInitializedAsync()
    {
        ExampleService = ScopedServices.GetRequiredService<ExampleService>();

        message = await ExampleService.ExampleMethod(AuthenticationStateProvider);
    }
}

Para obter mais informações, consulte as diretrizes de OwningComponentBase em Injeção de dependência Blazor no ASP.NET Core.

Exibição de conteúdo não autorizado durante a pré-renderização com um AuthenticationStateProvider personalizado

Para evitar a exibição de conteúdo não autorizado, por exemplo, conteúdo em um componente AuthorizeView, durante a pré-renderização com um AuthenticationStateProvider personalizado, adote uma das seguintes abordagens:

  • Desabilitar a pré-renderização: indique o modo de renderização com o parâmetro prerender definido como false no componente de nível mais alto na hierarquia de componentes do aplicativo que não seja um componente raiz.

    Observação

    Não há suporte para tornar um componente raiz interativo, como o componente App. Portanto, a pré-renderização não pode ser desabilitada diretamente pelo componente App.

    Para aplicativos com base no modelo de projeto do aplicativo Web Blazor, a pré-renderização normalmente é desabilitada quando o componente Routes é usado no componente App (Components/App.razor):

    <Routes @rendermode="new InteractiveServerRenderMode(prerender: false)" />

    Além disso, desabilite a pré-geração para o componente HeadOutlet:

    <HeadOutlet @rendermode="new InteractiveServerRenderMode(prerender: false)" />

    Você também pode desabilitar seletivamente a pré-renderização com controle fino do modo de renderização aplicado à instância do componente Routes. Para obter mais informações, consulte ASP.NET Core Blazor modos de renderização.

  • Desabilitar a pré-renderização: abra o arquivo _Host.cshtml e altere o atributo render-mode do Component Tag Helper para Server:

    <component type="typeof(App)" render-mode="Server" />
  • Autenticar o usuário no servidor antes de iniciar o aplicativo: para adotar essa abordagem, o aplicativo deve responder à solicitação inicial de um usuário com a página ou exibição de logon baseada em Identity e impedir qualquer solicitação a pontos de extremidade Blazor até que haja a autenticação. Para obter mais informações, confira Criar um aplicativo ASP.NET Core com dados de usuário protegidos por autorização. Após a autenticação, o conteúdo não autorizado em componentes Razor pré-renderizados só é mostrado quando o usuário realmente não está autorizado a exibir o conteúdo.

Gerenciamento de estado do usuário

Apesar da palavra "estado" no nome, AuthenticationStateProvider não é para armazenar o estado geral do usuário. AuthenticationStateProvider indica apenas o estado de autenticação do usuário para o aplicativo, se ele está conectado ao aplicativo e como ele está conectado.

A autenticação usa a mesma autenticação Identity do ASP.NET Core que os aplicativos Razor Pages e MVC. O estado do usuário armazenado para ASP.NET Core Identity flui sem Blazor adicionar código ao aplicativo. Siga as diretrizes nos artigos e tutoriais Identity do ASP.NET Core para que os recursos Identity entrem em vigor nas partes Blazor do aplicativo.

Para obter diretrizes sobre o gerenciamento de estado geral fora do ASP.NET Core Identity, consulte Gerenciamento de estado Blazor do ASP.NET Core.

Abstrações de segurança adicionais

Duas abstrações adicionais participam do gerenciamento do estado de autenticação:

Observação

Os links de documentação para a fonte de referência do .NET geralmente carregam o branch padrão do repositório, que representa o desenvolvimento atual da próxima versão do .NET. Para selecionar uma marca para uma versão específica, use a lista suspensa para Alternar branches ou marcas. Para saber mais, confira Como selecionar uma marca de versão do código-fonte do ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Duração da validade da URL de redirecionamento temporário

Esta seção aplica-se a Aplicativos Web Blazor.

Use a opção RazorComponentsServiceOptions.TemporaryRedirectionUrlValidityDuration para obter ou definir o tempo de vida da validade da proteção de dados para URLs de redirecionamento temporário emitidas pela renderização do lado do servidor do Blazor. Eles são usados apenas transitoriamente, portanto, o tempo de vida só precisa ser longo o suficiente para que um cliente receba a URL e inicie a navegação nela. No entanto, também deve ser longo o suficiente para permitir a distorção do relógio entre os servidores. O valor padrão é cinco minutos.

No exemplo a seguir, o valor é estendido para sete minutos:

builder.Services.AddRazorComponents(options => 
    options.TemporaryRedirectionUrlValidityDuration = 
        TimeSpan.FromMinutes(7));

Recursos adicionais