Debugowanie aplikacji ASP.NET Core

W tym artykule opisano sposób debugowania Blazor aplikacji, w tym debugowania Blazor WebAssembly aplikacji za pomocą narzędzi deweloperskich przeglądarki lub zintegrowanego środowiska projektowego (IDE).

Blazor Aplikacje internetowe można debugować w programie Visual Studio lub Visual Studio Code.

Blazor WebAssembly aplikacje można debugować:

• W programie Visual Studio lub Visual Studio Code.
• Korzystanie z narzędzi programistycznych przeglądarki w przeglądarkach opartych na Chromium, w tym Przeglądarki Microsoft Edge, Google Chrome i Firefox.

Dostępne scenariusze debugowania Blazor WebAssembly obejmują:

• Ustawianie i usuwanie punktów przerwania.
• Uruchom aplikację z obsługą debugowania w środowiskach IDE.
• Jednoetapowy kod.
• Wznów wykonywanie kodu za pomocą skrótu klawiaturowego w środowiskach IDE.
• W oknie Ustawienia lokalne obserwuj wartości zmiennych lokalnych.
• Zobacz stos wywołań, w tym łańcuchy wywołań między językiem JavaScript i platformą .NET.
• Użyj serwera symboli do debugowania skonfigurowanego przez preferencje programu Visual Studio.

Nieobsługiwane scenariusze obejmują:

• Debugowanie w scenariuszach innych niż lokalne (na przykład Podsystem Windows dla systemu Linux (WSL) lub Visual Studio Codespaces.
• Debuguj w przeglądarce Firefox z poziomu programu Visual Studio lub Visual Studio Code.

Wymagania wstępne

W tej sekcji opisano wymagania wstępne dotyczące debugowania.

Wymagania wstępne dotyczące przeglądarki

Najnowsza wersja następujących przeglądarek:

• Google Chrome
• Microsoft Edge
• Firefox (tylko narzędzia deweloperskie przeglądarki)

Upewnij się, że zapory lub serwery proxy nie blokują komunikacji z serwerem proxy debugowania (NodeJS proces). Aby uzyskać więcej informacji, zobacz sekcję Konfiguracja zapory.

Uwaga

Przeglądarka Apple Safari w systemie macOS nie jest obecnie obsługiwana.

Wymagania wstępne dotyczące środowiska IDE

Wymagana jest najnowsza wersja programu Visual Studio lub Visual Studio Code.

Wymagania wstępne programu Visual Studio Code

Program Visual Studio Code wymaga zestawu Deweloperskiego języka C# dla programu Visual Studio Code (Wprowadzenie do języka C# w programie VS Code). W witrynie Marketplace rozszerzeń programu Visual Studio Code przefiltruj listę rozszerzeń za pomocą ciągu "c# dev kit", aby zlokalizować rozszerzenie:

Zainstalowanie zestawu deweloperskiego języka C# powoduje automatyczne zainstalowanie następujących dodatkowych rozszerzeń:

• Narzędzie instalacji platformy .NET
• C#
• IntelliCode for C# Dev Kit

Jeśli wystąpią ostrzeżenia lub błędy, możesz otworzyć problem (microsoft/vscode-dotnettools repozytorium GitHub) opisujący problem.

Wymagania wstępne dotyczące konfiguracji aplikacji

Wskazówki zawarte w tej podsekcji dotyczą debugowania po stronie klienta.

Properties/launchSettings.json Otwórz plik projektu startowego. Potwierdź obecność następującej inspectUri właściwości w każdym profilu uruchamiania węzła profiles pliku. Jeśli następująca właściwość nie jest obecna, dodaj ją do każdego profilu:

"inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}"

Właściwość inspectUri :

• Umożliwia środowisku IDE wykrywanie, że aplikacja jest aplikacją Blazor .
• Instruuje infrastrukturę debugowania skryptu w celu nawiązania połączenia z przeglądarką za pośrednictwem Blazorserwera proxy debugowania.

Wartości zastępcze protokołu WebSocket (), hosta (wsProtocolurl.hostname), portu (url.port) i identyfikatora URI inspektora w uruchomionej przeglądarce (browserInspectUri) są udostępniane przez platformę.

Pakiety

Blazor Web Apps: : Microsoft.AspNetCore.Components.WebAssembly.Serverodwołuje się do wewnętrznego pakietu (Microsoft.NETCore.BrowserDebugHost.Transport) dla zestawów, które współużytkuje hosta debugowania przeglądarki.

Blazor WebAssemblyAutonomiczny: : Microsoft.AspNetCore.Components.WebAssembly.DevServerserwer deweloperów do użycia podczas kompilowania Blazor aplikacji. Wywołuje WebAssemblyNetDebugProxyAppBuilderExtensions.UseWebAssemblyDebugging wewnętrznie, aby dodać oprogramowanie pośredniczące do debugowania Blazor WebAssembly aplikacji wewnątrz narzędzi deweloperskich Chromium.

Uwaga

Aby uzyskać instrukcje dodawania pakietów do aplikacji .NET, zobacz artykuły w sekcji Instalowanie pakietów i zarządzanie nimi w temacie Przepływ pracy użycia pakietów (dokumentacja programu NuGet). Sprawdź prawidłowe wersje pakietów pod adresem NuGet.org.

Debugowanie Blazor aplikacji internetowej w środowisku IDE

Program Visual Studio

W przykładzie w tej sekcji założono, że utworzono aplikację Blazor internetową z interaktywnym trybem renderowania automatycznego (serwera i zestawu WebAssembly) oraz lokalizacji interakcyjności dla poszczególnych składników.

1. Otwórz aplikację.
2. Ustaw punkt przerwania w currentCount++; wierszu w składniku Counter (Pages/Counter.razor) projektu klienta (.Client).
3. Naciśnij klawisz F5 , aby uruchomić aplikację w debugerze.
4. W przeglądarce przejdź do Counter strony pod adresem /counter. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wybierz przycisk Kliknij mnie, aby nacisnąć punkt przerwania.
5. W programie Visual Studio sprawdź wartość currentCount pola w oknie Ustawienia lokalne .
6. Naciśnij klawisz F5 , aby kontynuować wykonywanie.

Punkty przerwania można również trafić w projekcie serwera w statycznie renderowanych i interaktywnie renderowanych składnikach po stronie serwera.

1. Zatrzymaj debuger.

2. Dodaj następujący składnik do aplikacji serwera. Składnik stosuje tryb renderowania interaktywnego serwera (InteractiveServer).

   Components/Pages/Counter2.razor:

   @page "/counter-2"
   @rendermode InteractiveServer
   
   <PageTitle>Counter 2</PageTitle>
   
   <h1>Counter 2</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++;
       }
   }
   

