Dela via

dotnet watch

Den här artikeln gäller för: ✔️ .NET 6 SDK och senare versioner

Namn

dotnet watch – Startar om eller laddar om det angivna programmet eller kör ett angivet dotnet-kommando när ändringar i källkoden identifieras.

Sammanfattning

dotnet watch [<command>]
  [--artifacts-path <ARTIFACTS_DIR>] [--disable-build-servers]
  [--list] [--no-hot-reload] [--no-self-contained]
  [--non-interactive] [--project <PROJECT>] [--sc|--self-contained]
  [-q|--quiet] [-v|--verbose] [--version]
  [--] <forwarded arguments> 

dotnet watch -?|-h|--help

Description

Kommandot dotnet watch är en filskådare. När en ändring identifieras körs dotnet run kommandot eller ett angivet dotnet kommando. Om den kör dotnet run, och ändringen stöds för frekvent omläsning, läses det in på nytt för det angivna programmet. Om ändringen inte stöds startas programmet om. Den här processen möjliggör snabb iterativ utveckling från kommandoraden.

När du kör dotnet watchkan du tvinga appen att återskapa och starta om genom att trycka på Ctrl+R i kommandogränssnittet. Den här funktionen är endast tillgänglig när appen körs. Om du till exempel kör dotnet watch på en konsolapp som slutar innan du trycker på Ctrl+R har det ingen effekt att trycka på Ctrl+R. I så fall dotnet watch tittar dock fortfarande filer och startar om appen om en fil uppdateras.

Svarskomprimering

Om dotnet watch körs för en app som använder svarskomprimering kan verktyget inte mata in webbläsaruppdateringsskriptet. .NET 7 och senare version av verktyget visar ett varningsmeddelande som liknar följande:

warn: Microsoft.AspNetCore.Watch.BrowserRefresh.BrowserRefreshMiddleware[4]

Det går inte att konfigurera inmatning av webbläsaruppdateringsskript för svaret. Detta kan ha orsakats av svarets Content-Encoding: 'br'. Överväg att inaktivera svarskomprimering.

Som ett alternativ till att inaktivera svarskomprimering lägger du manuellt till JavaScript-referensen för webbläsaruppdatering till appens sidor:

@if (Environment.GetEnvironmentVariable("__ASPNETCORE_BROWSER_TOOLS") is not null)
{
    <script src="/_framework/aspnetcore-browser-refresh.js"></script>
}

Arguments

  • <command>

    I .NET 7 SDK och tidigare dotnet watch kan du köra alla kommandon som skickas via den dotnet körbara filen, till exempel inbyggda CLI-kommandon och globala verktyg. Om du kan köra dotnet <command>kan du köra dotnet watch <command>.

    I .NET 8 SDK och senare dotnet watch kan du köra dotnet run, dotnet buildeller dotnet test. Ange run, buildeller test för <command>.

    Om det underordnade kommandot inte har angetts är run standardvärdet för dotnet run.

  • <forwarded arguments>

    Argument som anges efter ett dubbelstreck (--) skickas till den underordnade dotnet processen. Om du kör dotnet watch runär dessa argument alternativ för dotnet-körning. Om du kör dotnet watch testär dessa argument alternativ för dotnet-test.

Options

  • --artifacts-path <ARTIFACTS_DIR>

    Alla build-utdatafiler från det körda kommandot kommer att gå i undermappar under den angivna sökvägen, avgränsade med projekt. Mer information finns i Artefaktutdatalayout. Tillgänglig sedan .NET 8 SDK.

  • --disable-build-servers

    Tvingar kommandot att ignorera alla beständiga byggservrar. Det här alternativet är ett konsekvent sätt att inaktivera all användning av cachelagring av versioner, vilket tvingar fram en version från grunden. En version som inte förlitar sig på cacheminnen är användbar när cacheminnena kan vara skadade eller felaktiga av någon anledning. Tillgänglig sedan .NET 7 SDK.

  • --list

    Visar en lista över alla identifierade filer utan att starta bevakaren.

  • --no-self-contained

    Motsvarar --self-contained false.

  • --no-hot-reload

    Förhindra frekvent omläsning för appar som stöds.

  • --non-interactive

    Körs dotnet watch i icke-interaktivt läge. Använd det här alternativet för att förhindra att konsolindata begärs. När frekvent omläsning är aktiverat och en oförskämd redigering upptäcks startar dotnet watch om appen. Tillgänglig sedan .NET 7 SDK.

  • --project <PATH>

    Anger sökvägen till den projektfil som ska köras (endast mapp eller inklusive namnet på projektfilen). Om det inte anges används den aktuella katalogen som standard.

  • --sc|--self-contained

    Publicera .NET-körningen med ditt program så att körningen inte behöver installeras på måldatorn. Standardvärdet är true.

  • -q|--quiet

    Undertrycker alla utdata som genereras av dotnet watch kommandot förutom varningar och fel. Alternativet skickas inte till underordnade kommandon. Till exempel utdata från dotnet restore och dotnet run fortsätter att vara utdata.

  • -v|--verbose

    Visar utförliga utdata för felsökning.

  • --version

    Visar versionen av dotnet watch.

  • --

    Dubbelstrecksalternativet ('--') kan användas för att avgränsa dotnet watch alternativ från argument som skickas till den underordnade processen. Dess användning är valfri. När dubbelstrecksalternativet inte används anser dotnet watch du att det första okända argumentet är början på argument som det ska skicka till den underordnade dotnet processen.

  • -?|-h|--help

    Skriver ut en beskrivning av hur du använder kommandot.

