Volání webového rozhraní API z ASP.NET Core Blazor

Článek
03/10/2025

Poznámka:

Toto není nejnovější verze tohoto článku. Pro aktuální vydání si přečtěte verzi článku pro .NET 9.

Varování

Tato verze ASP.NET Core se už nepodporuje. Další informace najdete v zásadách podpory .NET a .NET Core. Aktuální verzi tohoto článku najdete v verzi .NET 9.

Důležité

Tyto informace se týkají předběžného vydání produktu, který může být podstatně změněn před komerčním vydáním. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Aktuální vydání najdete v verzi .NET 9 tohoto článku.

Tento článek popisuje, jak volat webové API z Blazor aplikace.

Balíček

Balíček System.Net.Http.Json poskytuje rozšiřující metody pro System.Net.Http.HttpClient a System.Net.Http.HttpContent, které provádějí automatickou serializaci a deserializaci pomocí System.Text.Json. Balíček System.Net.Http.Json poskytuje sdílená architektura .NET a nevyžaduje přidání odkazu na balíček do aplikace.

Ukázkové aplikace

Podívejte se na ukázkové aplikace v dotnet/blazor-samples úložišti GitHub.

`BlazorWebAppCallWebApi`

Zavolejte externí webové API seznamu úkolů (které není v Blazor Web App) z Blazor Web App:

Backend: Aplikace pro správu seznamu úkolů využívající Minimal APIs. Webová API aplikace je oddělenou aplikací od Blazor Web App a možná je hostována na jiném serveru.
BlazorApp / BlazorApp.Client: Blazor Web App, který volá webovou aplikaci API pro operace se seznamem HttpClient úkolů, jako je vytváření, čtení, aktualizace a mazání položek (CRUD) v seznamu úkolů.

Pro vykreslování na straně klienta (CSR), které zahrnuje interaktivní komponenty WebAssembly a automatické komponenty, které přijaly CSR, se provádějí volání s předem nakonfigurovaným HttpClient zaregistrovaným v Program souboru klientského projektu (BlazorApp.Client):

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

Pro vykreslování na straně serveru (SSR), které zahrnuje předrenderované a interaktivní komponenty serveru, předrenderované komponenty WebAssembly a automatické komponenty, které jsou buď předem renderované, nebo přijaly SSR, se volání provádějí s HttpClient registrovaným v Program souboru serverového projektu (BlazorApp):

builder.Services.AddHttpClient();

Volání interního (uvnitř Blazor Web App) rozhraní API seznamu filmů, ve kterém se rozhraní API nachází v serverovém projektu Blazor Web App:

BlazorApp: Blazor Web App, který udržuje seznam filmů:
- Při provádění operací v seznamu filmů v aplikaci na serveru se použijí běžná volání rozhraní API.
- Když webový klient provádí volání rozhraní API, použije se webové rozhraní API pro operace se seznamem filmů na základě minimálních rozhraní API.
BlazorApp.Client: Projekt klienta Blazor Web App, který obsahuje Interactive WebAssembly a Auto komponenty pro správu uživatelů seznamu filmů.

Pro CSR, která zahrnuje interaktivní komponenty WebAssembly a automatické komponenty, které přijaly CSR, se volání rozhraní API provádí prostřednictvím služby založené na klientovi (ClientMovieService), která používá předkonfigurovaný zaregistrovaný HttpClient v Program souboru klientského projektu (BlazorApp.Client). Vzhledem k tomu, že se tato volání provádějí přes veřejný nebo privátní web, je API seznamu filmů webové API.

Následující příklad získá seznam filmů z koncového /movies bodu:

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

Pro rozhraní SSR, které zahrnují předem vykreslené a interaktivní komponenty serveru, předem vykreslené komponenty WebAssembly a automatické komponenty, které jsou buď předem vykreslené, nebo používají SSR, se volání provádějí přímo prostřednictvím serverové služby (ServerMovieService). Rozhraní API nespoléhá na síť, takže se jedná o standardní rozhraní API pro operace CRUD seznamu filmů.

Následující příklad získá seznam filmů:

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();
}

`BlazorWebAppCallWebApi_Weather`

Ukázková aplikace dat o počasí, která používá vykreslování streamovaných dat pro data o počasí.

`BlazorWebAssemblyCallWebApi`

Volá webové API seznamu úkolů z aplikace Blazor WebAssembly.

Backend: Webová API aplikace pro správu seznamu úkolů na základě „Minimal APIs“.
BlazorTodo: Blazor WebAssembly aplikace, která volá webové API s předem nakonfigurovanými operacemi CRUD pro seznam úkolů.

Scénáře na straně klienta pro volání externích webových rozhraní API

Klientské komponenty volají externí webová API pomocí instancí HttpClient, které se obvykle vytvářejí pomocí předem nakonfigurovaného HttpClient, zaregistrovaného v souboru Program.

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

Následující Razor komponenta vytvoří požadavek na webové rozhraní API pro větve GitHubu podobně jako příklad základního použití v článku 'Vytváření požadavků HTTP pomocí IHttpClientFactory v ASP.NET Core' .

CallWebAPI.razor:

@page "/call-web-api"
@using System.Text.Json
@using System.Text.Json.Serialization
@inject HttpClient Client

<h1>Call web API from a Blazor WebAssembly 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 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; }
    }
}