3. Ustaw punkt przerwania currentCount++; w wierszu w składniku Counter2 .

4. Naciśnij klawisz F5 , aby uruchomić aplikację w debugerze.

5. W przeglądarce przejdź do Counter2 strony pod adresem /counter-2. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wybierz przycisk Kliknij mnie, aby nacisnąć punkt przerwania.

6. Naciśnij klawisz F5 , aby kontynuować wykonywanie.

Punkty przerwania nie są osiągane podczas uruchamiania aplikacji przed uruchomieniem serwera proxy debugowania. Obejmuje to punkty przerwania w pliku i punkty przerwania w ProgramOnInitialized{Async} metodach cyklu życia składników ładowanych przez pierwszą stronę żądaną z aplikacji.

Visual Studio Code

W przykładzie w tej sekcji założono, że utworzono aplikację Blazor internetową z interaktywnym trybem renderowania automatycznego (serwera i zestawu WebAssembly) oraz lokalizacją interakcyjności dla poszczególnych składników.

1. Otwórz aplikację w programie Visual Studio Code, otwierając folder rozwiązania, który jest folderem zawierającym serwer i .Client foldery projektu.
2. Ustaw punkt przerwania w currentCount++; wierszu w składniku Counter (Pages/Counter.razor) projektu klienta (.Client).
3. Otwórz okienko Uruchamianie i debugowanie, a następnie wybierz przycisk Uruchom i Debuguj. Alternatywnie naciśnij klawisz F5 (Rozpocznij debugowanie). C# Wybierz debuger w palecie poleceń w górnej części interfejsu użytkownika. Wybierz profil domyślny projektu serwera (na przykład C#:BlazorSample [Default Configuration]).
4. W przeglądarce przejdź do Counter strony pod adresem /counter. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wybierz przycisk Kliknij mnie, aby nacisnąć punkt przerwania.
5. Wybierz przycisk Kontynuuj w interfejsie użytkownika lub naciśnij klawisz F5 (Kontynuuj), aby kontynuować wykonywanie.

Punkty przerwania można również trafić w projekcie serwera.

1. Zatrzymaj debugowanie, wybierając przycisk Zatrzymaj lub naciśnij klawisze Shift+F5 na klawiaturze.

