public void StartWatching(string fileName, string directoryPath)
            {
                // Read the file time stamp right now; we want to know if it changes between now
                // and our ability to get the file watcher in place.
                var originalFileTimeStamp = TryGetFileTimeStamp(fileName, directoryPath);

                _taskQueue.ScheduleTask(nameof(DeferredFileWatcher) + "." + nameof(StartWatching), () =>
                {
                    _fileWatcher.StartWatching(fileName, directoryPath);

                    var newFileTimeStamp = TryGetFileTimeStamp(fileName, directoryPath);

                    if (originalFileTimeStamp != newFileTimeStamp)
                    {
                        ChangeType changeType;

                        if (!originalFileTimeStamp.HasValue && newFileTimeStamp.HasValue)
                        {
                            changeType = ChangeType.FileCreated;
                        }
                        else if (originalFileTimeStamp.HasValue && !newFileTimeStamp.HasValue)
                        {
                            changeType = ChangeType.FileDeleted;
                        }
                        else
                        {
                            changeType = ChangeType.FileModified;
                        }

                        ConventionFileChanged?.Invoke(this,
                                                      new ConventionsFileChangeEventArgs(fileName, directoryPath, changeType));
                    }
                }, CancellationToken.None);
            }
Esempio n. 2
0
 void FileService_FileChanged(object sender, FileEventArgs e)
 {
     foreach (var file in e)
     {
         if (watchers.TryGetValue(file.FileName, out FileSystemWatcher watcher))
         {
             ConventionFileChanged?.Invoke(this, new ConventionsFileChangeEventArgs(watcher.Filter, watcher.Path, ChangeType.FileModified));
         }
     }
 }
 void FileService_FileChanged(object sender, FileEventArgs e)
 {
     lock (watchedFiles) {
         foreach (var file in e)
         {
             if (watchedFiles.Contains(file.FileName))
             {
                 ConventionFileChanged?.Invoke(this, new ConventionsFileChangeEventArgs(file.FileName.FileName, file.FileName.ParentDirectory, ChangeType.FileModified));
             }
         }
     }
 }
 void FileService_FileRemoved(object sender, FileEventArgs e)
 {
     lock (watchedFiles) {
         foreach (var file in e)
         {
             if (watchedFiles.Remove(file.FileName))
             {
                 ConventionFileChanged?.Invoke(this, new ConventionsFileChangeEventArgs(file.FileName.FileName, file.FileName.ParentDirectory, ChangeType.FileDeleted));
                 WatchDirectories();
             }
         }
     }
 }
Esempio n. 5
0
 void FileService_FileRemoved(object sender, FileEventArgs e)
 {
     lock (watchers) {
         foreach (var file in e)
         {
             if (watchers.TryGetValue(file.FileName, out FileSystemWatcher watcher))
             {
                 ConventionFileChanged?.Invoke(this, new ConventionsFileChangeEventArgs(watcher.Filter, watcher.Path, ChangeType.FileDeleted));
                 watcher.Dispose();
                 watchers.Remove(file.FileName);
             }
         }
     }
 }
Esempio n. 6
0
 private Task OnConventionFileChanged(object sender, ConventionsFileChangeEventArgs arg)
 {
     return(ConventionFileChanged?.Invoke(this, arg) ?? Task.CompletedTask);
 }
Esempio n. 7
0
            void OnChanged(object source, FileSystemEventArgs e)
            {
                var watcher = (FileSystemWatcher)source;

                ConventionFileChanged?.Invoke(this, new ConventionsFileChangeEventArgs(watcher.Filter, watcher.Path, GetChangeType(e.ChangeType)));
            }
 private Task OnConventionFileChangedAsync(object sender, ConventionsFileChangeEventArgs arg)
 => ConventionFileChanged?.Invoke(this, arg) ?? Task.CompletedTask;