Chamar uma API Web de ASP.NET Core Blazor

Este artigo descreve como chamar uma API Web de um aplicativo Blazor.

Pacote

O pacote System.Net.Http.Json fornece métodos de extensão para System.Net.Http.HttpClient e System.Net.Http.HttpContent que executam serialização e desserialização automáticas usando System.Text.Json.System.Text.Json O pacote System.Net.Http.Json é fornecido pela estrutura compartilhada do .NET e não requer a adição de uma referência de pacote ao aplicativo.

builder.Services.AddScoped(sp =>
    new HttpClient
    {
        BaseAddress = new Uri(builder.Configuration["FrontendUrl"] ?? "https://localhost:5002")
    });

builder.Services.AddHttpClient();

public class ClientMovieService(HttpClient http) : IMovieService
{
    public async Task<Movie[]> GetMoviesAsync(bool watchedMovies) => 
        await http.GetFromJsonAsync<Movie[]>("movies") ?? [];
}

public class ServerMovieService(MovieContext db) : IMovieService
{
    public async Task<Movie[]> GetMoviesAsync(bool watchedMovies) => 
        watchedMovies ? 
        await db.Movies.Where(t => t.IsWatched).ToArrayAsync() : 
        await db.Movies.ToArrayAsync();
}

Cenários do lado do servidor para chamar APIs Web externas

Os componentes baseados em servidor chamam às APIs Web externas utilizando instâncias HttpClient, normalmente criadas usando IHttpClientFactory. Para obter diretrizes que se aplicam a aplicativos do lado do servidor, consulte Fazer solicitações HTTP usando o IHttpClientFactory no ASP.NET Core.

Um aplicativo no lado do servidor não inclui um serviço HttpClient. Forneça um HttpClient ao aplicativo usando a HttpClient infraestrutura de fábrica.

No arquivo Program:

builder.Services.AddHttpClient();

O componente Razor a seguir faz uma solicitação para uma API Web para branches do GitHub semelhante ao exemplo deUso Básico no artigo Fazer solicitações HTTP usando IHttpClientFactory no ASP.NET Core.

CallWebAPI.razor:

@page "/call-web-api"
@using System.Text.Json
@using System.Text.Json.Serialization
@inject IHttpClientFactory ClientFactory

<h1>Call web API from a Blazor Server Razor component</h1>

@if (getBranchesError || branches is null)
{
    <p>Unable to get branches from GitHub. Please try again later.</p>
}
else
{
    <ul>
        @foreach (var branch in branches)
        {
            <li>@branch.Name</li>
        }
    </ul>
}

@code {
    private IEnumerable<GitHubBranch>? branches = [];
    private bool getBranchesError;
    private bool shouldRender;

    protected override bool ShouldRender() => shouldRender;

    protected override async Task OnInitializedAsync()
    {
        var request = new HttpRequestMessage(HttpMethod.Get,
            "https://api.github.com/repos/dotnet/AspNetCore.Docs/branches");
        request.Headers.Add("Accept", "application/vnd.github.v3+json");
        request.Headers.Add("User-Agent", "HttpClientFactory-Sample");

        var client = ClientFactory.CreateClient();

        var response = await client.SendAsync(request);

        if (response.IsSuccessStatusCode)
        {
            using var responseStream = await response.Content.ReadAsStreamAsync();
            branches = await JsonSerializer.DeserializeAsync
                <IEnumerable<GitHubBranch>>(responseStream);
        }
        else
        {
            getBranchesError = true;
        }

        shouldRender = true;
    }

    public class GitHubBranch
    {
        [JsonPropertyName("name")]
        public string? Name { get; set; }
    }
}

No exemplo anterior para C# 12 ou posterior, uma matriz vazia ([]) é criada para a variável branches. Para versões anteriores do C#, crie uma matriz vazia (Array.Empty<GitHubBranch>()).