2. Dodaj następujący składnik do aplikacji serwera. Składnik przyjmuje tryb renderowania serwera interaktywnego (InteractiveServer).

   Components/Pages/Counter2.razor:

   @page "/counter-2"
   @rendermode InteractiveServer
   
   <PageTitle>Counter 2</PageTitle>
   
   <h1>Counter 2</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++;
       }
   }
   

3. Ustaw punkt przerwania currentCount++; w wierszu w składniku Counter2 .

4. Wybierz przycisk Rozpocznij debugowanie w interfejsie użytkownika lub naciśnij klawisz F5 (Rozpocznij debugowanie), aby uruchomić aplikację w debugerze.

5. W przeglądarce przejdź do Counter2 strony pod adresem /counter-2. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wybierz przycisk Kliknij mnie, aby nacisnąć punkt przerwania.

6. Wybierz przycisk Kontynuuj w interfejsie użytkownika lub naciśnij klawisz F5 (Kontynuuj), aby kontynuować wykonywanie.

Punkty przerwania nie są osiągane podczas uruchamiania aplikacji przed uruchomieniem serwera proxy debugowania. Obejmuje to punkty przerwania w pliku i punkty przerwania w ProgramOnInitialized{Async} metodach cyklu życia składników ładowanych przez pierwszą stronę żądaną z aplikacji.

Nie można uruchomić bez debugowania [Ctrl+F5 (Windows) lub ⌘+F5 (macOS)] nie jest obsługiwane. Gdy aplikacja jest uruchamiana w konfiguracji debugowania, debugowanie zawsze powoduje zmniejszenie wydajności.

Debugowanie Blazor WebAssembly aplikacji w środowisku IDE

Program Visual Studio

1. Otwórz aplikację.
2. Ustaw punkt przerwania currentCount++; w wierszu w składniku Counter (Pages/Counter.razor).
3. Naciśnij klawisz F5 , aby uruchomić aplikację w debugerze.
4. W przeglądarce przejdź do Counter strony pod adresem /counter. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wybierz przycisk Kliknij mnie, aby nacisnąć punkt przerwania.
5. W programie Visual Studio sprawdź wartość currentCount pola w oknie Ustawienia lokalne .
6. Naciśnij klawisz F5 , aby kontynuować wykonywanie.

Punkty przerwania nie są osiągane podczas uruchamiania aplikacji przed uruchomieniem serwera proxy debugowania. Obejmuje to punkty przerwania w pliku i punkty przerwania w ProgramOnInitialized{Async} metodach cyklu życia składników ładowanych przez pierwszą stronę żądaną z aplikacji.

Visual Studio Code

1. Otwórz folder aplikacji w programie Visual Studio Code.
2. Ustaw punkt przerwania currentCount++; w wierszu w składniku Counter (Pages/Counter.razor).
3. Otwórz okienko Uruchamianie i debugowanie, a następnie wybierz przycisk Uruchom i Debuguj. Alternatywnie naciśnij klawisz F5 (Rozpocznij debugowanie). C# Wybierz debuger w palecie poleceń w górnej części interfejsu użytkownika. Wybierz profil domyślny (na przykład C#:BlazorSample [Default Configuration]).
4. Naciśnij klawisz F5 , aby uruchomić aplikację w debugerze.
5. Aplikacja autonomiczna jest uruchamiana i otwierana jest przeglądarka debugowania.
6. W przeglądarce przejdź do Counter strony pod adresem /counter. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wybierz przycisk Kliknij mnie, aby nacisnąć punkt przerwania.
7. Naciśnij klawisz F5 , aby kontynuować wykonywanie.

Punkty przerwania nie są osiągane podczas uruchamiania aplikacji przed uruchomieniem serwera proxy debugowania. Obejmuje to punkty przerwania w pliku i punkty przerwania w ProgramOnInitialized{Async} metodach cyklu życia składników ładowanych przez pierwszą stronę żądaną z aplikacji.

Nie można uruchomić bez debugowania [Ctrl+F5 (Windows) lub ⌘+F5 (macOS)] nie jest obsługiwane. Gdy aplikacja jest uruchamiana w konfiguracji debugowania, debugowanie zawsze powoduje zmniejszenie wydajności.

Obsługa debugera

Debugowanie jest włączone dla środowiska uruchomieniowego, gdy obsługa debugera jest włączona z elementem <DebuggerSupport>{VALUE}</DebuggerSupport>, gdzie {VALUE} element zastępczy ma true wartość lub false.