V předchozím příkladu pro C# 12 a vyšší se vytvoří prázdné pole ([]) pro proměnnou branches. Pro starší verze jazyka C# zkompilované pomocí sady SDK starší než .NET 8 vytvořte prázdné pole (Array.Empty<GitHubBranch>()).

K ochraně kódu a dat .NET/C# použijte funkce ASP.NET Core Data Protection s back-endovým webovým rozhraním API na straně serveru ASP.NET Core. Klientská Blazor WebAssembly aplikace volá webové rozhraní API na straně serveru pro zabezpečené funkce aplikací a zpracování dat.

Blazor WebAssembly aplikacím se často brání v přímém volání z jednoho původu na jiný k webovým API kvůli sdílení zdrojů mezi různými originy (CORS) zabezpečení. Typická výjimka vypadá takto:

Přístup k načtení z adresy {URL} z původu 'https://localhost:{PORT}'' byl zablokován zásadami CORS: U požadovaného prostředku není přítomna hlavička 'Access-Control-Allow-Origin'. Pokud pro vaše potřeby stačí neprůhledná odpověď, nastavte režim požadavku na 'no-cors', aby se prostředek načítal se zakázaným CORS.

I když voláte SetBrowserRequestMode s polem BrowserRequestModeNoCors (1) snažícím se obejít předchozí výjimku, požadavek často selže kvůli omezením CORS u původu webového API, jako je omezení, které povoluje pouze volání z určitých původů, nebo omezení, které zabraňuje JavaScriptovým fetch požadavkům z prohlížeče. Jediný způsob, jak uspět s těmito voláními, je, aby webové API, které voláte, umožnilo zdroji vaší stránky volat jeho zdroj se správnou konfigurací CORS. Většina externích webových rozhraní API neumožňuje konfigurovat jejich zásady CORS. Pokud chcete toto omezení vyřešit, použijte některou z následujících strategií:

Udržujte si vlastní back-endové webové rozhraní API na straně serveru ASP.NET Core. Klientská aplikace Blazor WebAssembly volá webové rozhraní API na straně serveru a vaše webové rozhraní API odešle požadavek z kódu C# založeného na serveru (ne z prohlížeče) na externí webové rozhraní API se správnými hlavičkami CORS a vrátí výsledek do vaší aplikace na straně klienta Blazor WebAssembly.

Proxy služba slouží k proxy požadavku z klientské Blazor WebAssembly aplikace do externího webového rozhraní API. Proxy služba používá aplikaci na straně serveru k vytvoření požadavku jménem klienta a vrátí výsledek po úspěšném volání. V následujícím příkladu založeném na CloudFlare's CORS PROXY, je zástupný symbol {REQUEST URI} identifikátor URI požadavku:

@using System.Net
@inject IHttpClientFactory ClientFactory

...

@code {
    public async Task CallApi()
    {
        var client = ClientFactory.CreateClient();

        var urlEncodedRequestUri = WebUtility.UrlEncode("{REQUEST URI}");

        var request = new HttpRequestMessage(HttpMethod.Get, 
            $"https://corsproxy.io/?{urlEncodedRequestUri}");

        var response = await client.SendAsync(request);

        ...
    }
}

Scénáře na straně serveru pro volání externích webových rozhraní API

Serverové komponenty volají externí webová rozhraní API pomocí HttpClient instancí, obvykle vytvořených pomocí IHttpClientFactory. Pokyny, které platí pro aplikace na straně serveru, najdete v tématu Vytváření požadavků HTTP pomocí IHttpClientFactory v ASP.NET Core.

Aplikace na straně serveru nezahrnuje HttpClient službu. Poskytněte HttpClient aplikaci využitím infrastruktury HttpClient továrny.

V souboru Program:

builder.Services.AddHttpClient();

Následující Razor komponenta vytvoří požadavek na webové API pro větve GitHubu podobně jako v příkladu Základní použití v Vytváření požadavků HTTP pomocí IHttpClientFactory v 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 server-side 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; }
    }
}

V předchozím příkladu pro C# 12 nebo novější je pro proměnnou (branches) vytvořeno prázdné pole ([]). Pro starší verze jazyka C# zkompilované pomocí sady SDK starší než .NET 8 vytvořte prázdné pole (Array.Empty<GitHubBranch>()).

Další funkční příklad najdete v článku o nahrávání souborů v ASP.NET Core, kde je uveden příklad nahrání souboru na straně serveru do kontroleru webového rozhraní API.

Abstrakce služby pro volání webového rozhraní API

Tato část se vztahuje na Blazor Web App, které zajišťují webové rozhraní API v serverovém projektu nebo transformují volání webového rozhraní API na externí webové rozhraní API.

Při použití interaktivního režimu WebAssembly a automatického vykreslení jsou komponenty standardně předem vygenerovány. Automatické komponenty se také zpočátku interaktivně vykreslují ze serveru před stažením Blazor sady do klienta a aktivací modulu runtime na straně klienta. To znamená, že komponenty používající tyto režimy vykreslování by měly být navrženy tak, aby se úspěšně spouštěly z klienta i ze serveru. Pokud komponenta musí při spuštění na klientovi volat serverové projektové rozhraní API nebo transformovat požadavek na externí webové rozhraní API (které jsou mimo Blazor Web App), doporučuje se toto volání rozhraní API abstrahovat za rozhraním služby a implementovat klientské a serverové verze služby.

