|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Immutable;
using System.Linq;
namespace Microsoft.CodeAnalysis.ProjectSystem;
internal interface IFileChangeWatcher
{
IFileChangeContext CreateContext(ImmutableArray<WatchedDirectory> watchedDirectories);
}
/// <summary>
/// Gives a hint to the <see cref="IFileChangeContext"/> that we should watch a top-level directory for all changes in addition
/// to any files called by <see cref="IFileChangeContext.EnqueueWatchingFile(string)"/>.
/// </summary>
/// <remarks>
/// This is largely intended as an optimization; consumers should still call <see cref="IFileChangeContext.EnqueueWatchingFile(string)" />
/// for files they want to watch. This allows the caller to give a hint that it is expected that most of the files being
/// watched is under this directory, and so it's more efficient just to watch _all_ of the changes in that directory
/// rather than creating and tracking a bunch of file watcher state for each file separately. A good example would be
/// just creating a single directory watch on the root of a project for source file changes: rather than creating a file watcher
/// for each individual file, we can just watch the entire directory and that's it.
/// </remarks>
internal sealed class WatchedDirectory
{
public WatchedDirectory(string path, ImmutableArray<string> extensionFilters)
{
// We are doing string comparisons with this path, so ensure it has a trailing directory separator so we don't get confused with sibling
// paths that won't actually be covered. For example, if we're watching C:\Directory we wouldn't see changes to C:\DirectorySibling\Foo.txt.
if (!path.EndsWith(System.IO.Path.DirectorySeparatorChar.ToString()))
{
path += System.IO.Path.DirectorySeparatorChar;
}
if (extensionFilters.Any(static filter => !filter.StartsWith(".")))
{
throw new ArgumentException($"{nameof(extensionFilters)} should only contain entries starting with a period.", nameof(extensionFilters));
}
Path = path;
ExtensionFilters = extensionFilters;
}
public string Path { get; }
/// <summary>
/// If non-null, only watch the directory for changes to a specific extension. String always starts with a period.
/// </summary>
public ImmutableArray<string> ExtensionFilters { get; }
public static bool FilePathCoveredByWatchedDirectories(ImmutableArray<WatchedDirectory> watchedDirectories, string filePath, StringComparison stringComparison)
{
foreach (var watchedDirectory in watchedDirectories)
{
if (filePath.StartsWith(watchedDirectory.Path, stringComparison))
{
// If ExtensionFilters is empty, then we're watching for all files in the directory so the prior check
// of the directory containment was sufficient. If it isn't empty, then we have to check the extension
// matches.
if (watchedDirectory.ExtensionFilters.Length == 0 || watchedDirectory.ExtensionFilters.Any(filter => filePath.EndsWith(filter, stringComparison)))
{
return true;
}
}
}
return false;
}
}
/// <summary>
/// A context that is watching one or more files.
/// </summary>
internal interface IFileChangeContext : IDisposable
{
/// <summary>
/// Raised when a file has been changed. This may be a file watched explicitly by <see cref="EnqueueWatchingFile(string)"/> or it could be any
/// file in the directory if the <see cref="IFileChangeContext"/> was watching a directory.
/// </summary>
event EventHandler<string> FileChanged;
/// <summary>
/// Starts watching a file but doesn't wait for the file watcher to be registered with the operating system. Good if you know
/// you'll need a file watched (eventually) but it's not worth blocking yet.
/// </summary>
IWatchedFile EnqueueWatchingFile(string filePath);
}
internal interface IWatchedFile : IDisposable
{
}
/// <summary>
/// When a FileChangeWatcher already has a watch on a directory, a request to watch a specific file is a no-op. In that case, we return this token,
/// which when disposed also does nothing.
/// </summary>
internal sealed class NoOpWatchedFile : IWatchedFile
{
public static readonly IWatchedFile Instance = new NoOpWatchedFile();
private NoOpWatchedFile()
{
}
public void Dispose()
{
}
}
|