Miljövariabler

dotnet watch använder följande miljövariabler:

  • DOTNET_HOTRELOAD_NAMEDPIPE_NAME

    Det här värdet konfigureras av dotnet watch när appen ska startas och anger det namngivna röret.

  • DOTNET_USE_POLLING_FILE_WATCHER

    När det är inställt på 1 eller trueanvänder dotnet watch använder en avsökningsfilsläsare System.IO.FileSystemWatcheri stället för . Avsökning krävs för vissa filsystem, till exempel nätverksresurser, Docker-monterade volymer och andra virtuella filsystem. Klassen PhysicalFileProvider använder DOTNET_USE_POLLING_FILE_WATCHER för att avgöra om PhysicalFileProvider.Watch metoden förlitar sig på PollingFileChangeToken.

  • DOTNET_WATCH

    dotnet watch anger den här variabeln till 1 på alla underordnade processer som den startar.

  • DOTNET_WATCH_AUTO_RELOAD_WS_HOSTNAME

    Som en del av dotnet watchläser mekanismen för webbläsaruppdateringsserver det här värdet för att fastställa WebSocket-värdmiljön. Värdet 127.0.0.1 ersätts av localhost, och schemana http:// och https:// ersätts med ws://wss:// respektive.

  • DOTNET_WATCH_ITERATION

    dotnet watch anger den här variabeln till 1 och ökar med en varje gång en fil ändras och kommandot startar om eller läser in programmet på nytt.

  • DOTNET_WATCH_SUPPRESS_BROWSER_REFRESH

    När det är inställt på 1 eller truedotnet watch uppdateras inte webbläsare när filändringar identifieras.

  • DOTNET_WATCH_SUPPRESS_EMOJIS

    Med .NET SDK 6.0.300 och senare dotnet watch genererar icke-ASCII-tecken till konsolen, enligt följande exempel:

    dotnet watch 🔥 Hot reload enabled. For a list of supported edits, see https://aka.ms/dotnet/hot-reload.
  💡 Press "Ctrl + R" to restart.
dotnet watch 🔧 Building...
dotnet watch 🚀 Started
dotnet watch ⌚ Exited
dotnet watch ⏳ Waiting for a file to change before restarting dotnet...

    På vissa konsolvärdar kan dessa tecken verka förvrängda. Om du vill undvika att se förvrängda tecken anger du den här variabeln till 1 eller true.

  • DOTNET_WATCH_SUPPRESS_LAUNCH_BROWSER

    När värdet är inställt på 1 eller true, dotnet watch startar eller uppdaterar du inte webbläsare för webbappar som har launchBrowser konfigurerats i launchSettings.json.

  • DOTNET_WATCH_SUPPRESS_MSBUILD_INCREMENTALISM

    Som standard dotnet watch optimerar bygget genom att undvika vissa åtgärder, till exempel att köra återställning eller utvärdera om uppsättningen övervakade filer vid varje filändring. Om den här variabeln är inställd på 1 eller trueinaktiveras dessa optimeringar.

  • DOTNET_WATCH_SUPPRESS_STATIC_FILE_HANDLING

    När inställningen är inställd på 1 eller true, dotnet watch kommer inte att utföra särskild hantering för statiska innehållsfiler. dotnet watch anger EGENSKAPEN DotNetWatchContentFiles MSBuild till false.

  • DOTNET_WATCH_RESTART_ON_RUDE_EDIT

    När det är inställt 1 på eller truestartas dotnet watch alltid om vid oförskämda redigeringar i stället för att fråga.