Para obter um exemplo de trabalho adicional, confira o exemplo de upload de arquivo do lado do servidor que carrega arquivos em um controlador de API Web no artigo sobre uploads de arquivo Blazor do ASP.NET Core.

Adicionar o serviço HttpClient

As diretrizes nesta seção se aplicam a cenários do lado do cliente.

Os componentes do lado do cliente chamam à API Web utilizando um serviço HttpClient pré-configurado, que se concentra em fazer solicitações de volta ao servidor de origem. Configurações de serviço adicionais HttpClient para outras APIs Web podem ser criadas no código do desenvolvedor. As solicitações são compostas usando auxiliares JSON Blazor ou com HttpRequestMessage. As solicitações podem incluir a configuração de opção Buscar API.

Os exemplos de configuração nesta seção são úteis apenas quando uma única API Web é chamada para uma única instância HttpClient no aplicativo. Quando o aplicativo precisar chamar várias APIs Web, cada uma com seu próprio endereço base e configuração, você poderá adotar as seguintes abordagens, que serão tratadas mais adiante neste artigo:

• Nomeado HttpClient com IHttpClientFactory: cada API Web recebe um nome exclusivo. Quando o código do aplicativo ou um componente Razor chama uma API Web, ele usa uma instância HttpClient nomeada para fazer a chamada.
• Tipada HttpClient: cada API Web é tipada. Quando o código do aplicativo ou um Razorcomponente chama uma API da web, ele usa uma instância tipada HttpClient para fazer a chamada.

No arquivo Program, adicione um serviço HttpClient se ele ainda não estiver presente em um modelo de projeto Blazor utilizado para criar o aplicativo:

builder.Services.AddScoped(sp => 
    new HttpClient
    {
        BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
    });

O exemplo anterior define o endereço base com builder.HostEnvironment.BaseAddress (IWebAssemblyHostEnvironment.BaseAddress), que obtém o endereço base do aplicativo e é normalmente derivado do valor href da tag <base> na página do host.

Os casos de uso mais comuns para usar o endereço base do próprio cliente são:

• O projeto cliente (.Client) de um Blazor Web App (.NET 8 ou posterior) faz chamadas à API Web a partir de componentes WebAssembly ou código executado no cliente em WebAssembly a APIs no aplicativo do servidor.
• O projeto cliente (Client) de um aplicativo hospedado Blazor WebAssembly faz chamadas à API Web para o projeto do servidor (Server). Observe que o modelo de projeto Blazor WebAssembly hospedado não está mais disponível no .NET 8 ou posterior. No entanto, os aplicativos hospedados Blazor WebAssembly permanecem com suporte pelo .NET 8.

Se estiver chamando uma API Web externa (que não esteja no mesmo espaço de URL que o aplicativo cliente), defina o URI como o endereço base da API Web. O exemplo a seguir define o endereço base da API Web como https://localhost:5001, no qual um aplicativo de API Web separado está em execução e pronto para responder às solicitações do aplicativo cliente:

builder.Services.AddScoped(sp => 
    new HttpClient
    {
        BaseAddress = new Uri("https://localhost:5001")
    });

Auxiliares JSON

HttpClient está disponível como um serviço pré-configurado para fazer solicitações de volta ao servidor de origem.

Os auxiliares HttpClient e JSON (System.Net.Http.Json.HttpClientJsonExtensions) também são usados para chamar pontos de extremidade da API Web de terceiros. HttpClient é implementado usando a API de busca do navegador e está sujeito a suas limitações, incluindo a imposição da política de mesma origem, que é discutida posteriormente neste artigo na seção Compartilhamento de Recursos entre Origens (CORS).

O endereço base do cliente é definido como o endereço do servidor de origem. Insere uma instância HttpClient em um componente usando a diretiva @inject:

@using System.Net.Http
@inject HttpClient Http

