BlazorAutenticação e autorização do ASP.NET CoreASP.NET Core Blazor authentication and authorization

Por Steve Sanderson e Luke LathamBy Steve Sanderson and Luke Latham

O ASP.NET Core dá suporte à configuração e ao gerenciamento de segurança em Blazor aplicativos.ASP.NET Core supports the configuration and management of security in Blazor apps.

Cenários de segurança diferem entre Blazor Server Blazor WebAssembly aplicativos e.Security scenarios differ between Blazor Server and Blazor WebAssembly apps. Como os Blazor Server aplicativos são executados no servidor, as verificações de autorização são capazes de determinar:Because Blazor Server apps run on the server, authorization checks are able to determine:

  • As opções de interface do usuário apresentadas ao usuário (por exemplo, as entradas de menu disponíveis a um usuário).The UI options presented to a user (for example, which menu entries are available to a user).
  • As regras de acesso para áreas do aplicativo e componentes.Access rules for areas of the app and components.

Blazor WebAssemblyos aplicativos são executados no cliente.Blazor WebAssembly apps run on the client. A autorização é somente usada para determinar quais opções da interface do usuário serão apresentadas.Authorization is only used to determine which UI options to show. Como as verificações do lado do cliente podem ser modificadas ou ignoradas por um usuário, um Blazor WebAssembly aplicativo não pode impor regras de acesso de autorização.Since client-side checks can be modified or bypassed by a user, a Blazor WebAssembly app can't enforce authorization access rules.

As Razor convenções de autorização de páginas não se aplicam a componentes roteáveis Razor .Razor Pages authorization conventions don't apply to routable Razor components. Se um componente não roteável Razor for inserido em uma página, as convenções de autorização da página afetarão indiretamente o Razor componente junto com o restante do conteúdo da página.If a non-routable Razor component is embedded in a page, the page's authorization conventions indirectly affect the Razor component along with the rest of the page's content.

Observação

SignInManager<TUser>e UserManager<TUser> não têm suporte em Razor componentes do.SignInManager<TUser> and UserManager<TUser> aren't supported in Razor components.

AutenticaçãoAuthentication

Blazorusa os mecanismos de autenticação de ASP.NET Core existentes para estabelecer a identidade do usuário.Blazor uses the existing ASP.NET Core authentication mechanisms to establish the user's identity. O mecanismo exato depende de como o Blazor aplicativo é hospedado Blazor WebAssembly ou Blazor Server .The exact mechanism depends on how the Blazor app is hosted, Blazor WebAssembly or Blazor Server.

autenticação Blazor WebAssemblyBlazor WebAssembly authentication

Em Blazor WebAssembly aplicativos, as verificações de autenticação podem ser ignoradas porque todo o código do lado do cliente pode ser modificado por usuários.In Blazor WebAssembly apps, authentication checks can be bypassed because all client-side code can be modified by users. Isso também ocorre com todas as tecnologias de aplicativo do lado do cliente, incluindo estruturas de SPA do JavaScript ou aplicativos nativos em qualquer sistema operacional.The same is true for all client-side app technologies, including JavaScript SPA frameworks or native apps for any operating system.

Adicione o seguinte:Add the following:

Para lidar com a autenticação, o uso de um serviço interno ou personalizado AuthenticationStateProvider é abordado nas seções a seguir.To handle authentication, use of a built-in or custom AuthenticationStateProvider service is covered in the following sections.

Para obter mais informações sobre como criar aplicativos e configuração, consulte ASP.NET Core seguroBlazor WebAssembly .For more information on creating apps and configuration, see ASP.NET Core seguroBlazor WebAssembly.

autenticação Blazor ServerBlazor Server authentication

Blazor Serveros aplicativos operam em uma conexão em tempo real que é criada usando o SignalR .Blazor Server apps operate over a real-time connection that's created using SignalR. A autenticação em SignalR aplicativos baseados no é tratada quando a conexão é estabelecida.Authentication in SignalR-based apps is handled when the connection is established. A autenticação pode ser baseada em um cookie ou algum outro token de portador.Authentication can be based on a cookie or some other bearer token.

O AuthenticationStateProvider serviço interno para Blazor Server aplicativos obtém dados de estado de autenticação do ASP.NET Core HttpContext.User .The built-in AuthenticationStateProvider service for Blazor Server apps obtains authentication state data from ASP.NET Core's HttpContext.User. É assim que o estado de autenticação se integra aos mecanismos existentes de autenticação de ASP.NET Core.This is how authentication state integrates with existing ASP.NET Core authentication mechanisms.