Filer som övervakas som standard

dotnet watch bevakar alla objekt i Watch objektgruppen i projektfilen. Som standard innehåller den här gruppen alla objekt i Compile grupperna och EmbeddedResource . dotnet watch söker också igenom hela diagrammet med projektreferenser och bevakar alla filer i dessa projekt.

Som standard Compile innehåller grupperna och EmbeddedResource alla filer som matchar följande globmönster:

  • **/*.cs
  • *.csproj
  • **/*.resx
  • Innehållsfiler i webbappar: wwwroot/**

Som standard utlöser .configoch .json filer inte en omstart av dotnet watch eftersom konfigurationssystemet har sina egna mekanismer för att hantera konfigurationsändringar.

Filer kan läggas till i bevakningslistan eller tas bort från listan genom att redigera projektfilen. Filer kan anges individuellt eller med hjälp av globmönster.

Titta på ytterligare filer

Fler filer kan övervakas genom att lägga till objekt i Watch gruppen. Följande markering utökar till exempel den gruppen till att omfatta JavaScript-filer:

<ItemGroup>
  <Watch Include="**\*.js" Exclude="node_modules\**\*;**\*.js.map;obj\**\*;bin\**\*" />
</ItemGroup>

Ignorera angivna filer

dotnet watch ignorerar Compile och EmbeddedResource objekt som har Watch="false" attributet, som visas i följande exempel:

<ItemGroup>
  <Compile Update="Generated.cs" Watch="false" />
  <EmbeddedResource Update="Strings.resx" Watch="false" />
</ItemGroup>

dotnet watch ignorerar projektreferenser som har Watch="false" attributet, som du ser i följande exempel:

<ItemGroup>
  <ProjectReference Include="..\ClassLibrary1\ClassLibrary1.csproj" Watch="false" />
</ItemGroup>

Avancerad konfiguration

dotnet watch utför en designtidsversion för att hitta objekt att titta på. När den här versionen körs dotnet watch anger du egenskapen DotNetWatchBuild=true. Den här egenskapen kan användas enligt följande exempel:

<ItemGroup Condition="'$(DotNetWatchBuild)'=='true'">
  <!-- only included in the project when dotnet-watch is running -->
</ItemGroup>

Snabb omladdning

Från och med .NET 6 SDK innehåller dotnet watch stöd för frekvent omläsning. Frekvent omläsning är en funktion som gör att du kan tillämpa ändringar på en app som körs utan att behöva återskapa och starta om den. Ändringarna kan vara kodfiler eller statiska tillgångar, till exempel formatmallsfiler och JavaScript-filer. Den här funktionen effektiviserar den lokala utvecklingsupplevelsen eftersom den ger omedelbar feedback när du ändrar din app.

Information om apptyper och .NET-versioner som stöder frekvent omläsning finns i .NET-appramverk och scenarier som stöds.

Oförskämda redigeringar

När en fil ändras avgör dotnet watch om appen kan läsas in på nytt. Om den inte kan läsas in på nytt kallas ändringen för en oförskämd redigering och dotnet watch frågar om du vill starta om appen:

dotnet watch ⌚ Unable to apply hot reload because of a rude edit.
  ❔ Do you want to restart your app - Yes (y) / No (n) / Always (a) / Never (v)?
  • Ja: Startar om appen.
  • Nej: Lämnar appen igång utan att ändringarna tillämpas.
  • Alltid: Startar om appen och frågar inte längre efter oförskämda redigeringar.
  • Aldrig: Lämnar appen igång utan att ändringarna tillämpas och frågar inte längre efter oförskämda redigeringar.

Information om vilka typer av ändringar som anses vara oförskämda ändringar finns i Redigera kod och fortsätt felsökning och ändringar som inte stöds i kod.

Om du vill inaktivera snabb inläsning när du kör dotnet watchanvänder --no-hot-reload du alternativet , som du ser i följande exempel:

dotnet watch --no-hot-reload

Examples

  • Kör dotnet run för projektet i den aktuella katalogen när källkoden ändras:

    dotnet watch

    Eller:

    dotnet watch run

  • Kör dotnet test för projektet i den aktuella katalogen när källkoden ändras:

    dotnet watch test

  • Kör dotnet run --project ./HelloWorld.csproj när källkoden ändras:

    dotnet watch run --project  ./HelloWorld.csproj

  • Kör dotnet run -- arg0 för projektet i den aktuella katalogen när källkoden ändras:

    dotnet watch run -- arg0

    Eller:

    dotnet watch -- run arg0

Se även