Verze klienta volá webové rozhraní API s předkonfigurovaným HttpClient.
Verze serveru má obvykle přímý přístup k prostředkům na straně serveru. Vložení HttpClient na server, které vyžaduje volání zpět na server, se nedoporučuje, protože síťový požadavek je obvykle zbytečný. Alternativně může být rozhraní API externí vůči serverovému projektu, ale pro server je vyžadována abstrakce služby, která transformuje požadavek nějakým způsobem, například přidáním přístupového tokenu k zprostředkované žádosti.

Při použití režimu vykreslování WebAssembly máte také možnost zakázat předběžné vykreslování, takže komponenty se vykreslují pouze z klienta. Další informace najdete v tématu renderovací režimy ASP.NET CoreBlazor.

Příklady (ukázkové aplikace):

Webové rozhraní API seznamu filmů v BlazorWebAppCallWebApi ukázkové aplikaci
Streamování webového rozhraní API pro zpracování dat o počasí v ukázkové aplikaci.
Data o počasí vrácená klientovi v ukázkových aplikacích buď s použitím BlazorWebAppOidc (vzor ne-BFF) nebo BlazorWebAppOidcBff (vzor BFF). Tyto aplikace demonstrují zabezpečená (webová) volání rozhraní API. Další informace najdete v tématu Zabezpečení ASP.NET Core Blazor Web App pomocí OpenID Connect (OIDC).

Blazor Web App externí webová rozhraní API

Tato část se týká Blazor Web Appvolání webového rozhraní API spravovaného samostatným (externím) projektem, který je pravděpodobně hostovaný na jiném serveru.

Blazor Web Apps obvykle předkreslují komponenty WebAssembly na straně klienta a Auto komponenty se vykreslují na serveru během statického nebo interaktivního server-side renderování (SSR). HttpClient služby nejsou ve výchozím nastavení zaregistrované v Blazor Web Apphlavním projektu. Pokud je aplikace spuštěna pouze se službami HttpClient zaregistrovanými v projektu .Client, jak je popsáno v části Přidat službu HttpClient, spuštění aplikace způsobí chybu za běhu:

cs-CZ: InvalidOperationException: Nelze poskytnout hodnotu pro vlastnost 'Http' typu '...{COMPONENT}'. Neexistuje žádná registrovaná služba typu System.Net.Http.HttpClient.

Použijte některý z následujících přístupů:

Přidejte služby HttpClient do projektu serveru, aby bylo HttpClient dostupné během SSR. V souboru projektu serveru Program použijte následující registraci služby:
```
builder.Services.AddHttpClient();
```
HttpClient služby jsou poskytovány sdílenou architekturou, takže není vyžadován odkaz na balíček v souboru projektu aplikace.

Příklad: Webové rozhraní API seznamu úkolů v BlazorWebAppCallWebApiukázkové aplikaci
Pokud komponenta WebAssembly, která volá webové rozhraní API, nepotřebuje prerendering, zakažte prerendering podle pokynů v ASP.NET Core Blazor render modes. Pokud tento přístup přijmete, nemusíte do hlavního HttpClient projektu přidávat Blazor Web App služby, protože tato komponenta není na serveru předem označená.

Další informace naleznete v tématu Služby na straně klienta se nedaří vyřešit během předvykreslování.

Předem vyřazovaná data

Při předkreslování se komponenty vykreslují dvakrát: nejprve staticky a interaktivně. Stav automaticky neprochází z předem vykreslené komponenty do interaktivní komponenty. Pokud komponenta provádí asynchronní inicializační operace a během inicializace vykresluje různý obsah pro různé stavy, například indikátor průběhu "Načítání...", může dojít k blikání, když se komponenta vykreslí dvakrát.

Tento problém můžete vyřešit použitím toku předem vykresleného stavu pomocí API pro stav přetrvávající komponenty, což demonstrují BlazorWebAppCallWebApi a BlazorWebAppCallWebApi_Weatherukázkové aplikace. Když se komponenta vykreslí interaktivně, bude se vykreslovat způsobem odpovídajícím danému stavu. Rozhraní API ale v současné době nefunguje s vylepšenou navigaci, kterou můžete obejít zakázáním rozšířené navigace u odkazů na stránku (data-enhanced-nav=false). Další informace naleznete v následujících zdrojích:

Streamování požadavků na straně klienta

V prohlížečích založených na Chromiu (například Google Chrome a Microsoft Edge) používajících protokol HTTP/2 a HTTPS používá Blazor na straně klienta Streams API k povolení streamování.

Pokud chcete povolit streamování požadavků, nastavte SetBrowserRequestStreamingEnabled na true v HttpRequestMessage.

V následujícím příkladu nahrání souboru:

content je HttpContentsouboru .
/Filesave je koncový bod webového rozhraní API.
Http je HttpClient.

var request = new HttpRequestMessage(HttpMethod.Post, "/Filesave");
request.SetBrowserRequestStreamingEnabled(true);
request.Content = content;

var response = await Http.SendAsync(request);

Požadavky na streamování:

Vyžaduje protokol HTTPS a nepodporuje HTTP/1.x.
Zahrňte text, ale ne hlavičku Content-Length. CORS s předběžným požadavkem se vyžaduje pro požadavky streamování mezi zdroji.

Další informace o nahrávání souborů s komponentou InputFile naleznete v tématu ASP.NET Core Blazor nahrávání souborů a příklad viz na Nahrání souborů na server s vykreslováním na straně klienta (CSR).

Přidat službu `HttpClient`

Pokyny v této části platí pro scénáře na straně klienta.