Use o namespace System.Net.Http.Json para acessar HttpClientJsonExtensions, incluindo GetFromJsonAsync, PutAsJsonAsync e PostAsJsonAsync:

@using System.Net.Http.Json

As seções a seguir abrangem os auxiliares JSON:

• GET
• POST
• PUT
• PATCH

System.Net.Http inclui métodos de extensão adicionais para enviar solicitações HTTP e receber respostas HTTP. Para obter mais informações, consulte a seção DELETE e métodos de extensão adicionais seção.

GET de JSON (GetFromJsonAsync)

GetFromJsonAsync envia uma solicitação HTTP GET e analisa o corpo da resposta JSON para criar um objeto.

No código do componente a seguir, os todoItems são exibidos pelo componente. GetFromJsonAsync é chamado quando o componente é concluído inicializando (OnInitializedAsync).

todoItems = await Http.GetFromJsonAsync<TodoItem[]>("todoitems");

POST como JSON (PostAsJsonAsync)

PostAsJsonAsync envia uma solicitação POST ao URI especificado que contém o valor serializado como JSON no corpo da solicitação.

No código do componente a seguir, newItemName é fornecido por um elemento associado do componente. O método AddItem é disparado selecionando um elemento <button>.

await Http.PostAsJsonAsync("todoitems", addItem);

PostAsJsonAsync retorna um HttpResponseMessage. Para desserializar o conteúdo JSON da mensagem de resposta, use o método de extensão ReadFromJsonAsync. O exemplo a seguir lê dados meteorológicos JSON como uma matriz:

var content = await response.Content.ReadFromJsonAsync<WeatherForecast[]>() ?? 
    Array.Empty<WeatherForecast>();

PUT como JSON (PutAsJsonAsync)

PutAsJsonAsync envia uma solicitação HTTP PUT com conteúdo codificado em JSON.

No código do componente a seguir, os valores editItem para Name e IsCompleted são fornecidos por elementos associados do componente. O Id do item é definido quando o item é selecionado em outra parte da interface do usuário (não mostrado) e EditItem é chamado. O método SaveItem é disparado selecionando o elemento <button>. O exemplo a seguir não mostra o carregamento de todoItems para fins de brevidade. Consulte a seção GET de JSON (GetFromJsonAsync) para ver um exemplo de itens de carregamento.

await Http.PutAsJsonAsync($"todoitems/{editItem.Id}", editItem);

PutAsJsonAsync retorna um HttpResponseMessage. Para desserializar o conteúdo JSON da mensagem de resposta, use o método de extensão ReadFromJsonAsync. O exemplo a seguir lê dados meteorológicos JSON como uma matriz:

var content = await response.Content.ReadFromJsonAsync<WeatherForecast[]>() ?? 
    Array.Empty<WeatherForecast>();

await Http.PatchAsJsonAsync(
    $"todoitems/{id}", 
    "[{\"operationType\":2,\"path\":\"/IsComplete\",\"op\":\"replace\",\"value\":true}]");

var response = await Http.PatchAsJsonAsync(...);
var content = await response.Content.ReadFromJsonAsync<TodoItem[]>() ??
    Array.Empty<TodoItem>();

[
  {
    "operationType": 2,
    "path": "/IsComplete",
    "op": "replace",
    "value": true
  }
]

@using System.Text.Json
@using System.Text.Json.Serialization
@using Microsoft.AspNetCore.JsonPatch

var patchDocument = new JsonPatchDocument<TodoItem>()
    .Replace(p => p.IsComplete, true);

private async Task UpdateItem(long id)
{
    await Http.PatchAsJsonAsync(
        $"todoitems/{id}", 
        patchDocument.Operations, 
        new JsonSerializerOptions()
        {
            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingDefault
        });
}

using Microsoft.AspNetCore.JsonPatch;

