Platforma Blazor ASP.NET Core — podstawy
Uwaga
Nie jest to najnowsza wersja tego artykułu. Aby zapoznać się z bieżącą wersją, zobacz wersję tego artykułu .NET 9.
Ostrzeżenie
Ta wersja ASP.NET Core nie jest już obsługiwana. Aby uzyskać więcej informacji, zobacz zasady pomocy technicznej platformy .NET i platformy .NET Core. Aby zapoznać się z bieżącą wersją, zobacz wersję tego artykułu .NET 9.
Ważne
Te informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany, zanim zostanie wydany komercyjnie. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.
Aby zapoznać się z bieżącą wersją, zobacz wersję tego artykułu w wersji .NET 9.
Artykuły podstawowe zawierają wskazówki na temat podstawowych Blazor pojęć. Niektóre pojęcia wiążą się z podstawową znajomością składników Razor, które dokładniej opisano w następnej sekcji tego artykułu i szczegółowo omówiono w artykułach dotyczących składników.
Pojęcia dotyczące renderowania statycznego i interaktywnego
Razor składniki są renderowane statycznie lub interaktywnie renderowane.
Renderowanie statyczne lub statyczne to scenariusz po stronie serwera, który oznacza, że składnik jest renderowany bez możliwości współdziałania między użytkownikiem a kodem .NET/C#. Zdarzenia JavaScript i HTML DOM pozostają nienaruszone, ale żadne zdarzenia użytkownika na kliencie nie mogą być przetwarzane przy użyciu platformy .NET uruchomionej na serwerze.
interaktywne/interaktywność lub interaktywne renderowanie oznacza, że składnik ma możliwość przetwarzania zdarzeń platformy .NET i powiązań za pomocą kodu C#. Zdarzenia i powiązanie platformy .NET są przetwarzane na serwerze przez środowisko uruchomieniowe ASP.NET Core lub w przeglądarce na kliencie przez środowisko uruchomieniowe Blazor oparte na WebAssembly.
Ważne
W przypadku korzystania z elementu Blazor Web Appwiększość przykładowych Blazor składników dokumentacji wymaga interakcyjności do działania i zademonstrowania pojęć omówionych w artykułach. Podczas testowania przykładowego składnika dostarczonego przez artykuł w Blazor Web Appupewnij się, że aplikacja przyjmuje globalną interakcyjność lub składnik przyjmuje tryb renderowania interaktywnego. Więcej informacji na ten temat znajduje się w sekcji Components dotyczącej ASP.NET Core Blazor trybów renderowania, która znajduje się później w zestawie dokumentacji Blazor.
Więcej informacji na temat tych pojęć i sposobu kontrolowania renderowania statycznego i interaktywnego znajduje się w artykule
Pojęcia dotyczące renderowania klienta i serwera
W całej Blazor dokumentacji działanie wykonywane w systemie użytkownika określane jest jako na kliencie lub po stronie klienta. Działanie, które odbywa się na serwerze, nazywa się, że występuje na serwerze lub po stronie serwera.
Termin rendering oznacza tworzenie znaczników HTML, które przeglądarki wyświetlają.
Renderowanie po stronie klienta (CSR) oznacza, że końcowy znacznik HTML jest generowany przez środowisko uruchomieniowe zestawu WebAssembly platformy .NET na kliencie. Kod HTML dla interfejsu użytkownika generowanego po stronie klienta aplikacji nie jest wysyłany z serwera do klienta w przypadku tego typu renderowania. Zakłada się, że użytkownik będzie wchodził w interakcję ze stroną. Nie ma takiej koncepcji, jak statyczne renderowanie po stronie klienta. Zakłada się, że CSR jest interaktywne, dlatego "interaktywne renderowanie po stronie klienta" i "interaktywne CSR" nie są używane przez branżę ani w Blazor dokumentacji.
Renderowanie po stronie serwera (SSR) oznacza, że ostateczny znacznik HTML jest generowany przez środowisko uruchomieniowe ASP.NET Core na serwerze. Kod HTML jest wysyłany do klienta za pośrednictwem sieci do wyświetlania przez przeglądarkę klienta. Klient tego typu renderowania nie tworzy kodu HTML dla interfejsu użytkownika wygenerowanego przez serwer aplikacji. SSR może mieć dwie odmiany:
- Statyczny SSR: serwer tworzy statyczny kod HTML, który nie pozwala na interaktywność użytkownika ani utrzymywania stanu komponentu Razor.
- Interaktywne SSR: Blazor zdarzenia umożliwiają interakcję użytkownika, a Razor stan komponentu jest utrzymywany przez Blazor framework.
Prerendering to proces początkowego renderowania zawartości strony na serwerze bez włączania procedur obsługi zdarzeń dla renderowanych kontrolek. Serwer zwraca interfejs użytkownika HTML strony tak szybko, jak to możliwe w odpowiedzi na początkowe żądanie, co sprawia, że aplikacja wydaje się bardziej responsywna dla użytkowników. Prerendering może również poprawić optymalizację dla wyszukiwarek internetowych (SEO) przez renderowanie zawartości w początkowej odpowiedzi HTTP używanej przez wyszukiwarki do obliczania pozycjonowania strony. Prerendering jest zawsze poprzedzone ostatecznym renderowaniem, czy to na serwerze, czy po stronie klienta.
Składniki Razor
Aplikacje Blazor są oparte na składnikach Razor, często nazywanych tylko składnikami. Składnik to element interfejsu użytkownika, taki jak strona, okno dialogowe lub formularz wprowadzania danych. Składniki to klasy języka C# na platformie .NET wbudowane w zestawy platformy .NET.
Składnia Razor odnosi się do sposobu, w jaki składniki są zwykle zapisywane w postaci strony znaczników Razor na potrzeby obsługi kompozycji i logiki interfejsu użytkownika po stronie klienta.
Razor to składnia łączenia znaczników HTML z kodem C# zaprojektowana dla zwiększenia produktywności deweloperów. W plikach Razor używa się rozszerzenia nazwy pliku .razor
.
Chociaż niektórzy deweloperzy Blazor i autorzy zasobów online używają terminu „składniki Blazor”, w dokumentacji unika się tego terminu i powszechnie używa się terminów „składniki Razor” lub „składniki”.
W dokumentacji platformy Blazor przyjmuje się kilka konwencji dotyczących prezentowania i omawiania składników:
- Ogólnie rzecz biorąc, przykłady są zgodne z konwencjami kodowania ASP.NET Core/C# i wytycznymi inżynieryjnymi. Aby uzyskać więcej informacji, zobacz następujące zasoby:
- Kod projektu, ścieżki i nazwy plików, nazwy szablonów projektu i inne terminy specjalistyczne są napisane w języku angielskim (Stany Zjednoczone) i zwykle są oznaczone jako kod.
- Składniki są zwykle określane przez nazwę swojej klasy w języku C# (z wielkimi literami jak w języku Pascal), a następnie słowem „składnik”. Na przykład typowy składnik do przesyłania plików jest nazywany „składnikiem
FileUpload
”. - Zazwyczaj nazwa klasy C# składnika jest taka sama jak jego nazwa pliku.
- Składniki podlegające trasowaniu zwykle ustawiają swoje względne adresy URL zgodnie z nazwą klasy składnika w kebab-case. Na przykład składnik
FileUpload
zawiera konfigurację routingu na potrzeby docierania do renderowanego składnika pod względnym adresem URL/file-upload
. Routing i nawigację omówiono w artykule ASP.NET Core Blazor — routing i nawigacja. - Gdy jest używanych wiele wersji składnika, są one numerowane sekwencyjnie. Na przykład
FileUpload3
składnik jest osiągany pod adresem/file-upload-3
. -
Razor dyrektywy w górnej części definicji składnika (
.razor file
) są umieszczane w następującej kolejności:@page
,@rendermode
(.NET 8 lub nowsza),@using
instrukcje, inne dyrektywy w kolejności alfabetycznej. - Chociaż nie są wymagane dla członków
private
, modyfikatory dostępu są stosowane w przykładach artykułów i aplikacjach demonstracyjnych. Na przykład parametrprivate
jest podawany w celu zadeklarowania pola o nazwiemaxAllowedFiles
jakoprivate int maxAllowedFiles = 3;
. -
Wartości parametrów składników zaczynają się od zastrzeżonego Razor
@
symbolu, ale nie jest to wymagane. Literały (na przykład wartości logiczne), słowa kluczowe (na przykładthis
), anull
jako wartości parametrów składnika nie są poprzedzone prefiksem@
, ale jest to również tylko konwencja dokumentacji. Jeśli chcesz, twój własny kod może prefiksować literały@
. - Klasy języka C# używają słowa kluczowego
this
i unikają prefiksowania pól znakiem podkreślenia (_
), które są przypisywane w konstruktorach, co różni się od wytycznych inżynieryjnych dotyczących frameworka ASP.NET Core. - W przykładach korzystających z konstruktorów podstawowych (C# 12 lub nowszych) podstawowe parametry konstruktora są zwykle używane bezpośrednio przez składowe klasy. W przykładach artykułów wiersze kodu są podzielone w celu zmniejszenia scrollowania w poziomie. Powyższe przerwy nie wpływają na działanie, ale można je usunąć podczas wklejania do projektu.
Dodatkowe informacje na Razor temat składni składników znajdują się w Razor sekcji składni składników RazorASP.NET Core.
Poniżej przedstawiono przykładowy składnik licznika i część aplikacji utworzonej na podstawie szablonu projektu Blazor. Szczegółowe omówienie składników można znaleźć w artykułach dotyczących składników w dalszej części dokumentacji. W poniższym przykładzie przedstawiono pojęcia dotyczące składników przedstawione w artykułach dotyczących podstaw, a w dalszej części dokumentacji znajdują się artykuły dotyczące składników.
Counter.razor
:
Składnik zakłada, że tryb renderowania interaktywnego jest dziedziczony z składnika nadrzędnego lub stosowany globalnie do aplikacji.
@page "/counter"
<PageTitle>Counter</PageTitle>
<h1>Counter</h1>
<p role="status">Current count: @currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int currentCount = 0;
private void IncrementCount() => currentCount++;
}
Składnik zakłada, że tryb renderowania interaktywnego jest dziedziczony z składnika nadrzędnego lub stosowany globalnie do aplikacji.
@page "/counter"
<PageTitle>Counter</PageTitle>
<h1>Counter</h1>
<p role="status">Current count: @currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int currentCount = 0;
private void IncrementCount() => currentCount++;
}
@page "/counter"
<PageTitle>Counter</PageTitle>
<h1>Counter</h1>
<p role="status">Current count: @currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int currentCount = 0;
private void IncrementCount()
{
currentCount++;
}
}
@page "/counter"
<PageTitle>Counter</PageTitle>
<h1>Counter</h1>
<p role="status">Current count: @currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int currentCount = 0;
private void IncrementCount()
{
currentCount++;
}
}
@page "/counter"
<h1>Counter</h1>
<p>Current count: @currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int currentCount = 0;
private void IncrementCount()
{
currentCount++;
}
}
@page "/counter"
<h1>Counter</h1>
<p>Current count: @currentCount</p>
<button class="btn btn-primary" @onclick="IncrementCount">Click me</button>
@code {
private int currentCount = 0;
private void IncrementCount()
{
currentCount++;
}
}
Poprzedni składnik Counter
:
- Ustawia swoją trasę za pomocą dyrektywy
@page
w pierwszym wierszu. - Ustawia tytuł i nagłówek strony.
- Renderuje bieżącą liczbę za pomocą
@currentCount
.currentCount
jest zmienną całkowitą zdefiniowaną w kodzie C# bloku@code
. - Wyświetla przycisk wyzwalający metodę
IncrementCount
, która również znajduje się w bloku@code
i zwiększa wartość zmiennejcurrentCount
.
Tryby renderowania
Artykuły w węźle Podstawy odwołują się do koncepcji trybów renderowania. Ten temat został szczegółowo omówiony w artykule ASP.NET Core Blazor tryby renderowania w węźle Składniki, który pojawia się po węźle Podstawy artykułów.
W przypadku wczesnych odwołań w tym węźle artykułów dotyczących koncepcji trybu renderowania należy pamiętać tylko o następujących kwestiach:
Każdy składnik w programie Blazor Web App przyjmuje tryb renderowania w celu określenia modelu hostingu, którego używa, gdzie jest renderowany i czy jest renderowany statycznie na serwerze, renderowany na potrzeby interakcyjności użytkownika na serwerze lub renderowany na potrzeby interakcyjności użytkownika na kliencie (zwykle z prerenderingiem na serwerze).
Blazor Server i Blazor WebAssembly aplikacje dla wersji ASP.NET Core przed platformą .NET 8 pozostają skupione na koncepcjach modelu hostingu, a nie trybach renderowania. Tryby renderowania są koncepcyjnie stosowane do Blazor Web Apps na platformie .NET 8 lub nowszej.
W poniższej tabeli przedstawiono dostępne tryby renderowania składników Razor w kontekście Blazor Web App. Tryby renderowania są stosowane do komponentów za pomocą dyrektywy @rendermode
na instancji składnika lub definicji składnika. Można również ustawić tryb renderowania dla całej aplikacji.
Nazwa/nazwisko | opis | Lokalizacja renderowania | Interakcyjny |
---|---|---|---|
Serwer statyczny | Renderowanie statyczne po stronie serwera (statyczne SSR) | Serwer | Nie |
Serwer interaktywny | Interaktywne renderowanie po stronie serwera (interaktywne SSR) przy użyciu Blazor Server | Serwer | Tak |
Interakcyjny zestaw WebAssembly | Renderowanie po stronie klienta (CSR) przy użyciu Blazor WebAssembly† | Klient | Tak |
Interaktywne Auto | Interaktywne użycie SSR z Blazor Server początkowo, a następnie CSR przy kolejnych wizytach po pobraniu pakietu Blazor | Serwer, a następnie klient | Tak |
† przyjmuje się, że renderowanie po stronie klienta (CSR) jest interaktywne. "Interaktywne renderowanie po stronie klienta" i "interaktywne CSR" nie są używane przez branżę Blazor ani w dokumentacji.
Powyższe informacje na temat trybów renderowania to wszystko, co musisz wiedzieć, aby zrozumieć artykuły o węźle "Podstawy". Jeśli dopiero zaczynasz korzystać z Blazor i czytasz artykuły Blazor po kolei według spisu treści, możesz opóźnić zapoznawanie się z szczegółowymi informacjami na temat trybów renderowania, dopóki nie dotrzesz do artykułu Tryby renderowania ASP.NET Core Blazor w węźle Składniki.
Model obiektów dokumentu (DOM)
Odwołania do modelu obiektów dokumentów używają skrótu DOM.
Aby uzyskać więcej informacji, zobacz następujące zasoby:
Podzestaw interfejsów API platformy .NET dla Blazor WebAssembly aplikacji
Wyselekcjonowana lista określonych interfejsów API platformy .NET obsługiwanych w przeglądarce Blazor WebAssembly nie jest dostępna. Można jednak ręcznie wyszukać listę interfejsów API platformy .NET oznaczonymi jako [UnsupportedOSPlatform("browser")]
, w celu odkrycia, które interfejsy API platformy .NET nie są obsługiwane w WebAssembly.
Uwaga
Linki dokumentacji do źródła referencyjnego platformy .NET zwykle ładują domyślną gałąź repozytorium, która odzwierciedla bieżące programowanie dla następnej wersji platformy .NET. Aby wybrać tag dla określonej wersji, użyj listy rozwijanej Przełącz gałęzie lub tagi. Aby uzyskać więcej informacji, zobacz Jak wybrać tag wersji kodu źródłowego platformy ASP.NET Core (dotnet/AspNetCore.Docs #26205).
Aby uzyskać więcej informacji, zobacz następujące zasoby:
- Biblioteki klas: Analizator zgodności przeglądarki po stronie klienta
-
Adnotacja interfejsów API jako nieobsługiwanych na określonych platformach (
dotnet/designs
w repozytorium GitHub
Przykładowe aplikacje
Przykładowe aplikacje z dokumentacji są dostępne do przejrzenia i pobrania:
Blazor przykładowe repozytorium GitHub (dotnet/blazor-samples
)
Znajdź przykładową aplikację, wybierając najpierw folder wersji zgodny z wersją platformy .NET, z którą pracujesz.
Przykłady aplikacji w repozytorium:
- Blazor Web App
- Blazor WebAssembly
- przykładowy samouczek dotyczący filmów Blazor Web App (Tworzenie aplikacji bazy danych filmów Blazor (omówienie))
- Blazor Web App with SignalR (Używanie ASP.NET Core SignalR z Blazor)
- Dwa Blazor Web Apps i Blazor WebAssembly aplikację do wywoływania interfejsów API sieci Web (serwerowych) (Wywołanie interfejsu API sieci Web z aplikacji ASP.NET Core Blazor)
- Blazor Web App with OIDC (BFF and non-BFF patterns) (Secure an ASP.NET Core with OpenID Connect (OIDC)) (Zabezpieczanie ASP.NET Core Blazor Web App za pomocą openID Connect (OIDC))
- Blazor Web App za pomocą usługi Entra (zabezpieczanie Blazor Web App ASP.NET Core przy użyciuidentyfikatora Entra firmy Microsoft)
- Blazor WebAssembly logowanie z obsługą zakresów (logowanie ASP.NET CoreBlazor)
- Blazor WebAssembly z ASP.NET Core (Zabezpiecz ASP.NET Core Identity z ASP.NET Core Identity)
- .NET MAUI Blazor Hybrid aplikacja z Blazor Web App i udostępnionym interfejsem użytkownika zapewnianym przez bibliotekę klas (RCL) (Zbuduj aplikację .NET MAUIBlazor Hybrid za pomocą Blazor Web App)
- Dodatkowe próbki (zobacz próbki Blazor w pliku README w repozytorium GitHub)
Przykłady aplikacji w repozytorium:
- Blazor Web App
- Blazor WebAssembly
- przykładowy samouczek dotyczący filmów Blazor Web App (Tworzenie aplikacji bazy danych filmów Blazor (omówienie))
- Blazor Web App z SignalR (Używaj ASP.NET Core SignalR z Blazor)
- Dwa Blazor Web App i aplikacja Blazor WebAssembly do wywoływania interfejsów API sieci Web (serwera) (Wywołaj interfejs API sieci Web z aplikacji ASP.NET Core Blazor)
- Blazor Web App z OIDC (wzorce BFF i nie-BFF) (Zabezpiecz ASP.NET Core Blazor Web App za pomocą OpenID Connect (OIDC))
- Blazor WebAssemblyrejestrowanie z obsługą zakresów (rejestrowanie ASP.NET CoreBlazor)
- Blazor WebAssembly z ASP.NET Core Identity (Chronienie ASP.NET Core Blazor WebAssembly przy użyciu ASP.NET Core Identity)
- .NET MAUI Blazor Hybridaplikacja z interfejsem użytkownika udostępnianym przez bibliotekę klas (RCL) Blazor Web App (Tworzenie aplikacji .NET MAUIBlazor Hybridza pomocą Blazor Web App)
- Dodatkowe próbki (zobacz próbki Blazor w pliku README w repozytorium GitHub)
Przykładowe repozytorium zawiera dwa typy przykładów:
- Aplikacje demonstracyjne z fragmentami kodu zawierają przykłady kodu zamieszczane w artykułach. Te aplikacje są kompilowane, ale niekoniecznie można je uruchomić. Te aplikacje są przydatne tylko do uzyskiwania przykładowego kodu wyświetlanego w artykułach.
- Aplikacje przykładowe towarzyszące artykułom Blazor są kompilowane i uruchamiane dla następujących scenariuszy:
- Blazor Server i Blazor WebAssembly z SignalR
- Blazor WebAssembly — rejestrowanie z włączoną obsługą zakresów
Aby uzyskać więcej informacji, listę przykładów oraz instrukcje pobierania, zapoznaj się z plikiem README repozytorium GitHub zawierającym przykłady Blazor.
Podstawowa aplikacja testowa z repozytorium ASP.NET Core to również przydatny zestaw przykładów dla różnych scenariuszy Blazor.
BasicTestApp
w źródle referencyjnym ASP.NET Core (dotnet/aspnetcore
)
Uwaga
Linki dokumentacji do źródła referencyjnego .NET zazwyczaj prowadzą do domyślnej gałęzi repozytorium, która odzwierciedla bieżący rozwój kolejnej wersji .NET. Aby wybrać tag dla określonej wersji, użyj listy rozwijanej Przełącz gałęzie lub tagi. Aby uzyskać więcej informacji, zobacz Jak wybrać tag wersji kodu źródłowego platformy ASP.NET Core (dotnet/AspNetCore.Docs #26205).
Wielokrotny bajt
Rozmiary bajtów w platformie .NET używają przedrostków metrycznych dla wielokrotności nie dziesiętnej bajtów na podstawie potęg liczby 1024.
Nazwa (skrót) | Rozmiar | Przykład |
---|---|---|
Kilobajt (KB) | 1 024 bajty | 1 KB = 1024 bajty |
Megabajt (MB) | 1 0242 bajtów | 1 MB = 1048 576 bajtów |
Gigabajt (GB) | 1,0243 bajtów | 1 GB = 1,073,741,824 bajtów |
Prośby o pomoc techniczną
Tylko problemy związane z dokumentacją są odpowiednie dla repozytorium dotnet/AspNetCore.Docs
.
W celu uzyskania pomocy technicznej dotyczącej produktów nie otwieraj problemu z dokumentacją. Poszukaj pomocy za pośrednictwem co najmniej jednego z następujących kanałów pomocy technicznej:
W przypadku potencjalnej usterki w frameworku lub opinii o produkcie, zgłoś problem dotyczący jednostki produktu ASP.NET Core w sekcji dotnet/aspnetcore
Problemy. Raporty o usterkach zwykle wymagają następujących elementów:
- Jasne wyjaśnienie problemu: postępuj zgodnie z instrukcjami w szablonie problemu w serwisie GitHub udostępnionym dla jednostki produktu podczas otwierania problemu.
- Minimalny projekt reprodukcji: Umieść projekt na GitHubie, aby inżynierowie jednostki produktowej mogli go pobrać i uruchomić. Utwórz wzajemne połączenie między projektem a otwierającym komentarzem zagadnienia.
W przypadku potencjalnego problemu z artykułem Blazor, otwórz zgłoszenie dokumentacyjne. Aby otworzyć problem z dokumentacją, użyj linku Otwórz opinię dotyczącą problemu z dokumentacją w dolnej części artykułu. Metadane dodane do zgłoszenia udostępniają dane śledzenia i automatycznie powiadamiają autora artykułu. Jeśli temat został omówiony z jednostką produktu przed otwarciem problemu z dokumentacją, umieść link krzyżowy do problemu inżynieryjnego w komentarzu otwierającym problem z dokumentacją.
W przypadku problemów lub opinii dotyczących programu Visual Studio użyj gestów Zgłoś problem lub Zasugeruj funkcję z poziomu programu Visual Studio, które otwierają wewnętrzne problemy dla programu Visual Studio. Aby uzyskać więcej informacji, zobacz Visual Studio Feedback (Opinie dotyczące programu Visual Studio).
W przypadku problemów z programem Visual Studio Code poproś o pomoc techniczną na forach pomocy technicznej społeczności. W przypadku zgłoszeń usterek i opinii o produktach otwórz zgłoszenie w repozytorium microsoft/vscode
na GitHubie.
Problemy w serwisie GitHub dotyczące dokumentacji Blazor są automatycznie oznaczane do klasyfikacji w projekcie Blazor.Docs
(repozytorium dotnet/AspNetCore.Docs
w serwisie GitHub). Poczekaj nieco na odpowiedź, zwłaszcza w weekendy i święta. Zwykle autorzy dokumentacji reagują w ciągu 24 godzin w dni powszednie.
Linki społeczności do zasobów platformy Blazor
Aby uzyskać zbiór linków do zasobów platformy Blazor obsługiwanych przez społeczność, odwiedź stronę Awesome Blazor.
Uwaga
Firma Microsoft nie jest właścicielem, nie zajmuje się konserwacją ani nie obsługuje strony Awesome Blazor ani większości produktów i usług społeczności na niej opisanych lub wskazanych.