Komponenty na straně klienta volají webová rozhraní API pomocí předkonfigurované HttpClient služby, která se zaměřuje na provádění požadavků zpět na server původu. V kódu pro vývojáře je možné vytvořit další HttpClient konfigurace služby pro jiná webová rozhraní API. Žádosti se skládají pomocí Blazor pomocných rutin JSON nebo pomocí HttpRequestMessage. Požadavky můžou zahrnovat konfiguraci možností Fetch API.

Příklady konfigurace v této části jsou užitečné jenom v případě, že se pro jednu instanci v aplikaci volá jedno HttpClient webové rozhraní API. Když aplikace musí volat více webových rozhraní API, každá s vlastní základní adresou a konfigurací, můžete přijmout následující přístupy, které jsou popsány dále v tomto článku:

Pojmenované HttpClient s IHttpClientFactory: Každé webové rozhraní API má jedinečný název. Když kód aplikace nebo komponenta Razor volá webové rozhraní API, použije k volání pojmenovanou HttpClient instanci.
Typováno: HttpClientKaždé webové rozhraní API je typově definováno. Když kód aplikace nebo komponenta Razor volá webové rozhraní API, používá k volání typovou HttpClient instanci.

Program V souboru přidejte HttpClient službu, pokud ještě není k dispozici ze Blazor šablony projektu použité k vytvoření aplikace:

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

Předchozí příklad nastaví základní adresu pomocí builder.HostEnvironment.BaseAddress (IWebAssemblyHostEnvironment.BaseAddress), což určuje základní adresu aplikace a obvykle se odvozuje z hodnoty značky href<base> na hostitelské stránce.

Nejběžnější případy použití pro použití vlastní základní adresy klienta jsou:

Projekt klienta .Client (.NET 8 nebo novější) provádí volání webových API z komponentů nebo kódu WebAssembly, které běží na straně klienta v prostředí WebAssembly, do rozhraní API v serverové aplikaci.
Klientský projekt (Client) hostované aplikace Blazor WebAssembly provádí webové volání API k serverovému projektu (Server). Všimněte si, že šablona hostovaného Blazor WebAssembly projektu už není v rozhraní .NET 8 nebo novější dostupná. Hostované Blazor WebAssembly aplikace ale zůstávají podporované pro .NET 8.

Pokud voláte externí webové rozhraní API (ne ve stejném prostoru adres URL jako klientská aplikace), nastavte identifikátor URI na základní adresu webového rozhraní API. Následující příklad nastaví základní adresu webového rozhraní API na https://localhost:5001, kde je spuštěná samostatná webová aplikace API a připravená reagovat na požadavky z klientské aplikace:

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

Pomocné nástroje JSON

HttpClient je k dispozici jako předkonfigurovaná služba pro provádění požadavků zpět na původní server.

HttpClient a pomocné rutiny JSON (System.Net.Http.Json.HttpClientJsonExtensions) se také používají k volání koncových bodů webového rozhraní API třetích stran. HttpClient se implementuje pomocí rozhraní Fetch API prohlížeče a podléhá jeho omezením, včetně zásad stejného původu, které jsou popsány dále v tomto článku v části Sdílení prostředků mezi zdroji (CORS).

Základní adresa klienta je nastavená na adresu původního serveru. Vložte HttpClient instance do komponenty pomocí @inject direktivy:

@using System.Net.Http
@inject HttpClient Http

System.Net.Http.Json Použití oboru názvů pro přístup k HttpClientJsonExtensions, včetně GetFromJsonAsync, PutAsJsonAsync a PostAsJsonAsync:

@using System.Net.Http.Json

Následující části zahrnují pomocníky JSON.

GET
POST
PUT
PATCH

System.Net.Http obsahuje další metody pro odesílání požadavků HTTP a přijímání odpovědí HTTP, například pro odeslání požadavku DELETE. Další informace najdete v části DELETE a další metody pro rozšíření.

GET z JSON (`GetFromJsonAsync`)

GetFromJsonAsync odešle požadavek HTTP GET a parsuje tělo odpovědi JSON k vytvoření objektu.

V následujícím kódu jsou todoItems zobrazeny komponentou. GetFromJsonAsync je volána po dokončení inicializace komponenty (OnInitializedAsync).

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

POST as JSON (`PostAsJsonAsync`)

PostAsJsonAsync odešle požadavek POST na zadaný identifikátor URI obsahující hodnotu serializovanou jako JSON v těle požadavku.

V následujícím kódu komponenty je newItemName poskytována vázaným prvkem dané komponenty. Metoda AddItem se aktivuje výběrem elementu <button> .

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

PostAsJsonAsync vrátí hodnotu HttpResponseMessage. Použijte rozšiřující metodu ReadFromJsonAsync pro deserializaci obsahu JSON ze zprávy odpovědi. Následující příklad čte data o počasí JSON jako pole:

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

PUT as JSON (`PutAsJsonAsync`)

PutAsJsonAsync odešle požadavek HTTP PUT s obsahem kódovaným ve formátu JSON.

V následujícím kódu komponenty editItem jsou hodnoty pro Name a IsCompleted poskytovány prvky vázanými ke komponentě. Položka Id je nastavena, když je položka vybrána v jiné části uživatelského rozhraní (není zobrazena) a EditItem je volána. Metoda SaveItem se aktivuje výběrem elementu <button> . Následující příklad nezobrazuje načítání todoItems pro stručnost. Příklad načítání položek najdete v části GET z JSON (GetFromJsonAsync).

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