app.MapPatch("/todoitems/{id}", async (long id, TodoContext db) =>
{
    if (await db.TodoItems.FindAsync(id) is TodoItem todo)
    {
        var patchDocument = 
            new JsonPatchDocument<TodoItem>().Replace(p => p.IsComplete, true);
        patchDocument.ApplyTo(todo);
        await db.SaveChangesAsync();

        return TypedResults.Ok(todo);
    }

    return TypedResults.NoContent();
});

DELETE (DeleteAsync) e métodos de extensão adicionais

System.Net.Http inclui métodos de extensão adicionais para enviar solicitações HTTP e receber respostas HTTP. HttpClient.DeleteAsync é usado para enviar uma solicitação HTTP DELETE para uma API Web.

No código do componente a seguir, o <button> elemento chama o método DeleteItem. O elemento associado <input> fornece o item id a ser excluído.

await Http.DeleteAsync($"todoitems/{id}");

HttpClient nomeado com IHttpClientFactory

IHttpClientFactory há suporte para os serviços e a configuração de um HttpClient nomeado.

Adicione o Pacote NuGet Microsoft.Extensions.Http ao aplicativo.

No arquivo Program de um projeto cliente:

builder.Services.AddHttpClient("WebAPI", client => 
    client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress));

O exemplo do lado do cliente anterior define o endereço base com builder.HostEnvironment.BaseAddress (IWebAssemblyHostEnvironment.BaseAddress), que obtém o endereço base do aplicativo do lado do cliente e é normalmente derivado do valor href da tag <base> na página do host.

Se você estiver chamando uma API Web externa (não no mesmo espaço de URL do aplicativo cliente) ou estiver configurando os serviços em um aplicativo do lado do servidor (por exemplo, para lidar com a pré-renderização de componentes do lado do cliente no servidor), defina o URI como o endereço base da API Web. O exemplo a seguir define o endereço base da API Web como https://localhost:5001, no qual um aplicativo de API Web separado está em execução e pronto para responder às solicitações do aplicativo cliente:

builder.Services.AddHttpClient("WebAPI", client => 
    client.BaseAddress = new Uri("https://localhost:5001"));

No seguinte código do componente:

• Uma instância de IHttpClientFactory cria um nome HttpClient.
• O HttpClient nomeado é usado para emitir uma solicitação GET para os dados de previsão do tempo JSON na API Web em /forecast.

@inject IHttpClientFactory ClientFactory

...

@code {
    private Forecast[]? forecasts;

    protected override async Task OnInitializedAsync()
    {
        var client = ClientFactory.CreateClient("WebAPI");

        forecasts = await client.GetFromJsonAsync<Forecast[]>("forecast") ?? [];
    }
}

HttpClient tipado

O HttpClient tipado usa uma ou mais instâncias do aplicativo HttpClient, padrão ou nomeado, para retornar dados de um ou mais pontos de extremidade da API Web.

Adicione o Pacote NuGet Microsoft.Extensions.Http ao aplicativo.

O exemplo a seguir emite uma solicitação GET para dados de previsão do tempo JSON na API Web em /forecast.

ForecastHttpClient.cs:

using System.Net.Http.Json;

namespace BlazorSample.Client;

public class ForecastHttpClient(HttpClient http)
{
    public async Task<Forecast[]> GetForecastAsync() => 
        await http.GetFromJsonAsync<Forecast[]>("forecast") ?? [];
}

No arquivo Program de um projeto cliente:

builder.Services.AddHttpClient<ForecastHttpClient>(client => 
    client.BaseAddress = new Uri(builder.HostEnvironment.BaseAddress));

O exemplo anterior define o endereço base com builder.HostEnvironment.BaseAddress (IWebAssemblyHostEnvironment.BaseAddress), que obtém o endereço base do aplicativo do lado do cliente e é normalmente derivado do valor href da tag <base> na página do host.