Domyślnie platforma Blazorwyłącza obsługę debugera dla wszystkich konfiguracji innych niż debugowanie. Aby włączyć obsługę debugera dla konfiguracji innej niż debugowanie, dodaj <DebuggerSupport> właściwość do pliku projektu aplikacji.

W poniższym przykładzie obsługa debugera jest włączona dla niestandardowej konfiguracji "DebugCustom":

<DebuggerSupport Condition="'$(Configuration)' == 'DebugCustom'">true</DebuggerSupport>

Aby uzyskać więcej informacji, zobacz Blazor WebAssembly niestandardową konfigurację debugera (dotnet/runtime #96239).

Dołączanie do istniejącej sesji debugowania programu Visual Studio Code

Aby dołączyć do uruchomionej Blazor aplikacji, otwórz .vscode/launch.json plik i zastąp {URL} symbol zastępczy adresem URL, pod którym działa aplikacja:

{
  "name": "Attach and Debug",
  "type": "blazorwasm",
  "request": "attach",
  "url": "{URL}"
}

Opcje uruchamiania programu Visual Studio Code

Opcje konfiguracji uruchamiania w poniższej tabeli są obsługiwane dla blazorwasm typu debugowania (.vscode/launch.json).

Opcja	Opis
browser	Przeglądarka do uruchomienia na potrzeby sesji debugowania. Ustaw edge lub chrome. Wartość domyślna to edge.
cwd	Katalog roboczy do uruchamiania aplikacji w obszarze.
request	Służy launch do uruchamiania i dołączania sesji debugowania do Blazor WebAssembly aplikacji lub attach dołączania sesji debugowania do już uruchomionej aplikacji.
timeout	Liczba milisekund oczekiwania na dołączenie sesji debugowania. Wartość domyślna to 30 000 milisekund (30 sekund).
trace	Służy do generowania JS dzienników z debugera. Ustaw wartość na wartość , aby true wygenerować dzienniki.
url	Adres URL do otwarcia w przeglądarce podczas debugowania.
webRoot	Określa ścieżkę bezwzględną serwera internetowego. Należy ustawić, jeśli aplikacja jest obsługiwana z podkierowania.

Debugowanie Blazor WebAssembly za pomocą przeglądarki Google Chrome lub Przeglądarki Microsoft Edge

Wskazówki w tej sekcji dotyczą aplikacji debugowania Blazor WebAssembly w:

• Przeglądarka Google Chrome uruchomiona w systemie Windows lub macOS.
• Przeglądarka Microsoft Edge uruchomiona w systemie Windows.

1. Uruchom aplikację w powłoce poleceń za pomocą polecenia dotnet run.

2. Uruchom przeglądarkę i przejdź do adresu URL aplikacji.

3. Rozpocznij debugowanie zdalne, naciskając klawisze:

   • Shift+Alt+d w systemie Windows.
   • Shift+⌘+d w systemie macOS.

   Przeglądarka musi być uruchomiona z włączonym debugowaniem zdalnym, co nie jest domyślne. Jeśli debugowanie zdalne jest wyłączone, zostanie renderowana strona błędu karty Nie można odnaleźć debugowalnej karty przeglądarki z instrukcjami dotyczącymi uruchamiania przeglądarki z otwartym portem debugowania. Postępuj zgodnie z instrukcjami przeglądarki.

   Po wykonaniu instrukcji umożliwiających zdalne debugowanie aplikacja zostanie otwarta w nowym oknie przeglądarki. Rozpocznij debugowanie zdalne, naciskając kombinację klawisza HotKey w nowym oknie przeglądarki:

   • Shift+Alt+d w systemie Windows.
   • Shift+⌘+d w systemie macOS.

   Zostanie otwarta nowa karta przeglądarki narzędzi deweloperskich narzędzi dla deweloperów z wyświetlonym obrazem upiornym aplikacji.

   Uwaga

   Jeśli wykonano instrukcje otwierania nowej karty przeglądarki z włączonym debugowaniem zdalnym, możesz zamknąć oryginalne okno przeglądarki, pozostawiając drugie okno otwarte przy użyciu pierwszej karty z uruchomioną aplikacją i drugą kartą z uruchomionym debugerem.

4. Po chwili na karcie Źródła zostanie wyświetlona lista zestawów i stron platformy .NET aplikacji.

5. file:// Otwórz węzeł. W kodzie składnika (.razor plikach) i plikach kodu C# (.cs) punkty przerwania ustawione są osiągane po wykonaniu kodu na karcie przeglądarki aplikacji (początkowa karta otwarta po rozpoczęciu debugowania zdalnego). Po osiągnięciu punktu przerwania pojedynczy krok (F10) za pośrednictwem kodu lub wznowienia (F8) wykonywania kodu zwykle na karcie debugowania.

W przypadku debugowania przeglądarki opartego na chromium udostępnia serwer proxy debugowania, Blazor który implementuje protokół Chrome DevTools i rozszerza protokół za pomocą polecenia . Informacje specyficzne dla platformy NET. Po naciśnięciu Blazor skrótu klawiaturowego debugowania program Chrome DevTools wskazuje serwer proxy. Serwer proxy łączy się z oknem przeglądarki, które chcesz debugować (stąd potrzeba włączenia debugowania zdalnego).

Debugowanie aplikacji za Blazor WebAssembly pomocą przeglądarki Firefox

Wskazówki zawarte w tej sekcji dotyczą aplikacji debugowania Blazor WebAssembly w przeglądarce Firefox działającej w systemie Windows.

Debugowanie aplikacji za Blazor WebAssembly pomocą przeglądarki Firefox wymaga skonfigurowania przeglądarki na potrzeby zdalnego debugowania i nawiązywania połączenia z przeglądarką przy użyciu narzędzi deweloperskich przeglądarki za pośrednictwem serwera proxy debugowania zestawu WebAssembly platformy .NET.

Uwaga

Debugowanie w programie Firefox z poziomu programu Visual Studio nie jest obecnie obsługiwane.

Aby debugować aplikację Blazor WebAssembly w przeglądarce Firefox podczas programowania:

1. Skonfiguruj przeglądarkę Firefox:
   • Otwórz about:config w nowej karcie przeglądarki. Przeczytaj i odrzuć wyświetlone ostrzeżenie.
   • Włącz devtools.debugger.remote-enabled , ustawiając jego wartość na True.
   • Włącz devtools.chrome.enabled , ustawiając jego wartość na True.
   • Wyłącz devtools.debugger.prompt-connection , ustawiając jego wartość na False.
2. Zamknij wszystkie wystąpienia przeglądarki Firefox.
3. Uruchom aplikację w powłoce poleceń za pomocą polecenia dotnet run.
4. Uruchom ponownie przeglądarkę Firefox i przejdź do aplikacji.
5. Otwórz about:debugging w nowej karcie przeglądarki. Pozostaw tę kartę otwartą.
6. Wróć do karty, na której działa aplikacja. Rozpocznij debugowanie zdalne, naciskając klawisze Shift+Alt+d.
7. Debugger Na karcie otwórz plik źródłowy aplikacji, który chcesz debugować w węźle file:// i ustaw punkt przerwania. Na przykład ustaw punkt przerwania w currentCount++; wierszu w IncrementCount metodzie Counter składnika (Pages/Counter.razor).
8. Przejdź do Counter strony składnika (/counter) na karcie przeglądarki aplikacji i wybierz przycisk licznika, aby przejść do punktu przerwania.
9. Naciśnij klawisz F5 , aby kontynuować wykonywanie na karcie debugowania.

Przerwij w nieobsługiwane wyjątki

Debuger domyślnie nie przerywa obsługi nieobsługiwane wyjątki, ponieważ Blazor przechwytuje wyjątki, które nie są obsługiwane przez kod dewelopera.

Aby przerwać w nieobsługiwane wyjątki:

• Otwórz ustawienia wyjątku debugera (Debugowanie>wyjątku systemu Windows>Ustawienia) w programie Visual Studio.
• Ustaw następujące ustawienia wyjątków języka JavaScript:
  • Wszystkie wyjątki
  • Wyjątki nieuchwycone

Mapy źródłowe przeglądarki

Mapy źródłowe przeglądarki umożliwiają przeglądarce mapowanie skompilowanych plików z powrotem na oryginalne pliki źródłowe i są często używane do debugowania po stronie klienta. Blazor Jednak obecnie nie mapuje języka C# bezpośrednio na język JavaScript/WASM. Zamiast tego, czy interpretacja IL w przeglądarce, Blazor więc mapy źródłowe nie są istotne.

Konfiguracja zapory

Jeśli zapora blokuje komunikację z serwerem proxy debugowania, utwórz regułę wyjątku zapory zezwalającą na komunikację między przeglądarką a procesem NodeJS .

Ostrzeżenie

Aby uniknąć tworzenia luk w zabezpieczeniach, należy wprowadzić modyfikację konfiguracji zapory. Uważnie zastosuj wskazówki dotyczące zabezpieczeń, postępuj zgodnie z najlepszymi rozwiązaniami w zakresie zabezpieczeń i przestrzegaj ostrzeżeń wydanych przez producenta zapory.

Zezwalanie na otwartą komunikację z procesem NodeJS :

• Otwiera serwer Node z dowolnym połączeniem, w zależności od możliwości i konfiguracji zapory.
• Może to być ryzykowne w zależności od sieci.
• Jest zalecana tylko na maszynach deweloperskich.

Jeśli to możliwe, zezwalaj tylko na otwartą komunikację z procesem NodeJSw zaufanych lub prywatnych sieciach.

Aby uzyskać wskazówki dotyczące konfiguracji zapory systemu Windows, zobacz Tworzenie programu przychodzącego lub reguły usługi. Aby uzyskać więcej informacji, zobacz Zapora Windows Defender z zabezpieczeniami zaawansowanymi i powiązanymi artykułami w zestawie dokumentacji Zapory systemu Windows.

Rozwiązywanie problemów

Jeśli występują błędy, następujące porady mogą pomóc:

• Usuń punkty przerwania:
  • Google Chrome: na karcie Debuger otwórz narzędzia deweloperskie w przeglądarce. W konsoli programu wykonaj polecenie localStorage.clear() , aby usunąć wszystkie punkty przerwania.
  • Microsoft Edge: na karcie Aplikacja otwórz magazyn lokalny. Kliknij prawym przyciskiem myszy witrynę i wybierz polecenie Wyczyść.
• Upewnij się, że zainstalowano i zaufano certyfikatowi programistycznego ASP.NET Core HTTPS. Aby uzyskać więcej informacji, zobacz Wymuszanie protokołu HTTPS w ASP.NET Core.
• Program Visual Studio wymaga opcji Włącz debugowanie języka JavaScript dla ASP.NET (Chrome i Edge) w obszarze Narzędzia>Opcje>Debugowanie>ogólne. Jest to ustawienie domyślne programu Visual Studio. Jeśli debugowanie nie działa, upewnij się, że wybrano opcję .
• Jeśli środowisko używa serwera proxy HTTP, upewnij się, że localhost jest on uwzględniony w ustawieniach obejścia serwera proxy. Można to zrobić, ustawiając zmienną NO_PROXY środowiskową w dowolnym z następujących elementów:
  • launchSettings.json Plik projektu.
  • Na poziomie zmiennych środowiskowych użytkownika lub systemu do zastosowania do wszystkich aplikacji. W przypadku używania zmiennej środowiskowej uruchom ponownie program Visual Studio, aby zmiany zaczęły obowiązywać.
• Upewnij się, że zapory lub serwery proxy nie blokują komunikacji z serwerem proxy debugowania (NodeJS proces). Aby uzyskać więcej informacji, zobacz sekcję Konfiguracja zapory.

Punkty przerwania w OnInitialized{Async} nie trafieniu

Blazor Serwer proxy debugowania platformy nie uruchamia się natychmiast podczas uruchamiania aplikacji, więc punkty przerwania w OnInitialized{Async} metodach cyklu życia mogą nie zostać trafione. Zalecamy dodanie opóźnienia na początku treści metody w celu nadania serwerowi proxy debugowania trochę czasu na uruchomienie przed trafieniem punktu przerwania. Opóźnienie można uwzględnić na if podstawie dyrektywy kompilatora, aby upewnić się, że opóźnienie nie występuje w przypadku kompilacji wydania aplikacji.

OnInitialized:

protected override void OnInitialized()
{
#if DEBUG
    Thread.Sleep(10000);
#endif

    ...
}

OnInitializedAsync:

protected override async Task OnInitializedAsync()
{
#if DEBUG
    await Task.Delay(10000);
#endif

    ...
}

Limit czasu programu Visual Studio (Windows)

Jeśli program Visual Studio zgłasza wyjątek, że nie można uruchomić karty debugowania, wskazując, że osiągnięto limit czasu, możesz dostosować limit czasu za pomocą ustawienia Rejestru:

VsRegEdit.exe set "<VSInstallFolder>" HKCU JSDebugger\Options\Debugging "BlazorTimeoutInMilliseconds" dword {TIMEOUT}

Symbol {TIMEOUT} zastępczy w poprzednim poleceniu znajduje się w milisekundach. Na przykład jedna minuta jest przypisywana jako 60000.