PutAsJsonAsync vrátí hodnotu HttpResponseMessage. K deserializaci obsahu JSON ze zprávy odpovědi použijte rozšiřující metodu ReadFromJsonAsync. Následující příklad čte data o počasí JSON jako pole:

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

PATCH as JSON (`PatchAsJsonAsync`)

PatchAsJsonAsync odešle požadavek HTTP PATCH s obsahem kódovaným ve formátu JSON.

Poznámka:

Další informace najdete v tématu JsonPatch ve webovém rozhraní API ASP.NET Core.

V následujícím příkladu PatchAsJsonAsync obdrží dokument JSON PATCH jako řetězec prostého textu s escapovanými uvozovkami.

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

Od jazyka C# 11 (.NET 7) můžete vytvořit řetězec JSON jako nezpracovaný řetězec. Zadejte syntaxi JSON s polem StringSyntaxAttribute.Json do atributu [StringSyntax] pro nástroje pro analýzu kódu:

@using System.Diagnostics.CodeAnalysis

...

@code {
    [StringSyntax(StringSyntaxAttribute.Json)]
    private const string patchOperation =
        """[{"operationType":2,"path":"/IsComplete","op":"replace","value":true}]""";

    ...

    await Http.PatchAsJsonAsync($"todoitems/{id}", patchOperation);
}

PatchAsJsonAsync vrátí hodnotu HttpResponseMessage. K deserializaci obsahu JSON ze zprávy odpovědi použijte rozšiřující metodu ReadFromJsonAsync. Následující příklad čte data položek úkolů JSON jako pole. Pokud metoda nevrací žádná data položek, vytvoří se prázdné pole, takže content po provedení příkazu není null:

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

Rozloženo s odsazením, mezerami a neuskutečňovanými uvozovkami, zobrazí se nekódovaný dokument PATCH jako následující JSON:

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

Pro zjednodušení vytváření dokumentů PATCH v aplikaci vydávajících požadavky PATCH může aplikace používat podporu .NET JSON PATCH, jak ukazuje následující doprovodné materiály.

Microsoft.AspNetCore.JsonPatch Nainstalujte balíček NuGet a pomocí funkcí rozhraní API balíčku JsonPatchDocument vytvořte požadavek PATCH.

Poznámka:

Pokyny k přidávání balíčků do aplikací .NET najdete v článcích v části Instalace a správa balíčků na webu Pracovní postup používání balíčků (dokumentace k NuGetu). Ověřte správné verze balíčků na NuGet.org.

Přidejte @using direktivy pro System.Text.Json, System.Text.Json.Serializationa Microsoft.AspNetCore.JsonPatch obory názvů na začátek Razor komponenty:

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

Sestavte JsonPatchDocument pro TodoItem s nastavením IsComplete na true pomocí metody Replace

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

Předejte operace dokumentu (patchDocument.Operations) na PatchAsJsonAsync volání:

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

JsonSerializerOptions.DefaultIgnoreCondition je nastavena tak, aby JsonIgnoreCondition.WhenWritingDefault ignorovala vlastnost pouze v případě, že se rovná výchozí hodnotě pro jeho typ.

Pokud chcete prezentovat datovou část JSON v příjemném formátu pro zobrazení, přidejte JsonSerializerOptions.WriteIndented sadu true. Zápis odsazeného formátu JSON nemá žádný vliv na zpracování požadavků PATCH a obvykle se neprovádí v produkčních aplikacích pro požadavky webového rozhraní API.

Pokud chcete do webového rozhraní API přidat akci kontroleru PATCH, postupujte podle pokynů v článku JsonPatch v ASP.NET core webovém rozhraní API. Případně je možné zpracování požadavků PATCH implementovat jako minimální rozhraní API pomocí následujícího postupu.

Přidejte odkaz na Microsoft.AspNetCore.Mvc.NewtonsoftJson balíček NuGet do aplikace webového rozhraní API.

Poznámka:

Není nutné do aplikace přidat odkaz na balíček Microsoft.AspNetCore.JsonPatch, protože odkaz na balíček Microsoft.AspNetCore.Mvc.NewtonsoftJson automaticky tranzitivně přidá odkaz na balíček Microsoft.AspNetCore.JsonPatch.

Do souboru Program přidejte direktivu @using pro obor názvů Microsoft.AspNetCore.JsonPatch.

using Microsoft.AspNetCore.JsonPatch;

Zadejte koncový bod kanálu zpracování požadavků webového rozhraní API:

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();
});

Varování

Stejně jako u ostatních příkladů v článku JsonPatch v ASP.NET Core web API nechrání uvedené PATCH API webové rozhraní API před útoky typu over-posting. Další informace najdete v tématu Kurz: Vytvoření webového rozhraní API založeného na kontroleru s ASP.NET Core.

Plně funkční prostředí PATCH najdete v BlazorWebAppCallWebApiukázkové aplikaci.

DELETE (`DeleteAsync`) a další rozšiřující metody

System.Net.Http obsahuje další metody rozšíření pro odesílání požadavků HTTP a přijímání odpovědí HTTP. HttpClient.DeleteAsync slouží k odeslání požadavku HTTP DELETE do webového rozhraní API.

V následujícím kódu komponenty volá prvek <button> metodu DeleteItem. Vázaný <input> prvek poskytuje id položku k odstranění.

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

Pojmenované `HttpClient` pomocí `IHttpClientFactory`

IHttpClientFactory jsou podporovány služby a konfigurace pojmenovaného HttpClient.