Se você estiver chamando uma API Web externa (não no mesmo espaço de URL do aplicativo cliente) ou estiver configurando os serviços em um aplicativo do lado do servidor (por exemplo, para lidar com a pré-renderização de componentes do lado do cliente no servidor), defina o URI como o endereço base da API Web. O exemplo a seguir define o endereço base da API Web como https://localhost:5001, no qual um aplicativo de API Web separado está em execução e pronto para responder às solicitações do aplicativo cliente:

builder.Services.AddHttpClient<ForecastHttpClient>(client => 
    client.BaseAddress = new Uri("https://localhost:5001"));

Os componentes injetam o HttpClient tipado para chamar a API Web.

No seguinte código do componente:

• Uma instância da ForecastHttpClient anterior é injetada, o que cria um HttpClient tipado.
• O HttpClient digitado é usado para emitir uma solicitação GET para dados de previsão do tempo JSON na API Web.

@inject ForecastHttpClient Http

...

@code {
    private Forecast[]? forecasts;

    protected override async Task OnInitializedAsync()
    {
        forecasts = await Http.GetForecastAsync();
    }
}

Credenciais de solicitação baseadas em Cookie

As diretrizes nesta seção se aplicam a cenários do lado do cliente que dependem de uma autenticação cookie.

Para autenticação baseada em cookie, que é considerada mais segura do que a autenticação de token de portador, as credenciais cookie podem ser enviadas com cada solicitação de API Web chamando AddHttpMessageHandler com um DelegatingHandler em um HttpClient pré-configurado. O manipulador configura SetBrowserRequestCredentials com BrowserRequestCredentials.Include, que aconselha o navegador a enviar credenciais com cada solicitação, como cookies ou cabeçalhos de autenticação HTTP, inclusive para solicitações entre origens.

CookieHandler.cs:

public class CookieHandler : DelegatingHandler
{
    protected override Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        request.SetBrowserRequestCredentials(BrowserRequestCredentials.Include);
        request.Headers.Add("X-Requested-With", ["XMLHttpRequest"]);

        return base.SendAsync(request, cancellationToken);
    }
}

CookieHandler é registrado no arquivo Program:

builder.Services.AddTransient<CookieHandler>();

O manipulador de mensagens é adicionado a qualquer HttpClient pré-configurado que exija autenticação cookie:

builder.Services.AddHttpClient(...)
    .AddHttpMessageHandler<CookieHandler>();

Ao compor um HttpRequestMessage, defina as credenciais de solicitação do navegador e o cabeçalho diretamente:

var requestMessage = new HttpRequestMessage() { ... };

requestMessage.SetBrowserRequestCredentials(BrowserRequestCredentials.Include);
requestMessage.Headers.Add("X-Requested-With", ["XMLHttpRequest"]);

HttpClient e HttpRequestMessage com opções de solicitação de API Fetch

As diretrizes nesta seção se aplicam a cenários do lado do cliente que dependem da autenticação de token de portador.

HttpClient (Documentaçãoda API) e HttpRequestMessage pode ser usado para personalizar solicitações. Por exemplo, você pode especificar o método HTTP e os cabeçalhos de solicitação. O componente a seguir faz uma solicitação POST para um ponto de extremidade da API Web e mostra o corpo da resposta.

TodoRequest.razor:

@page "/todo-request"
@using System.Net.Http.Headers
@using Microsoft.AspNetCore.Components.WebAssembly.Authentication
@inject HttpClient Http
@inject IAccessTokenProvider TokenProvider

<h1>ToDo Request</h1>

<h1>ToDo Request Example</h1>

<button @onclick="PostRequest">Submit POST request</button>

<p>Response body returned by the server:</p>

<p>@responseBody</p>