Para obter mais informações sobre como criar aplicativos e configuração, consulte Proteger ASP.NET Core Blazor Server aplicativos .For more information on creating apps and configuration, see Proteger ASP.NET Core Blazor Server aplicativos.

Serviço AuthenticationStateProviderAuthenticationStateProvider service

O AuthenticationStateProvider é o serviço subjacente usado pelos componentes AuthorizeView e CascadingAuthenticationState para obter o estado de autenticação.AuthenticationStateProvider is the underlying service used by the AuthorizeView component and CascadingAuthenticationState component to get the authentication state.

Normalmente, você não usa o AuthenticationStateProvider diretamente.You don't typically use AuthenticationStateProvider directly. Use o AuthorizeView componente ou Task<AuthenticationState> abordagens descritas posteriormente neste artigo.Use the AuthorizeView component or Task<AuthenticationState> approaches described later in this article. A principal desvantagem de usar o AuthenticationStateProvider diretamente é que o componente não será notificado automaticamente se os dados subjacentes do estado de autenticação forem alterados.The main drawback to using AuthenticationStateProvider directly is that the component isn't notified automatically if the underlying authentication state data changes.

O serviço AuthenticationStateProvider pode fornecer os dados de ClaimsPrincipal do usuário atual, conforme mostrado no seguinte exemplo:The AuthenticationStateProvider service can provide the current user's ClaimsPrincipal data, as shown in the following example:

@page "/"
@using System.Security.Claims
@using Microsoft.AspNetCore.Components.Authorization
@inject AuthenticationStateProvider AuthenticationStateProvider

<h3>ClaimsPrincipal Data</h3>

<button @onclick="GetClaimsPrincipalData">Get ClaimsPrincipal Data</button>

<p>@_authMessage</p>

@if (_claims.Count() > 0)
{
    <ul>
        @foreach (var claim in _claims)
        {
            <li>@claim.Type: @claim.Value</li>
        }
    </ul>
}

<p>@_surnameMessage</p>

@code {
    private string _authMessage;
    private string _surnameMessage;
    private IEnumerable<Claim> _claims = Enumerable.Empty<Claim>();

    private async Task GetClaimsPrincipalData()
    {
        var authState = await AuthenticationStateProvider.GetAuthenticationStateAsync();
        var user = authState.User;

        if (user.Identity.IsAuthenticated)
        {
            _authMessage = $"{user.Identity.Name} is authenticated.";
            _claims = user.Claims;
            _surnameMessage = 
                $"Surname: {user.FindFirst(c => c.Type == ClaimTypes.Surname)?.Value}";
        }
        else
        {
            _authMessage = "The user is NOT authenticated.";
        }
    }
}

Se user.Identity.IsAuthenticated for true e como o usuário é um ClaimsPrincipal, será possível enumerar as declarações e avaliar a associação nas funções.If user.Identity.IsAuthenticated is true and because the user is a ClaimsPrincipal, claims can be enumerated and membership in roles evaluated.

Para obter mais informações sobre a DI (injeção de dependência) e os serviços, confira Injeção de dependência de ASP.NET Core Blazor e Injeção de dependência no ASP.NET Core.For more information on dependency injection (DI) and services, see Injeção de dependência de ASP.NET Core Blazor and Injeção de dependência no ASP.NET Core.

Implementar um AuthenticationStateProvider personalizadoImplement a custom AuthenticationStateProvider

Se o aplicativo exigir um provedor personalizado, implemente AuthenticationStateProvider e substitua GetAuthenticationStateAsync :If the app requires a custom provider, implement AuthenticationStateProvider and override GetAuthenticationStateAsync:

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"),
        }, "Fake authentication type");

        var user = new ClaimsPrincipal(identity);

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

Em um Blazor WebAssembly aplicativo, o CustomAuthStateProvider serviço é registrado em Main Program.cs :In a Blazor WebAssembly app, the CustomAuthStateProvider service is registered in Main of Program.cs:

using Microsoft.AspNetCore.Components.Authorization;

...

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

Em um Blazor Server aplicativo, o CustomAuthStateProvider serviço é registrado em Startup.ConfigureServices :In a Blazor Server app, the CustomAuthStateProvider service is registered in Startup.ConfigureServices:

using Microsoft.AspNetCore.Components.Authorization;

...