Poznámka:

Alternativou k použití pojmenovaného HttpClient z IHttpClientFactory je použití typovaného HttpClient. Další informace najdete v části Typ.HttpClient

Přidejte do Microsoft.Extensions.Http aplikace balíček NuGet.

Poznámka:

Program V souboru klientského projektu:

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

Pokud se má pojmenovaný klient používat komponentami na straně klienta předem renderovanými Blazor Web App, měla by se předchozí registrace služby objevit jak v projektu serveru, tak v projektu .Client. Na serveru builder.HostEnvironment.BaseAddress se nahrazuje základní adresou webového rozhraní API, která je popsána níže.

Předchozí příklad na straně klienta nastaví základní adresu s builder.HostEnvironment.BaseAddress (IWebAssemblyHostEnvironment.BaseAddress), která získává základní adresu pro aplikaci na straně klienta a obvykle je odvozena z hodnoty značky <base> na hostitelské stránce.

Nejběžnější případy použití pro použití vlastní základní adresy klienta jsou:

Projekt klienta (.Client), který provádí volání webového Blazor Web App rozhraní API z komponent WebAssembly/Auto nebo kódu, které běží na klientovi ve službě WebAssembly na rozhraní API v serverové aplikaci na stejné adrese hostitele.
Klientský projekt (Client) hostované Blazor WebAssembly aplikace, která provádí volání webového rozhraní API do projektu serveru (Server).

Nejběžnější případ použití pro použití vlastní základní adresy klienta je v klientském projektu (Client) hostované Blazor WebAssembly aplikace, která provádí volání webového rozhraní API do projektu serveru (Server).

Pokud voláte externí webové rozhraní API (ne ve stejném prostoru adres URL jako klientská aplikace) nebo konfigurujete služby v aplikaci na straně serveru (například pro řešení předběžného nastavení komponent na straně klienta na serveru), nastavte identifikátor URI na základní adresu webového rozhraní API. Následující příklad nastaví základní adresu webového rozhraní API na https://localhost:5001, kde je spuštěná samostatná webová aplikace API a připravená reagovat na požadavky z klientské aplikace:

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

V následujícím kódu komponenty:

Instance IHttpClientFactory vytvoří pojmenovanou HttpClient.
HttpClient se používá k vydání GET požadavku na JSON data s předpovědí počasí z webového API na adrese /forecast.

@inject IHttpClientFactory ClientFactory

...

@code {
    private Forecast[]? forecasts;

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

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

Ukázková BlazorWebAppCallWebApiaplikace ukazuje volání webového rozhraní API s názvem HttpClient ve své CallTodoWebApiCsrNamedClient komponentě. Další funkční ukázku v klientské aplikaci založenou na volání Microsoft Graphu s názvem HttpClientnajdete v tématu Použití rozhraní Graph API s ASP.NET Core Blazor WebAssembly.

Funkční ukázku v klientské aplikaci založenou na volání Microsoft Graphu s názvem HttpClientnajdete v tématu Použití rozhraní Graph API s ASP.NET Core Blazor WebAssembly.

Psaný na stroji `HttpClient`

Typed HttpClient používá k vrácení dat z jednoho nebo více koncových bodů webového rozhraní API jednu nebo více instancí aplikace HttpClient ( výchozí nebo pojmenované).

Poznámka:

Alternativou k použití zadaného typu HttpClient je použití pojmenovaného HttpClient z objektu IHttpClientFactory. Další informace najdete v části Pojmenované HttpClient s oddílem IHttpClientFactory .

Přidejte do Microsoft.Extensions.Http aplikace balíček NuGet.

Poznámka:

Následující příklad vydává požadavek GET na data předpovědi počasí JSON z webového rozhraní API na adrese /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") ?? [];
}

Program V souboru klientského projektu:

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

Pokud je typový klient používán předem předřazenými komponentami Blazor Web Appna straně klienta , měla by se předchozí registrace služby objevit v projektu serveru i projektu .Client . Na serveru builder.HostEnvironment.BaseAddress se nahrazuje základní adresou webového rozhraní API, která je popsána níže.

Předchozí příklad nastaví základní adresu na builder.HostEnvironment.BaseAddress (IWebAssemblyHostEnvironment.BaseAddress), která získá základní adresu pro aplikaci na straně klienta a obvykle je odvozena z <base> hodnoty značky href na stránce hostitele.

Nejběžnější případy použití pro použití vlastní základní adresy klienta jsou:

Projekt klienta (.Client), který provádí volání webového Blazor Web App rozhraní API z komponent WebAssembly/Auto nebo kódu, které běží na klientovi ve službě WebAssembly na rozhraní API v serverové aplikaci na stejné adrese hostitele.
Klientský projekt (Client) hostované Blazor WebAssembly aplikace, která provádí volání webového rozhraní API do projektu serveru (Server).

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

Komponenty vkládají typ HttpClient, aby bylo možné volat webové API.

V následujícím kódu komponenty:

Instance předchozího ForecastHttpClient je vložena, což vytvoří typ HttpClient.
Zadaný HttpClient se používá k odeslání GET požadavku na JSON předpověď počasí z webového API.

@inject ForecastHttpClient Http

...