@code {
    private string? responseBody;

    private async Task PostRequest()
    {
        var requestMessage = new HttpRequestMessage()
        {
            Method = new HttpMethod("POST"),
            RequestUri = new Uri("https://localhost:10000/todoitems"),
            Content =
                JsonContent.Create(new TodoItem
                {
                    Name = "My New Todo Item",
                    IsComplete = false
                })
        };

        var tokenResult = await TokenProvider.RequestAccessToken();

        if (tokenResult.TryGetToken(out var token))
        {
            requestMessage.Headers.Authorization =
                new AuthenticationHeaderValue("Bearer", token.Value);

            requestMessage.Content.Headers.TryAddWithoutValidation(
                "x-custom-header", "value");

            var response = await Http.SendAsync(requestMessage);
            var responseStatusCode = response.StatusCode;

            responseBody = await response.Content.ReadAsStringAsync();
        }
    }

    public class TodoItem
    {
        public long Id { get; set; }
        public string? Name { get; set; }
        public bool IsComplete { get; set; }
    }
}

A implementação do lado do cliente de Blazor por parte do HttpClient usa a API de Fetch e configura as opções subjacentes da API de Fetch específicas da solicitação por meio dos métodos de extensão HttpRequestMessage e de WebAssemblyHttpRequestMessageExtensions. Defina opções adicionais usando o método de extensão genérico SetBrowserRequestOption. O Blazor e a API de Fetch subjacente não adiciona nem modifica diretamente os cabeçalhos de solicitação. Para obter mais informações sobre como os agentes de usuário, como navegadores, interagem com os cabeçalhos, consulte os conjuntos de documentação de agentes de usuário externos e outros recursos da Web.

A resposta HTTP normalmente é armazenada em buffer para habilitar o suporte para leituras síncronas no conteúdo da resposta. Para habilitar o suporte para streaming de resposta, use o método de extensão SetBrowserResponseStreamingEnabled na solicitação.

Para incluir credenciais em uma solicitação entre origens, use o método de extensão SetBrowserRequestCredentials:

requestMessage.SetBrowserRequestCredentials(BrowserRequestCredentials.Include);

Para obter mais informações sobre as opções da API fetch, consulte Documentos da Web MDN: WindowOrWorkerGlobalScope.fetch(): Parâmetros.

Tratar erros

Manipule erros de resposta da API Web no código do desenvolvedor quando eles ocorrem. Por exemplo, GetFromJsonAsync espera uma resposta JSON da API Web com um Content-Type de application/json. Se a resposta não estiver no formato JSON, a validação de conteúdo gerará um NotSupportedException.

No exemplo a seguir, o ponto de extremidade do URI para a solicitação de dados de previsão do tempo está escrito incorretamente. O URI deve ser para WeatherForecast, mas aparece na chamada como WeatherForcast, o que está faltando na letra e em Forecast.

A chamada GetFromJsonAsync espera que JSON seja retornado, mas a API Web retorna HTML para uma exceção sem tratamento com um Content-Type de text/html. A exceção sem tratamento ocorre porque o caminho para /WeatherForcast não foi encontrado e o middleware não pode servir a uma página ou exibição para a solicitação.

No OnInitializedAsync cliente, NotSupportedException é gerado quando o conteúdo da resposta é validado como não JSON. A exceção é capturada no bloco, em que a lógica catch personalizada pode registrar o erro ou apresentar uma mensagem de erro amigável ao usuário.

ReturnHTMLOnException.razor:

@page "/return-html-on-exception"
@using {PROJECT NAME}.Shared
@inject HttpClient Http

<h1>Fetch data but receive HTML on unhandled exception</h1>

@if (forecasts == null)
{
    <p><em>Loading...</em></p>
}
else
{
    <h2>Temperatures by Date</h2>

    <ul>
        @foreach (var forecast in forecasts)
        {
            <li>
                @forecast.Date.ToShortDateString():
                @forecast.TemperatureC &#8451;
                @forecast.TemperatureF &#8457;
            </li>
        }
    </ul>
}

<p>
    @exceptionMessage
</p>

