private async Task <int> HandleWatch(CommandLineOptions options)
{
// update reporter as configured by options
_reporter = CreateReporter(options.Verbose, options.Quiet, _console);
try
{
if (_cts.IsCancellationRequested)
{
return(1);
}
if (options.List)
{
return(await ListFilesAsync(_reporter,
options.Project,
_cts.Token));
}
else
{
return(await MainInternalAsync(_reporter,
options.Project,
options.RemainingArguments,
_cts.Token));
}
}
catch (Exception ex)
{
if (ex is TaskCanceledException || ex is OperationCanceledException)
{
// swallow when only exception is the CTRL+C forced an exit
return(0);
}
_reporter.Error(ex.ToString());
_reporter.Error("An unexpected error occurred");
return(1);
}
}
private async Task <int> MainInternalAsync(
IReporter reporter,
string project,
IReadOnlyCollection <string> args,
CancellationToken cancellationToken)
{
// TODO multiple projects should be easy enough to add here
string projectFile;
try
{
projectFile = MsBuildProjectFinder.FindMsBuildProject(_workingDirectory, project);
}
catch (FileNotFoundException ex)
{
reporter.Error(ex.Message);
return(1);
}
var watchOptions = DotNetWatchOptions.Default;
var fileSetFactory = new MsBuildFileSetFactory(reporter,
watchOptions,
projectFile,
waitOnError: true,
trace: false);
var processInfo = new ProcessSpec
{
Executable = new Muxer().MuxerPath,
WorkingDirectory = Path.GetDirectoryName(projectFile),
Arguments = args,
EnvironmentVariables =
{
["DOTNET_WATCH"] = "1"
},
};
if (CommandLineOptions.IsPollingEnabled)
{
_reporter.Output("Polling file watcher is enabled");
}
await using var watcher = new DotNetWatcher(reporter, fileSetFactory, watchOptions);
await watcher.WatchAsync(processInfo, cancellationToken);
return(0);
}
private async Task <int> ListFilesAsync(
IReporter reporter,
string project,
CancellationToken cancellationToken)
{
// TODO multiple projects should be easy enough to add here
string projectFile;
try
{
projectFile = MsBuildProjectFinder.FindMsBuildProject(_workingDirectory, project);
}
catch (FileNotFoundException ex)
{
reporter.Error(ex.Message);
return(1);
}
var fileSetFactory = new MsBuildFileSetFactory(
reporter,
DotNetWatchOptions.Default,
projectFile,
waitOnError: false,
trace: false);
var files = await fileSetFactory.CreateAsync(cancellationToken);
if (files == null)
{
return(1);
}
foreach (var file in files)
{
_console.Out.WriteLine(file.FilePath);
}
return(0);
}
public async Task WatchAsync(DotNetWatchContext context, CancellationToken cancellationToken)
{
var processSpec = context.ProcessSpec;
if (context.SuppressMSBuildIncrementalism)
{
_reporter.Verbose("MSBuild incremental optimizations suppressed.");
}
_reporter.Output("Hot reload enabled. For a list of supported edits, see https://aka.ms/dotnet/hot-reload. " +
"Press \"Ctrl + R\" to restart.");
while (true)
{
context.Iteration++;
for (var i = 0; i < _filters.Length; i++)
{
await _filters[i].ProcessAsync(context, cancellationToken);
}
// Reset for next run
context.RequiresMSBuildRevaluation = false;
processSpec.EnvironmentVariables["DOTNET_WATCH_ITERATION"] = (context.Iteration + 1).ToString(CultureInfo.InvariantCulture);
var fileSet = context.FileSet;
if (fileSet == null)
{
_reporter.Error("Failed to find a list of files to watch");
return;
}
if (!fileSet.Project.IsNetCoreApp60OrNewer())
{
_reporter.Error($"Hot reload based watching is only supported in .NET 6.0 or newer apps. Update the project's launchSettings.json to disable this feature.");
return;
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (context.Iteration == 0)
{
ConfigureExecutable(context, processSpec);
}
using var currentRunCancellationSource = new CancellationTokenSource();
var forceReload = _console.ListenForForceReloadRequest();
using var combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(
cancellationToken,
currentRunCancellationSource.Token,
forceReload);
using var fileSetWatcher = new FileSetWatcher(fileSet, _reporter);
try
{
using var hotReload = new HotReload(_processRunner, _reporter);
await hotReload.InitializeAsync(context, cancellationToken);
var processTask = _processRunner.RunAsync(processSpec, combinedCancellationSource.Token);
var args = string.Join(" ", processSpec.Arguments);
_reporter.Verbose($"Running {processSpec.ShortDisplayName()} with the following arguments: {args}");
_reporter.Output("Started");
Task <FileItem?> fileSetTask;
Task finishedTask;
while (true)
{
fileSetTask = fileSetWatcher.GetChangedFileAsync(combinedCancellationSource.Token);
finishedTask = await Task.WhenAny(processTask, fileSetTask).WaitAsync(combinedCancellationSource.Token);
if (finishedTask != fileSetTask || fileSetTask.Result is not FileItem fileItem)
{
// The app exited.
break;
}
else
{
_reporter.Output($"File changed: {fileItem.FilePath}.");
var start = Stopwatch.GetTimestamp();
if (await hotReload.TryHandleFileChange(context, fileItem, combinedCancellationSource.Token))
{
var totalTime = TimeSpan.FromTicks(Stopwatch.GetTimestamp() - start);
_reporter.Output($"Hot reload of changes succeeded.");
_reporter.Verbose($"Hot reload applied in {totalTime.TotalMilliseconds}ms.");
}
else
{
_reporter.Verbose($"Unable to handle changes to {fileItem.FilePath}. Rebuilding the app.");
break;
}
}
}
// Regardless of the which task finished first, make sure everything is cancelled
// and wait for dotnet to exit. We don't want orphan processes
currentRunCancellationSource.Cancel();
await Task.WhenAll(processTask, fileSetTask);
if (processTask.Result != 0 && finishedTask == processTask && !cancellationToken.IsCancellationRequested)
{
// Only show this error message if the process exited non-zero due to a normal process exit.
// Don't show this if dotnet-watch killed the inner process due to file change or CTRL+C by the user
_reporter.Error($"Exited with error code {processTask.Result}");
}
else
{
_reporter.Output("Exited");
}
if (finishedTask == processTask)
{
// Process exited. Redo evaludation
context.RequiresMSBuildRevaluation = true;
// Now wait for a file to change before restarting process
context.ChangedFile = await fileSetWatcher.GetChangedFileAsync(cancellationToken, () => _reporter.Warn("Waiting for a file to change before restarting dotnet..."));
}
else
{
Debug.Assert(finishedTask == fileSetTask);
var changedFile = fileSetTask.Result;
context.ChangedFile = changedFile;
}
}
public async Task <FileSet> CreateAsync(CancellationToken cancellationToken)
{
var watchList = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
var projectDir = Path.GetDirectoryName(_projectFile);
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
var capture = _outputSink.StartCapture();
var arguments = new List <string>
{
"msbuild",
"/nologo",
_projectFile,
$"/p:_DotNetWatchListFile={watchList}",
};
if (_dotNetWatchOptions.SuppressHandlingStaticContentFiles)
{
arguments.Add("/p:DotNetWatchContentFiles=false");
}
arguments.AddRange(_buildFlags);
var processSpec = new ProcessSpec
{
Executable = _muxerPath,
WorkingDirectory = projectDir,
Arguments = arguments,
OutputCapture = capture
};
_reporter.Verbose($"Running MSBuild target '{TargetName}' on '{_projectFile}'");
var exitCode = await _processRunner.RunAsync(processSpec, cancellationToken);
if (exitCode == 0 && File.Exists(watchList))
{
using var watchFile = File.OpenRead(watchList);
var result = await JsonSerializer.DeserializeAsync <MSBuildFileSetResult>(watchFile, cancellationToken : cancellationToken);
var fileItems = new List <FileItem>();
foreach (var project in result.Projects)
{
var value = project.Value;
var fileCount = value.Files.Count;
for (var i = 0; i < fileCount; i++)
{
fileItems.Add(new FileItem
{
FilePath = value.Files[i],
ProjectPath = project.Key,
});
}
var staticItemsCount = value.StaticFiles.Count;
for (var i = 0; i < staticItemsCount; i++)
{
var item = value.StaticFiles[i];
fileItems.Add(new FileItem
{
FilePath = item.FilePath,
ProjectPath = project.Key,
IsStaticFile = true,
StaticWebAssetPath = item.StaticWebAssetPath,
});
}
}
_reporter.Verbose($"Watching {fileItems.Count} file(s) for changes");
#if DEBUG
foreach (var file in fileItems)
{
_reporter.Verbose($" -> {file.FilePath} {(file.IsStaticFile ? file.StaticWebAssetPath : null)}");
}
Debug.Assert(fileItems.All(f => Path.IsPathRooted(f.FilePath)), "All files should be rooted paths");
#endif
// TargetFrameworkVersion appears as v6.0 in msbuild. Ignore the leading v
var targetFrameworkVersion = !string.IsNullOrEmpty(result.TargetFrameworkVersion) ?
Version.Parse(result.TargetFrameworkVersion.AsSpan(1)) : // Ignore leading v
null;
var projectInfo = new ProjectInfo(
_projectFile,
result.IsNetCoreApp,
targetFrameworkVersion,
result.RunCommand,
result.RunArguments,
result.RunWorkingDirectory);
return(new FileSet(projectInfo, fileItems));
}
_reporter.Error($"Error(s) finding watch items project file '{Path.GetFileName(_projectFile)}'");
_reporter.Output($"MSBuild output from target '{TargetName}':");
_reporter.Output(string.Empty);
foreach (var line in capture.Lines)
{
_reporter.Output($" {line}");
}
_reporter.Output(string.Empty);
if (!_waitOnError)
{
return(null);
}
else
{
_reporter.Warn("Fix the error to continue or press Ctrl+C to exit.");
var fileSet = new FileSet(null, new[] { new FileItem {
FilePath = _projectFile
} });
using (var watcher = new FileSetWatcher(fileSet, _reporter))
{
await watcher.GetChangedFileAsync(cancellationToken);
_reporter.Output($"File changed: {_projectFile}");
}
}
}
}
finally
{
if (File.Exists(watchList))
{
File.Delete(watchList);
}
}
}
public async Task WatchAsync(DotNetWatchContext context, CancellationToken cancellationToken)
{
var processSpec = context.ProcessSpec;
_reporter.Output("Hot reload enabled. For a list of supported edits, see https://aka.ms/dotnet/hot-reload. " +
"Press \"Ctrl + R\" to restart.");
var forceReload = new CancellationTokenSource();
_console.KeyPressed += (key) =>
{
var modifiers = ConsoleModifiers.Control;
if ((key.Modifiers & modifiers) == modifiers && key.Key == ConsoleKey.R)
{
var cancellationTokenSource = Interlocked.Exchange(ref forceReload, new CancellationTokenSource());
cancellationTokenSource.Cancel();
}
};
while (true)
{
context.Iteration++;
for (var i = 0; i < _filters.Length; i++)
{
await _filters[i].ProcessAsync(context, cancellationToken);
}
processSpec.EnvironmentVariables["DOTNET_WATCH_ITERATION"] = (context.Iteration + 1).ToString(CultureInfo.InvariantCulture);
var fileSet = context.FileSet;
if (fileSet == null)
{
_reporter.Error("Failed to find a list of files to watch");
return;
}
if (!fileSet.Project.IsNetCoreApp60OrNewer())
{
_reporter.Error($"Hot reload based watching is only supported in .NET 6.0 or newer apps. Update the project's launchSettings.json to disable this feature.");
return;
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (context.Iteration == 0)
{
ConfigureExecutable(context, processSpec);
}
using var currentRunCancellationSource = new CancellationTokenSource();
using var combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(
cancellationToken,
currentRunCancellationSource.Token,
forceReload.Token);
using var fileSetWatcher = new HotReloadFileSetWatcher(fileSet, _reporter);
try
{
using var hotReload = new HotReload(_processRunner, _reporter);
await hotReload.InitializeAsync(context, cancellationToken);
var processTask = _processRunner.RunAsync(processSpec, combinedCancellationSource.Token);
var args = string.Join(" ", processSpec.Arguments);
_reporter.Verbose($"Running {processSpec.ShortDisplayName()} with the following arguments: {args}");
_reporter.Output("Started");
Task <FileItem[]> fileSetTask;
Task finishedTask;
while (true)
{
fileSetTask = fileSetWatcher.GetChangedFileAsync(combinedCancellationSource.Token);
finishedTask = await Task.WhenAny(processTask, fileSetTask).WaitAsync(combinedCancellationSource.Token);
if (finishedTask != fileSetTask || fileSetTask.Result is not FileItem[] fileItems)
{
// The app exited.
break;
}
else
{
if (MayRequireRecompilation(context, fileItems) is { } newFile)
{
_reporter.Output($"New file: {newFile.FilePath}. Rebuilding the application.");
break;
}
private async Task <int> MainInternalAsync(
IReporter reporter,
string project,
IReadOnlyList <string> args,
CancellationToken cancellationToken)
{
// TODO multiple projects should be easy enough to add here
string projectFile;
try
{
projectFile = MsBuildProjectFinder.FindMsBuildProject(_workingDirectory, project);
}
catch (FileNotFoundException ex)
{
reporter.Error(ex.Message);
return(1);
}
var isDefaultRunCommand = false;
if (args.Count == 1 && args[0] == "run")
{
isDefaultRunCommand = true;
}
else if (args.Count == 0)
{
isDefaultRunCommand = true;
args = new[] { "run" };
}
var watchOptions = DotNetWatchOptions.Default;
var fileSetFactory = new MsBuildFileSetFactory(reporter,
watchOptions,
projectFile,
waitOnError: true,
trace: false);
var processInfo = new ProcessSpec
{
Executable = new Muxer().MuxerPath,
WorkingDirectory = Path.GetDirectoryName(projectFile),
Arguments = args,
EnvironmentVariables =
{
["DOTNET_WATCH"] = "1"
},
};
if (CommandLineOptions.IsPollingEnabled)
{
_reporter.Output("Polling file watcher is enabled");
}
var defaultProfile = LaunchSettingsProfile.ReadDefaultProfile(_workingDirectory, reporter);
var context = new DotNetWatchContext
{
ProcessSpec = processInfo,
Reporter = _reporter,
SuppressMSBuildIncrementalism = watchOptions.SuppressMSBuildIncrementalism,
DefaultLaunchSettingsProfile = defaultProfile,
};
if (isDefaultRunCommand && !string.IsNullOrEmpty(defaultProfile?.HotReloadProfile))
{
_reporter.Verbose($"Found HotReloadProfile={defaultProfile.HotReloadProfile}. Watching with hot-reload");
// We'll sue hot-reload based watching if
// a) watch was invoked with no args or with exactly one arg - the run command e.g. `dotnet watch` or `dotnet watch run`
// b) The launch profile supports hot-reload based watching.
// The watcher will complain if users configure this for runtimes that would not support it.
await using var watcher = new HotReloadDotNetWatcher(reporter, fileSetFactory, watchOptions, _console);
await watcher.WatchAsync(context, cancellationToken);
}
else
{
_reporter.Verbose("Did not find a HotReloadProfile or running a non-default command. Watching with legacy behavior.");
// We'll use the presence of a profile to decide if we're going to use the hot-reload based watching.
// The watcher will complain if users configure this for runtimes that would not support it.
await using var watcher = new DotNetWatcher(reporter, fileSetFactory, watchOptions);
await watcher.WatchAsync(context, cancellationToken);
}
return(0);
}
public async Task WatchAsync(DotNetWatchContext context, CancellationToken cancellationToken)
{
var processSpec = context.ProcessSpec;
var forceReload = new CancellationTokenSource();
var hotReloadEnabledMessage = "Hot reload enabled. For a list of supported edits, see https://aka.ms/dotnet/hot-reload.";
if (!_dotNetWatchOptions.NonInteractive)
{
_reporter.Output($"{hotReloadEnabledMessage}{Environment.NewLine} {(_dotNetWatchOptions.SuppressEmojis ? string.Empty : "💡")} Press \"Ctrl + R\" to restart.", emoji: "🔥");
_console.KeyPressed += (key) =>
{
var modifiers = ConsoleModifiers.Control;
if ((key.Modifiers & modifiers) == modifiers && key.Key == ConsoleKey.R)
{
var cancellationTokenSource = Interlocked.Exchange(ref forceReload, new CancellationTokenSource());
cancellationTokenSource.Cancel();
}
};
}
else
{
_reporter.Output(hotReloadEnabledMessage, emoji: "🔥");
}
while (true)
{
context.Iteration++;
for (var i = 0; i < _filters.Length; i++)
{
await _filters[i].ProcessAsync(context, cancellationToken);
}
processSpec.EnvironmentVariables["DOTNET_WATCH_ITERATION"] = (context.Iteration + 1).ToString(CultureInfo.InvariantCulture);
var fileSet = context.FileSet;
if (fileSet == null)
{
_reporter.Error("Failed to find a list of files to watch");
return;
}
if (!fileSet.Project.IsNetCoreApp60OrNewer())
{
_reporter.Error($"Hot reload based watching is only supported in .NET 6.0 or newer apps. Update the project's launchSettings.json to disable this feature.");
return;
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
if (context.Iteration == 0)
{
ConfigureExecutable(context, processSpec);
}
using var currentRunCancellationSource = new CancellationTokenSource();
using var combinedCancellationSource = CancellationTokenSource.CreateLinkedTokenSource(
cancellationToken,
currentRunCancellationSource.Token,
forceReload.Token);
using var fileSetWatcher = new HotReloadFileSetWatcher(fileSet, _reporter);
try
{
using var hotReload = new HotReload(_processRunner, _reporter);
await hotReload.InitializeAsync(context, cancellationToken);
var processTask = _processRunner.RunAsync(processSpec, combinedCancellationSource.Token);
var args = string.Join(" ", processSpec.Arguments);
_reporter.Verbose($"Running {processSpec.ShortDisplayName()} with the following arguments: {args}");
_reporter.Output("Started", emoji: "🚀");
Task <FileItem[]?> fileSetTask;
Task finishedTask;
while (true)
{
fileSetTask = fileSetWatcher.GetChangedFileAsync(combinedCancellationSource.Token);
finishedTask = await Task.WhenAny(processTask, fileSetTask).WaitAsync(combinedCancellationSource.Token);
if (finishedTask != fileSetTask || fileSetTask.Result is not FileItem[] fileItems)
{
if (processTask.IsFaulted && finishedTask == processTask && !cancellationToken.IsCancellationRequested)
{
// Only show this error message if the process exited non-zero due to a normal process exit.
// Don't show this if dotnet-watch killed the inner process due to file change or CTRL+C by the user
_reporter.Error($"Application failed to start: {processTask.Exception?.InnerException?.Message}");
}
break;
}
else
{
if (MayRequireRecompilation(context, fileItems) is { } newFile)
{
_reporter.Output($"New file: {GetRelativeFilePath(newFile.FilePath)}. Rebuilding the application.");
break;
}
public async Task <IFileSet> CreateAsync(CancellationToken cancellationToken)
{
var watchList = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
try
{
var projectDir = Path.GetDirectoryName(_projectFile);
while (true)
{
cancellationToken.ThrowIfCancellationRequested();
var capture = _outputSink.StartCapture();
var processSpec = new ProcessSpec
{
Executable = _muxerPath,
WorkingDirectory = projectDir,
Arguments = new[]
{
"msbuild",
"/nologo",
_projectFile,
$"/p:_DotNetWatchListFile={watchList}",
}.Concat(_buildFlags),
OutputCapture = capture
};
_reporter.Verbose($"Running MSBuild target '{TargetName}' on '{_projectFile}'");
var exitCode = await _processRunner.RunAsync(processSpec, cancellationToken);
if (exitCode == 0 && File.Exists(watchList))
{
var lines = File.ReadAllLines(watchList);
var isNetCoreApp31OrNewer = lines.FirstOrDefault() == "true";
var fileset = new FileSet(
isNetCoreApp31OrNewer,
lines.Skip(1)
.Select(l => l?.Trim())
.Where(l => !string.IsNullOrEmpty(l)));
_reporter.Verbose($"Watching {fileset.Count} file(s) for changes");
#if DEBUG
foreach (var file in fileset)
{
_reporter.Verbose($" -> {file}");
}
Debug.Assert(fileset.All(Path.IsPathRooted), "All files should be rooted paths");
#endif
return(fileset);
}
_reporter.Error($"Error(s) finding watch items project file '{Path.GetFileName(_projectFile)}'");
_reporter.Output($"MSBuild output from target '{TargetName}':");
_reporter.Output(string.Empty);
foreach (var line in capture.Lines)
{
_reporter.Output($" {line}");
}
_reporter.Output(string.Empty);
if (!_waitOnError)
{
return(null);
}
else
{
_reporter.Warn("Fix the error to continue or press Ctrl+C to exit.");
var fileSet = new FileSet(false, new[] { _projectFile });
using (var watcher = new FileSetWatcher(fileSet, _reporter))
{
await watcher.GetChangedFileAsync(cancellationToken);
_reporter.Output($"File changed: {_projectFile}");
}
}
}
}
finally
{
if (File.Exists(watchList))
{
File.Delete(watchList);
}
}
}