@code {
    private Forecast[]? forecasts;

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

Ukázková BlazorWebAppCallWebApiaplikace ukazuje volání webového rozhraní API s typem HttpClient v jeho CallTodoWebApiCsrTypedClient komponentě. Všimněte si, že komponenta přijímá vykreslování na straně klienta (CSR) (InteractiveWebAssemblyrežim vykreslování) s předběžným vykreslováním, takže se v souboru serverového projektu i Program projektu zobrazí .Client registrace zadané klientské služby.

Pokyny v této části platí pro scénáře na straně klienta, které spoléhají na ověřování cookie.

Pro cookieověřování založené na, které je považováno za bezpečnější než ověření tokenu, je možné odesílat přihlašovací údaje s každou žádostí webového rozhraní API voláním AddHttpMessageHandler s DelegatingHandler na předkonfigurovaném HttpClient. Obslužná rutina nastavuje SetBrowserRequestCredentials s BrowserRequestCredentials.Include tak, aby prohlížeč posílal přihlašovací údaje s jednotlivými požadavky, jako jsou soubory cookie nebo hlavičky ověřování HTTP, včetně požadavků mezi zdroji.

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);
    }
}

Soubor CookieHandler je zaregistrovaný v souboru Program :

builder.Services.AddTransient<CookieHandler>();

Obslužná rutina zprávy se přidá do libovolného předkonfigurovaného objektu HttpClient , který vyžaduje cookie ověření:

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

Ukázku najdete v tématu Zabezpečení ASP.NET Core Blazor WebAssembly s ASP.NET Core Identity.

Při vytváření HttpRequestMessage požadavku prohlížeče nastavte přihlašovací údaje a hlavičku přímo:

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

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

`HttpClient` a `HttpRequestMessage` s možnostmi požadavku Fetch API

Pokyny v této části platí pro scénáře na straně klienta, které spoléhají na ověřování nosných tokenů.

HttpClient (Dokumentace k rozhraní API) a HttpRequestMessage lze ji použít k přizpůsobení požadavků. Můžete například zadat metodu HTTP a hlavičky požadavku. Následující komponenta odešle POST požadavek na koncový bod webového rozhraní API a zobrazí text odpovědi.

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; }
    }
}

BlazorImplementace HttpClient rozhraní API na straně klienta používá rozhraní Fetch API a konfiguruje základní možnosti rozhraní Fetch API specifické pro požadavky prostřednictvím HttpRequestMessage rozšiřujících metod a WebAssemblyHttpRequestMessageExtensions. Nastavte další možnosti pomocí obecné SetBrowserRequestOption metody rozšíření. Blazor a rozhraní Fetch API přímo nepřidává ani neupravuje hlavičky požadavků. Další informace o tom, jak uživatelé agenti, jako jsou prohlížeče, pracují se záhlavími, najdete v dokumentaci externích uživatelských agentů a dalších webových prostředcích.

Odpověď HTTP je obvykle uložena do vyrovnávací paměti, aby bylo možné povolit podporu synchronních čtení v obsahu odpovědi. Pokud chcete povolit podporu streamování odpovědí, použijte metodu rozšíření SetBrowserResponseStreamingEnabled na požadavek.

Pro zahrnutí přihlašovacích údajů do požadavku mezi zdroji použijte metodu rozšíření SetBrowserRequestCredentials.

requestMessage.SetBrowserRequestCredentials(BrowserRequestCredentials.Include);

Další informace o možnostech rozhraní API pro načítání najdete ve webové dokumentaci MDN: WindowOrWorkerGlobalScope.fetch(): Parametry.

Řešte chyby

Zpracování chyb odpovědí webového rozhraní API v kódu vývojáře při jejich výskytu GetFromJsonAsync Například očekává odpověď JSON z webového rozhraní API s příponou Content-Typeapplication/json. Pokud odpověď není ve formátu JSON, ověření obsahu vyvolá NotSupportedExceptionchybu .

V následujícím příkladu je koncový bod identifikátoru URI pro požadavek na data předpovědi počasí chybně napsaný. Identifikátor URI by měl být ve volání jako WeatherForcast, ale chybí mu písmeno e v Forecast.

Volání GetFromJsonAsync očekává, že se vrátí JSON, ale webové rozhraní API vrátí kód HTML pro neošetřenou výjimku s chybou Content-Typetext/html . Neošetřená výjimka nastane, protože cesta /WeatherForcast nebyla nalezena, a middleware nemůže pro daný požadavek obsluhovat ani zobrazit stránku.

Ve OnInitializedAsync na klientovi je NotSupportedException vyhozen, když je obsah odpovědi ověřen jako ne-JSON. Výjimka se zachytí v catch bloku, kde vlastní logika může chybu protokolovat nebo uživateli zobrazit popisnou chybovou zprávu.

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;
        }
    }
}

Poznámka:

Předchozí příklad je určený pro demonstrační účely. Webové rozhraní API je možné nakonfigurovat tak, aby vracelo JSON, i když koncový bod neexistuje nebo na serveru dojde k neošetřené výjimce.

Pro více informací si přečtěte Řešení chyb v aplikacích ASP.NET Core Blazor.

Zabezpečení prohlížeče často omezuje webovou stránku v možnosti provádět požadavky na jiný původ než ten, který ji poskytl. Toto omezení se označuje jako zásada stejného zdroje. Zásady stejného původu omezují (ale nebrání) škodlivému webu číst citlivá data z jiného webu. Aby bylo možné provádět žádosti z prohlížeče do koncového bodu s jiným původem, musí koncový bod povolit sdílení prostředků mezi zdroji (CORS).