@code {
    private WeatherForecast[]? forecasts;
    private string? exceptionMessage;

    protected override async Task OnInitializedAsync()
    {
        try
        {
            // The URI endpoint "WeatherForecast" is misspelled on purpose on the 
            // next line. See the preceding text for more information.
            forecasts = await Http.GetFromJsonAsync<WeatherForecast[]>("WeatherForcast");
        }
        catch (NotSupportedException exception)
        {
            exceptionMessage = exception.Message;
        }
    }
}

Para obter mais informações, confira Manipular erros nos aplicativos Blazor do ASP.NET Core.

Compartilhamento de Recursos entre Origens (CORS)

A segurança do navegador restringe uma página da Web de fazer solicitações para um domínio diferente daquele que serviu a página da Web. Essa restrição é chamada de política de mesma origem. A política de mesma origem restringe (mas não impede) que um site mal-intencionado leia dados confidenciais de outro site. Para fazer solicitações do navegador para um ponto de extremidade com uma origem diferente, o ponto de extremidade deve habilitar o Compartilhamento de Recursos entre Origens (CORS).

Para obter mais informações sobre o CORS do lado do servidor, consulte Habilitar o CORS (Solicitações entre Origens) no ASP.NET Core. Os exemplos do artigo não se referem diretamente a cenários de componentes Razor, mas o artigo é útil para aprender conceitos gerais de CORS.

Para obter informações sobre solicitações CORS do lado do cliente, consulte ASP.NET Core Blazor WebAssembly cenários de segurança adicionais.

@inject AntiforgeryStateProvider Antiforgery

private async Task OnSubmit()
{
    var antiforgery = Antiforgery.GetAntiforgeryToken();
    var request = new HttpRequestMessage(HttpMethod.Post, "action");
    request.Headers.Add("RequestVerificationToken", antiforgery.RequestToken);
    var response = await client.SendAsync(request);
    ...
}

Exemplos de componente da estrutura Blazor para testar o acesso à API Web

Várias ferramentas de rede estão disponíveis publicamente para testar aplicativos de back-end da API Web diretamente, como o Desenvolvedor do Firefox Browser. Blazor A origem de referência da estrutura inclui ativos de teste HttpClient que são úteis para teste:

Ativos HttpClientTest no dotnet/aspnetcore repositório GitHub

Recursos adicionais

Geral

• CORS (Compartilhamento de Recursos entre Origens) no W3C
• Habilitar as solicitações entre Origens (CORS) no ASP.NET Core: embora o conteúdo se aplique a aplicativos ASP.NET Core, e não a componentes Razor, o artigo aborda conceitos gerais de CORS.

Mitigação de ataques de excesso de postagem

As APIs Web podem ser vulneráveis a um ataque de excesso de postagem, também conhecido como ataque de atribuição em massa. Um ataque de excesso de postagem ocorre quando um usuário mal-intencionado emite um POST de formulário HTML para o servidor que processa dados para propriedades que não fazem parte do formulário renderizado e que o desenvolvedor não deseja permitir que os usuários modifiquem. O termo “excesso de postagem” literalmente significa que o usuário mal-intencionado ultrapassou o limite de POSTs com o formulário.

Para obter diretrizes sobre como mitigar ataques de excesso de postagem, consulte Tutorial: Criar uma API Web com ASP.NET Core.

Lado do servidor

• Cenários de segurança adicionais do Blazor do ASP.NET Core: inclui cobertura sobre como usar HttpClient para fazer solicitações de API Web seguras.
• Fazer solicitações HTTP usando IHttpClientFactory no ASP.NET Core
• Impor HTTPS no ASP.NET Core
• Kestrel Configuração do ponto de extremidade HTTPS

Lado do cliente

• Cenários de segurança adicionais Blazor WebAssembly do ASP.NET Core: inclui cobertura sobre como usar HttpClient para fazer solicitações de API Web seguras.
• Usar a API do Graph com o ASP.NET Core Blazor WebAssembly
• API Fetch