services.AddScoped<AuthenticationStateProvider, CustomAuthStateProvider>();

Usando o CustomAuthStateProvider no exemplo anterior, todos os usuários são autenticados com o nome de usuário mrfibuli .Using the CustomAuthStateProvider in the preceding example, all users are authenticated with the username mrfibuli.

Expor o estado de autenticação como um parâmetro em cascataExpose the authentication state as a cascading parameter

Se os dados de estado de autenticação forem necessários para a lógica de procedimento, como ao executar uma ação disparada pelo usuário, obtenha os dados de estado de autenticação definindo um parâmetro em cascata do tipo Task< AuthenticationState > :If authentication state data is required for procedural logic, such as when performing an action triggered by the user, obtain the authentication state data by defining a cascading parameter of type Task<AuthenticationState>:

@page "/"

<button @onclick="LogUsername">Log username</button>

<p>@_authMessage</p>

@code {
    [CascadingParameter]
    private Task<AuthenticationState> authenticationStateTask { get; set; }

    private string _authMessage;

    private async Task LogUsername()
    {
        var authState = await authenticationStateTask;
        var user = authState.User;

        if (user.Identity.IsAuthenticated)
        {
            _authMessage = $"{user.Identity.Name} is authenticated.";
        }
        else
        {
            _authMessage = "The user is NOT authenticated.";
        }
    }
}

Se user.Identity.IsAuthenticated for true, será possível enumerar as declarações e avaliar a associação nas funções.If user.Identity.IsAuthenticated is true, claims can be enumerated and membership in roles evaluated.

Configure o Task< AuthenticationState > parâmetro em cascata usando os AuthorizeRouteView componentes e CascadingAuthenticationState no App componente ( App.razor ):Set up the Task<AuthenticationState> cascading parameter using the AuthorizeRouteView and CascadingAuthenticationState components in the App component (App.razor):

<CascadingAuthenticationState>
    <Router AppAssembly="@typeof(Program).Assembly">
        <Found Context="routeData">
            <AuthorizeRouteView RouteData="@routeData" 
                DefaultLayout="@typeof(MainLayout)" />
        </Found>
        <NotFound>
            <LayoutView Layout="@typeof(MainLayout)">
                <p>Sorry, there's nothing at this address.</p>
            </LayoutView>
        </NotFound>
    </Router>
</CascadingAuthenticationState>

Em um Blazor WebAssembly aplicativo, adicione serviços para opções e autorização para Program.Main :In a Blazor WebAssembly App, add services for options and authorization to Program.Main:

builder.Services.AddOptions();
builder.Services.AddAuthorizationCore();

Em um Blazor Server aplicativo, os serviços para opções e autorização já estão presentes, portanto, nenhuma ação adicional é necessária.In a Blazor Server app, services for options and authorization are already present, so no further action is required.

AutorizaçãoAuthorization

Depois que o usuário é autenticado, as regras de autorização são aplicadas para controlar o que ele poderá fazer.After a user is authenticated, authorization rules are applied to control what the user can do.

O acesso geralmente é concedido ou negado com base nos seguintes casos:Access is typically granted or denied based on whether:

  • Se o usuário está autenticado (conectado).A user is authenticated (signed in).
  • Se o usuário está em uma função.A user is in a role.
  • Se o usuário tem uma declaração.A user has a claim.
  • Se uma política é atendida.A policy is satisfied.

Cada um desses conceitos é o mesmo de um aplicativo ASP.NET Core MVC ou de Razor páginas.Each of these concepts is the same as in an ASP.NET Core MVC or Razor Pages app. Para obter mais informações sobre ASP.NET Core segurança, consulte os artigos em ASP.NET Core segurança Identity e .For more information on ASP.NET Core security, see the articles under ASP.NET Core Security and Identity.

Componente AuthorizeViewAuthorizeView component

O componente AuthorizeView exibe de forma seletiva a interface do usuário, caso o usuário esteja autorizado a vê-la.The AuthorizeView component selectively displays UI depending on whether the user is authorized to see it. Essa abordagem é útil quando você precisa apenas exibir dados para o usuário e não precisa usar a identidade dele na lógica de procedimento.This approach is useful when you only need to display data for the user and don't need to use the user's identity in procedural logic.

O componente expõe uma variável context do tipo AuthenticationState, que pode ser usada para acessar informações sobre o usuário conectado:The component exposes a context variable of type AuthenticationState, which you can use to access information about the signed-in user:

<AuthorizeView>
    <h1>Hello, @context.User.Identity.Name!</h1>
    <p>You can only see this content if you're authenticated.</p>
</AuthorizeView>

Também é possível fornecer um conteúdo diferente para ser exibido caso o usuário não esteja autenticado:You can also supply different content for display if the user isn't authenticated:

<AuthorizeView>
    <Authorized>
        <h1>Hello, @context.User.Identity.Name!</h1>
        <p>You can only see this content if you're authenticated.</p>
    </Authorized>
    <NotAuthorized>
        <h1>Authentication Failure!</h1>
        <p>You're not signed in.</p>
    </NotAuthorized>
</AuthorizeView>

O AuthorizeView componente pode ser usado no NavMenu componente ( Shared/NavMenu.razor ) para exibir um item de lista ( <li>...</li> ) para um NavLink componente () NavLink , mas observe que essa abordagem apenas remove o item de lista da saída renderizada.The AuthorizeView component can be used in the NavMenu component (Shared/NavMenu.razor) to display a list item (<li>...</li>) for a NavLink component (NavLink), but note that this approach only removes the list item from the rendered output. Ele não impede que o usuário navegue até o componente.It doesn't prevent the user from navigating to the component.

O conteúdo de <Authorized> <NotAuthorized> marcas e pode incluir itens arbitrários, como outros componentes interativos.The content of <Authorized> and <NotAuthorized> tags can include arbitrary items, such as other interactive components.

As condições de autorização, como funções ou políticas que controlam o acesso ou as opções da interface do usuário, são abordadas na seção Autorização.Authorization conditions, such as roles or policies that control UI options or access, are covered in the Authorization section.

Se as condições de autorização não forem especificadas, o AuthorizeView usará uma política padrão e tratará:If authorization conditions aren't specified, AuthorizeView uses a default policy and treats:

  • Usuários autenticados (conectados) como autorizados.Authenticated (signed-in) users as authorized.
  • Usuários não autenticados (não conectados) como não autorizados.Unauthenticated (signed-out) users as unauthorized.

Autorização baseada em funções e em políticasRole-based and policy-based authorization

O componente AuthorizeView dá suporte à autorização baseada em funções ou baseada em políticas.The AuthorizeView component supports role-based or policy-based authorization.

Para a autorização baseada em funções, use o parâmetro Roles:For role-based authorization, use the Roles parameter:

<AuthorizeView Roles="admin, superuser">
    <p>You can only see this if you're an admin or superuser.</p>
</AuthorizeView>

Para obter mais informações, consulte Autorização baseada em função no ASP.NET Core.For more information, see Autorização baseada em função no ASP.NET Core.

Para a autorização baseada em políticas, use o parâmetro Policy:For policy-based authorization, use the Policy parameter:

<AuthorizeView Policy="content-editor">
    <p>You can only see this if you satisfy the "content-editor" policy.</p>
</AuthorizeView>

A autorização baseada em declarações é um caso especial de autorização baseada em políticas.Claims-based authorization is a special case of policy-based authorization. Por exemplo, você pode definir uma política que exige que os usuários tenham determinada declaração.For example, you can define a policy that requires users to have a certain claim. Para obter mais informações, consulte Autorização baseada em políticas no ASP.NET Core.For more information, see Autorização baseada em políticas no ASP.NET Core.

Essas APIs podem ser usadas em um Blazor Server ou em Blazor WebAssembly aplicativos.These APIs can be used in either Blazor Server or Blazor WebAssembly apps.

Se Roles e Policy não forem especificados, o AuthorizeView usará a política padrão.If neither Roles nor Policy is specified, AuthorizeView uses the default policy.

Conteúdo exibido durante a autenticação assíncronaContent displayed during asynchronous authentication

Blazorpermite que o estado de autenticação seja determinado de forma assíncrona.Blazor allows for authentication state to be determined asynchronously. O cenário principal para essa abordagem é em Blazor WebAssembly aplicativos que fazem uma solicitação para um ponto de extremidade externo para autenticação.The primary scenario for this approach is in Blazor WebAssembly apps that make a request to an external endpoint for authentication.

Enquanto a autenticação estiver em andamento, AuthorizeView não exibirá nenhum conteúdo por padrão.While authentication is in progress, AuthorizeView displays no content by default. Para exibir o conteúdo enquanto a autenticação ocorre, use a <Authorizing> marca:To display content while authentication occurs, use the <Authorizing> tag:

<AuthorizeView>
    <Authorized>
        <h1>Hello, @context.User.Identity.Name!</h1>
        <p>You can only see this content if you're authenticated.</p>
    </Authorized>
    <Authorizing>
        <h1>Authentication in progress</h1>
        <p>You can only see this content while authentication is in progress.</p>
    </Authorizing>
</AuthorizeView>

Essa abordagem não é normalmente aplicável a Blazor Server aplicativos.This approach isn't normally applicable to Blazor Server apps. Blazor Serveros aplicativos conhecem o estado de autenticação assim que o estado é estabelecido.Blazor Server apps know the authentication state as soon as the state is established. Authorizingo conteúdo pode ser fornecido no Blazor Server componente de um aplicativo AuthorizeView , mas o conteúdo nunca é exibido.Authorizing content can be provided in a Blazor Server app's AuthorizeView component, but the content is never displayed.

Atributo [Authorize][Authorize] attribute

O [Authorize] atributo pode ser usado em Razor componentes:The [Authorize] attribute can be used in Razor components:

@page "/"
@attribute [Authorize]

You can only see this if you're signed in.

Importante

Somente [Authorize] o uso em @page componentes foi atingido por meio do Blazor roteador.Only use [Authorize] on @page components reached via the Blazor Router. A autorização é realizada apenas como um aspecto do roteamento e não para componentes filho renderizados dentro de uma página.Authorization is only performed as an aspect of routing and not for child components rendered within a page. Para autorizar a exibição de partes específicas dentro de uma página, use AuthorizeView.To authorize the display of specific parts within a page, use AuthorizeView instead.

O [Authorize] atributo também oferece suporte à autorização baseada em função ou em políticas.The [Authorize] attribute also supports role-based or policy-based authorization. Para a autorização baseada em funções, use o parâmetro Roles:For role-based authorization, use the Roles parameter:

@page "/"
@attribute [Authorize(Roles = "admin, superuser")]

<p>You can only see this if you're in the 'admin' or 'superuser' role.</p>

Para a autorização baseada em políticas, use o parâmetro Policy:For policy-based authorization, use the Policy parameter:

@page "/"
@attribute [Authorize(Policy = "content-editor")]

<p>You can only see this if you satisfy the 'content-editor' policy.</p>

Se nem Roles nem Policy for especificado, [Authorize] o usará a política padrão, que por padrão é tratar:If neither Roles nor Policy is specified, [Authorize] uses the default policy, which by default is to treat:

  • Usuários autenticados (conectados) como autorizados.Authenticated (signed-in) users as authorized.
  • Usuários não autenticados (não conectados) como não autorizados.Unauthenticated (signed-out) users as unauthorized.

Personalizar conteúdo não autorizado com o componente RouterCustomize unauthorized content with the Router component

O Router componente, em conjunto com o AuthorizeRouteView componente, permite que o aplicativo especifique o conteúdo personalizado se:The Router component, in conjunction with the AuthorizeRouteView component, allows the app to specify custom content if:

No modelo de Blazor Server projeto padrão, o App componente ( App.razor ) demonstra como definir o conteúdo personalizado:In the default Blazor Server project template, the App component (App.razor) demonstrates how to set custom content:

<CascadingAuthenticationState>
    <Router AppAssembly="@typeof(Program).Assembly">
        <Found Context="routeData">
            <AuthorizeRouteView RouteData="@routeData" 
                DefaultLayout="@typeof(MainLayout)">
                <NotAuthorized>
                    <h1>Sorry</h1>
                    <p>You're not authorized to reach this page.</p>
                    <p>You may need to log in as a different user.</p>
                </NotAuthorized>
                <Authorizing>
                    <h1>Authentication in progress</h1>
                    <p>Only visible while authentication is in progress.</p>
                </Authorizing>
            </AuthorizeRouteView>
        </Found>
        <NotFound>
            <LayoutView Layout="@typeof(MainLayout)">
                <h1>Sorry</h1>
                <p>Sorry, there's nothing at this address.</p>
            </LayoutView>
        </NotFound>
    </Router>
</CascadingAuthenticationState>

O conteúdo das <NotFound> <NotAuthorized> marcas, e <Authorizing> pode incluir itens arbitrários, como outros componentes interativos.The content of <NotFound>, <NotAuthorized>, and <Authorizing> tags can include arbitrary items, such as other interactive components.

Se a <NotAuthorized> marca não for especificada, o AuthorizeRouteView usará a seguinte mensagem de fallback:If the <NotAuthorized> tag isn't specified, the AuthorizeRouteView uses the following fallback message:

