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 Web Apps 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 pakietu wewnętrznego (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 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 elementu Blazor Web App w środowisku IDE

Program Visual Studio

W przykładzie w tej sekcji założono, że utworzono Blazor Web App obiekt z interaktywnym trybem renderowania auto (serwer i zestaw WebAssembly) oraz lokalizacją interakcyjności 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. Po wybraniu projektu serwera w Eksplorator rozwiązań naciśnij 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 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. W aplikacji serwera otwórz statycznie renderowany Weather składnik (Components/Pages/Weather.razor) i ustaw punkt przerwania w dowolnym miejscu w metodzie OnInitializedAsync .
3. Naciśnij F5 , aby uruchomić aplikację w debugerze.
4. W przeglądarce przejdź do Weather strony pod adresem /weather. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wykonywanie aplikacji zatrzymuje się w punkcie przerwania.
5. Naciśnij 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 Program OnInitialized{Async} metodach cyklu życia składników ładowanych przez pierwszą stronę żądaną z aplikacji.

Visual Studio Code

W przykładzie w tej sekcji przyjęto założenie, że utworzono Blazor Web App obiekt 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 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 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 Shift+F5 na klawiaturze.
2. W aplikacji serwera otwórz statycznie renderowany Weather składnik (Components/Pages/Weather.razor) i ustaw punkt przerwania w dowolnym miejscu w metodzie OnInitializedAsync .
3. Wybierz przycisk Rozpocznij debugowanie w interfejsie użytkownika lub naciśnij F5 (Rozpocznij debugowanie), aby uruchomić aplikację w debugerze.
4. W przeglądarce przejdź do Weather strony pod adresem /weather. Poczekaj kilka sekund na załadowanie i uruchomienie serwera proxy debugowania. Wykonywanie aplikacji zatrzymuje się w punkcie przerwania.
5. Wybierz przycisk Kontynuuj w interfejsie użytkownika lub naciśnij 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 Program OnInitialized{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 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 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 Program OnInitialized{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 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 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 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 Program OnInitialized{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.

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ą dotnet watch polecenia (lub dotnet run).

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

3. Rozpocznij debugowanie zdalne, naciskając:

   • 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ę 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ą dotnet watch polecenia (lub 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 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 F5 , aby kontynuować wykonywanie na karcie debugowania.

Przerwij w nieobsługiwane wyjątki

Debuger nie przerywa obsługi nieobsługiwane wyjątki, ponieważ Blazor przechwytuje wyjątki nieobsługiwane przez kod dewelopera.

Aby przerwać w nieobsługiwane wyjątki:

• Otwórz ustawienia wyjątku debugera (Debuguj>ustawienia wyjątków systemu Windows>) 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 NodeJS w 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.