Další informace o CORS na straně serveru najdete v tématu Povolení požadavků mezi zdroji (CORS) v ASP.NET Core. Příklady článku se netýkají přímo scénářů komponent Razor, ale článek je užitečný pro pochopení obecných principů CORS.

Informace o požadavcích CORS na straně klienta najdete v ASP.NET Core Blazor WebAssembly dalších scénářích zabezpečení.

Podpora ochrany proti padělání

Chcete-li přidat podporu ochrany proti padělání do požadavku HTTP, vložte AntiforgeryStateProvider a přidejte RequestToken do kolekce hlaviček jako RequestVerificationToken:

@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);
    ...
}

Další informace najdete v tématu ASP.NET Core Blazor ověřování a autorizace.

Blazor Příklady komponent architektury pro testování přístupu k webovému rozhraní API

Různé síťové nástroje jsou veřejně dostupné pro testování back-endových aplikací webového rozhraní API přímo, například vývojář prohlížeče Firefox. Blazor Referenční zdroj architektury zahrnuje HttpClient testovací prostředky, které jsou užitečné pro testování:

HttpClientTest prostředky v úložišti dotnet/aspnetcore GitHub

Poznámka:

Odkazy na dokumentaci k referenčnímu zdroji .NET obvykle načítají výchozí větev úložiště, která představuje aktuální vývoj pro příští verzi .NET. Pokud chcete vybrat značku pro konkrétní verzi, použijte rozevírací seznam pro přepnutí větví nebo značek. Další informace najdete v tématu Jak vybrat značku verze zdrojového kódu ASP.NET Core (dotnet/AspNetCore.Docs #26205).

Další materiály

Obecné

Sdílení prostředků mezi zdroji (Cross-Origin Resource Sharing, CORS) u W3C
Povolení žádostí mezi zdroji (CORS) v ASP.NET Core: I když se obsah vztahuje na aplikace ASP.NET Core, ne Razor komponenty, článek se zabývá obecnými koncepty CORS.

Zmírnění útoků nadměrným odesíláním dat

Webová rozhraní API mohou být ohrožena útokem zvaným podvržení dat, který je také známý jako útok hromadného přiřazení. Útok na nadměrné odesílání nastane, když uživatel se zlými úmysly odešle HTML formulář POST na server, který zpracovává data pro vlastnosti, jež nejsou součástí vykresleného formuláře a které vývojář nechce, aby uživatelé mohli upravovat. Pojem "overposting" doslova znamená, že uživatel se zlými úmysly provedl nadměrné množství POST požadavků při použití formuláře.

Pokyny k zmírnění útoků nadměrného vkládání najdete v tématu Kurz: Vytvoření webového rozhraní API založeného na kontroleru s ASP.NET Core.

Na straně serveru

Serverové zabezpečení v ASP.NET Core a Blazor Web App dodatečné bezpečnostní scénáře: Zahrnuje pokrytí používání HttpClient k vytváření zabezpečených požadavků na webové API.
Vytváření požadavků HTTP pomocí IHttpClientFactory v ASP.NET Core
Vynucení HTTPS v ASP.NET Core
Kestrel Konfigurace koncového bodu HTTPS

Na straně klienta

ASP.NET Core Blazor WebAssembly další scénáře zabezpečení: Zahrnuje použití HttpClient k vytváření zabezpečených požadavků webového rozhraní API.
Použití Graph API s ASP.NET Core
Fetch API

Sdílet prostřednictvím

Volání webového rozhraní API z ASP.NET Core Blazor

Balíček

Ukázkové aplikace

BlazorWebAppCallWebApi

BlazorWebAppCallWebApi_Weather

BlazorWebAssemblyCallWebApi

Scénáře na straně klienta pro volání externích webových rozhraní API

Scénáře na straně serveru pro volání externích webových rozhraní API

Abstrakce služby pro volání webového rozhraní API

Blazor Web App externí webová rozhraní API

Předem vyřazovaná data

Streamování požadavků na straně klienta

Přidat službu HttpClient

Pomocné nástroje JSON

GET z JSON (GetFromJsonAsync)

POST as JSON (PostAsJsonAsync)

PUT as JSON (PutAsJsonAsync)

PATCH as JSON (PatchAsJsonAsync)

DELETE (DeleteAsync) a další rozšiřující metody

Pojmenované HttpClient pomocí IHttpClientFactory

Psaný na stroji HttpClient

Cookie-založené přihlašovací údaje pro žádosti

HttpClient a HttpRequestMessage s možnostmi požadavku Fetch API

Řešte chyby

Sdílení zdrojů mezi doménami (Cross-Origin Resource Sharing, CORS)

Podpora ochrany proti padělání

Blazor Příklady komponent architektury pro testování přístupu k webovému rozhraní API

Další materiály

Obecné

Zmírnění útoků nadměrným odesíláním dat

Na straně serveru

Na straně klienta

Další materiály

`BlazorWebAppCallWebApi`

`BlazorWebAppCallWebApi_Weather`

`BlazorWebAssemblyCallWebApi`

Přidat službu `HttpClient`

GET z JSON (`GetFromJsonAsync`)

POST as JSON (`PostAsJsonAsync`)

PUT as JSON (`PutAsJsonAsync`)

PATCH as JSON (`PatchAsJsonAsync`)

DELETE (`DeleteAsync`) a další rozšiřující metody

Pojmenované `HttpClient` pomocí `IHttpClientFactory`

Psaný na stroji `HttpClient`

`HttpClient` a `HttpRequestMessage` s možnostmi požadavku Fetch API