Not authorized.

Notificação sobre mudanças no estado de autenticaçãoNotification about authentication state changes

Se o aplicativo determinar que os dados de estado de autenticação subjacentes foram alterados (por exemplo, porque o usuário se desconectou ou outro usuário alterou suas funções), um personalizado AuthenticationStateProvider poderá invocar opcionalmente o método NotifyAuthenticationStateChanged na AuthenticationStateProvider classe base.If the app determines that the underlying authentication state data has changed (for example, because the user signed out or another user has changed their roles), a custom AuthenticationStateProvider can optionally invoke the method NotifyAuthenticationStateChanged on the AuthenticationStateProvider base class. Isso notificará os consumidores a respeito dos dados de estado de autenticação (por exemplo, AuthorizeView) para realizar uma nova renderização usando os novos dados.This notifies consumers of the authentication state data (for example, AuthorizeView) to rerender using the new data.

Lógica de procedimentoProcedural logic

Se o aplicativo for necessário para verificar as regras de autorização como parte da lógica de procedimento, use um parâmetro em cascata do tipo Task< AuthenticationState > para obter o usuário ClaimsPrincipal .If the app is required to check authorization rules as part of procedural logic, use a cascaded parameter of type Task<AuthenticationState> to obtain the user's ClaimsPrincipal. Task<AuthenticationState>pode ser combinado com outros serviços, como IAuthorizationService , para avaliar políticas.Task<AuthenticationState> can be combined with other services, such as IAuthorizationService, to evaluate policies.

@using Microsoft.AspNetCore.Authorization
@inject IAuthorizationService AuthorizationService

<button @onclick="@DoSomething">Do something important</button>

@code {
    [CascadingParameter]
    private Task<AuthenticationState> authenticationStateTask { get; set; }

    private async Task DoSomething()
    {
        var user = (await authenticationStateTask).User;

        if (user.Identity.IsAuthenticated)
        {
            // Perform an action only available to authenticated (signed-in) users.
        }

        if (user.IsInRole("admin"))
        {
            // Perform an action only available to users in the 'admin' role.
        }

        if ((await AuthorizationService.AuthorizeAsync(user, "content-editor"))
            .Succeeded)
        {
            // Perform an action only available to users satisfying the 
            // 'content-editor' policy.
        }
    }
}

Observação

Em um Blazor WebAssembly componente de aplicativo, adicione Microsoft.AspNetCore.Authorization os Microsoft.AspNetCore.Components.Authorization namespaces e:In a Blazor WebAssembly app component, add the Microsoft.AspNetCore.Authorization and Microsoft.AspNetCore.Components.Authorization namespaces:

@using Microsoft.AspNetCore.Authorization
@using Microsoft.AspNetCore.Components.Authorization

Esses namespaces podem ser fornecidos globalmente adicionando-os ao arquivo do aplicativo _Imports.razor .These namespaces can be provided globally by adding them to the app's _Imports.razor file.

Solucionar problemas de errosTroubleshoot errors

Erros comuns:Common errors:

  • A autorização requer um parâmetro em cascata do tipo Task\<AuthenticationState> . Considere usar CascadingAuthenticationState para fornecer isso.Authorization requires a cascading parameter of type Task\<AuthenticationState>. Consider using CascadingAuthenticationState to supply this.

  • nullo valor é recebido paraauthenticationStateTasknull value is received for authenticationStateTask

É provável que o projeto não tenha sido criado usando um Blazor Server modelo com autenticação habilitada.It's likely that the project wasn't created using a Blazor Server template with authentication enabled. Empacote uma <CascadingAuthenticationState> parte da árvore de interface do usuário, por exemplo, no App componente ( App.razor ) da seguinte maneira:Wrap a <CascadingAuthenticationState> around some part of the UI tree, for example in the App component (App.razor) as follows:

<CascadingAuthenticationState>
    <Router AppAssembly="typeof(Startup).Assembly">
        ...
    </Router>
</CascadingAuthenticationState>

O CascadingAuthenticationState fornece o Task< AuthenticationState > parâmetro em cascata, que, por sua vez, recebe do AuthenticationStateProvider serviço de injeção subjacente.The CascadingAuthenticationState supplies the Task<AuthenticationState> cascading parameter, which in turn it receives from the underlying AuthenticationStateProvider DI service.

Recursos adicionaisAdditional resources