public static FileSystemWatcherHandle CreateDirectoryWatcher( string directoryPath, FileSystemEventHandler createHandler, FileSystemEventHandler updateHandler, FileSystemEventHandler deleteHandler, RenamedEventHandler renameHandler, ErrorEventHandler errorHandler ) { var fsWatcher = new FileSystemWatcher(directoryPath, "*.*") { InternalBufferSize = 64 * 1024, NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite, IncludeSubdirectories = true }; fsWatcher.Created += createHandler; fsWatcher.Changed += updateHandler; fsWatcher.Deleted += deleteHandler; fsWatcher.Renamed += renameHandler; fsWatcher.Error += errorHandler; return(new FileSystemWatcherHandle(fsWatcher, x => { x.EnableRaisingEvents = false; x.Error -= errorHandler; x.Renamed -= renameHandler; x.Deleted -= deleteHandler; x.Changed -= updateHandler; x.Created -= updateHandler; })); }
public static FileSystemWatcherHandle CreateSingleFileWatcher( string filePath, FileSystemEventHandler createHandler, FileSystemEventHandler updateHandler, FileSystemEventHandler deleteHandler, RenamedEventHandler renameHandler, ErrorEventHandler errorHandler ) { var directoryPath = Path.GetDirectoryName(filePath) ?? throw new ArgumentOutOfRangeException(nameof(filePath), filePath, null); var fileName = Path.GetFileName(filePath); var fsWatcher = new FileSystemWatcher(directoryPath, fileName) { InternalBufferSize = 64 * 1024, NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite, }; fsWatcher.Created += createHandler; fsWatcher.Changed += updateHandler; fsWatcher.Deleted += deleteHandler; fsWatcher.Renamed += renameHandler; fsWatcher.Error += errorHandler; return(new FileSystemWatcherHandle(fsWatcher, x => { x.EnableRaisingEvents = false; x.Error -= errorHandler; x.Renamed -= renameHandler; x.Deleted -= deleteHandler; x.Changed -= updateHandler; x.Created -= updateHandler; })); }
public void SetupWatchers(FileSystemEventHandler onChanged, RenamedEventHandler onRenamed) { foreach (var pair in DataSource) { pair.SetupWatcher(onChanged, onRenamed); } }
public IDisposable Subscribe(string path, Action <FileSystemEventArgs> handler) { var watcher = new FileSystemWatcher { Path = path, Filter = string.Empty, IncludeSubdirectories = true }; FileSystemEventHandler h1 = (_, args) => handler(args); RenamedEventHandler h2 = (_, args) => handler(args); watcher.Changed += h1; watcher.Created += h1; watcher.Deleted += h1; watcher.Renamed += h2; watcher.EnableRaisingEvents = true; return(Disposable.Create(() => { watcher.EnableRaisingEvents = false; watcher.Changed -= h1; watcher.Created -= h1; watcher.Deleted -= h1; watcher.Renamed -= h2; })); }
/// <summary> /// Creates a new SystemDirectory object for the given directory path. /// </summary> public SystemDirectory(string pathToDirectory, Dispatcher dispatcher) { try { this.dispatcher = dispatcher; files = new InvokingObservableCollection <SystemFile>(this.dispatcher); DirectoryInfo = new DirectoryInfo(pathToDirectory); fileWatcher.IncludeSubdirectories = false; fileWatcher.Filter = ""; fileWatcher.NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName; createdHandler = new FileSystemEventHandler(fileWatcher_Created); deletedHandler = new FileSystemEventHandler(fileWatcher_Deleted); renamedHandler = new RenamedEventHandler(fileWatcher_Renamed); fileWatcher.Created += createdHandler; fileWatcher.Deleted += deletedHandler; fileWatcher.Renamed += renamedHandler; fileWatcher.EnableRaisingEvents = true; } catch (UnauthorizedAccessException) { CairoMessage.Show(Localization.DisplayString.sError_FileNotFoundInfo, Localization.DisplayString.sError_OhNo, MessageBoxButton.OK, MessageBoxImage.Error); } }
public static void Observer() { using (FileSystemWatcher watcher = new FileSystemWatcher()) { Console.WriteLine("Включён режим наблюдателя"); watcher.Path = path; watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.LastAccess | NotifyFilters.FileName | NotifyFilters.DirectoryName; watcher.Filter = "*.txt"; FileSystemEventHandler fileCreateEventHandler = new FileSystemEventHandler(OnChanged); FileSystemEventHandler fileDeleteEventHandler = new FileSystemEventHandler(OnDelete); RenamedEventHandler fileRenameEventHandler = new RenamedEventHandler(OnRenamed); FileSystemEventHandler fileChangedEventHandler = new FileSystemEventHandler(Changed); watcher.Created += fileCreateEventHandler; watcher.Deleted += fileDeleteEventHandler; watcher.Renamed += fileRenameEventHandler; watcher.Changed += fileChangedEventHandler; watcher.EnableRaisingEvents = true; Console.WriteLine("Нажмите q для выхода из программы."); while (Console.Read() != 'q') { ; } watcher.Created -= fileCreateEventHandler; watcher.Deleted -= fileDeleteEventHandler; watcher.Renamed -= fileRenameEventHandler; watcher.Changed -= fileChangedEventHandler; } //we can and IDisposible work with //watcher.Dispose(); }
public DirectoryMonitor(string path, FileSystemEventHandler changedEvent, FileSystemEventHandler createdEvent, RenamedEventHandler renamedEvent, FileSystemEventHandler deletedEvent) { if (string.IsNullOrEmpty(path)) { throw new ArgumentNullException(nameof(path), "Path cannot be null"); } else if (changedEvent == null) { throw new ArgumentNullException(nameof(changedEvent), "changedEvent cannot be null"); } else if (createdEvent == null) { throw new ArgumentNullException(nameof(createdEvent), "createdEvent cannot be null"); } else if (renamedEvent == null) { throw new ArgumentNullException(nameof(renamedEvent), "renamedEvent cannot be null"); } else if (deletedEvent == null) { throw new ArgumentNullException(nameof(deletedEvent), "deletedEvent cannot be null"); } MonitorPath = path; ChangedEvent = changedEvent; CreatedEvent = createdEvent; RenamedEvent = renamedEvent; DeletedEvent = deletedEvent; }
private FileSystemWatcher MonitorContentFileSystemChanges() { var fileSystemWatcher = new FileSystemWatcher(); if (Directory.Exists(_baseLocalPath)) { fileSystemWatcher.Path = _baseLocalPath; fileSystemWatcher.IncludeSubdirectories = true; FileSystemEventHandler handler = (sender, args) => { _cacheManager.Clear(); }; RenamedEventHandler renamedHandler = (sender, args) => { _cacheManager.Clear(); }; var throttledHandler = handler.Throttle(TimeSpan.FromSeconds(5)); // Add event handlers. fileSystemWatcher.Changed += throttledHandler; fileSystemWatcher.Created += throttledHandler; fileSystemWatcher.Deleted += throttledHandler; fileSystemWatcher.Renamed += renamedHandler; // Begin watching. fileSystemWatcher.EnableRaisingEvents = true; } return(fileSystemWatcher); }
protected override void Dispose(bool disposing) { try { if (disposing) { //Stop raising events cleans up managed and //unmanaged resources. StopRaisingEvents(); // Clean up managed resources _onChangedHandler = null; _onCreatedHandler = null; _onDeletedHandler = null; _onRenamedHandler = null; _onErrorHandler = null; } else { FinalizeDispose(); } } finally { _disposed = true; base.Dispose(disposing); } }
/// <include file='doc\FileSystemWatcher.uex' path='docs/doc[@for="FileSystemWatcher.Dispose1"]/*' /> /// <devdoc> /// </devdoc> protected override void Dispose(bool disposing) { if (disposing) { //Stop raising events cleans up managed and //unmanaged resources. StopRaisingEvents(); // Clean up managed resources onChangedHandler = null; onCreatedHandler = null; onDeletedHandler = null; onRenamedHandler = null; onErrorHandler = null; readGranted = false; } else { stopListening = true; // Clean up unmanaged resources if (directoryHandle != (IntPtr)(-1)) { UnsafeNativeMethods.CloseHandle(new HandleRef(this, directoryHandle)); } } this.disposed = true; base.Dispose(disposing); }
internal FileChangeEventTarget(string fileName, OnChangedCallback onChangedCallback) { _fileName = fileName; _onChangedCallback = onChangedCallback; _changedHandler = new FileSystemEventHandler(this.OnChanged); _errorHandler = new ErrorEventHandler(this.OnError); _renamedHandler = new RenamedEventHandler(this.OnRenamed); }
public void Start(string path, FileSystemEventHandler OnChanged, RenamedEventHandler OnRenamed) { // Create a new FileSystemWatcher and set its properties. watcher.Path = path; watcher.IncludeSubdirectories = false; // Watch for changes in LastAccess and LastWrite times, and the renaming of files or directories. watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; // Only watch text files. watcher.Filter = "*.txt"; // Add event handlers. if (OnChanged != null) { watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Created += new FileSystemEventHandler(OnChanged); watcher.Deleted += new FileSystemEventHandler(OnChanged); } if (OnRenamed != null) { watcher.Renamed += new RenamedEventHandler(OnRenamed); } // Begin watching. watcher.EnableRaisingEvents = true; }
public SimpleFileWatcher(string dirToWatch, bool includeSubDirs, NotifyFilters notifyFilters, string fileFilter, FileSystemEventHandler handler, RenamedEventHandler renameHandler) { FileWatcher = new FileSystemWatcher(dirToWatch) { IncludeSubdirectories = includeSubDirs, NotifyFilter = notifyFilters, Filter = fileFilter }; if (handler != null) { FileWatcher.Created += handler; FileWatcher.Deleted += handler; FileWatcher.Changed += handler; } if (renameHandler != null) { FileWatcher.Renamed += renameHandler; } FileWatcher.EnableRaisingEvents = true; _handler = handler; _renameHandler = renameHandler; }
private FileSystemWatcher SetFileSystemWatcher(string path) { var fileSystemWatcher = new FileSystemWatcher(); fileSystemWatcher.Path = path; fileSystemWatcher.IncludeSubdirectories = true; FileSystemEventHandler handler = (sender, args) => { RaiseChangedEvent(args); }; RenamedEventHandler renamedHandler = (sender, args) => { RaiseRenamedEvent(args); }; var throttledHandler = handler.Throttle(TimeSpan.FromSeconds(5)); // Add event handlers. fileSystemWatcher.Changed += throttledHandler; fileSystemWatcher.Created += throttledHandler; fileSystemWatcher.Deleted += throttledHandler; fileSystemWatcher.Renamed += renamedHandler; // Begin watching. fileSystemWatcher.EnableRaisingEvents = true; return(fileSystemWatcher); }
/// <devdoc> /// </devdoc> protected override void Dispose(bool disposing) { try { if (disposing) { //Stop raising events cleans up managed and //unmanaged resources. StopRaisingEvents(); // Clean up managed resources onChangedHandler = null; onCreatedHandler = null; onDeletedHandler = null; onRenamedHandler = null; onErrorHandler = null; readGranted = false; } else { stopListening = true; // Clean up unmanaged resources if (!IsHandleInvalid) { directoryHandle.Close(); } } } finally { this.disposed = true; base.Dispose(disposing); } }
//----------------------------------------------------------------------------------------- public void setEventHandler(FileSystemEventHandler _onChanged = null, FileSystemEventHandler _onCreated = null, FileSystemEventHandler _onDeleted = null, RenamedEventHandler _onRenamed = null) { m_onCreated = _onCreated; m_onChanged = _onChanged; m_onDeleted = _onDeleted; m_onRenamed = _onRenamed; }
/// <summary> /// Watches the Renamed WatcherChangeType and unblocks the returned AutoResetEvent when a /// Renamed event is thrown by the watcher. /// </summary> public static (AutoResetEvent EventOccured, RenamedEventHandler Handler) WatchRenamed(FileSystemWatcher watcher, string[] expectedPaths = null, ITestOutputHelper _output = null) { AutoResetEvent eventOccurred = new AutoResetEvent(false); RenamedEventHandler handler = (o, e) => { if (e.ChangeType != WatcherChangeTypes.Renamed) { _output?.WriteLine("Unexpected event {0} while waiting for {1}", e.ChangeType, WatcherChangeTypes.Renamed); Assert.Equal(WatcherChangeTypes.Renamed, e.ChangeType); } if (expectedPaths != null) { try { Assert.Contains(Path.GetFullPath(e.FullPath), expectedPaths); } catch (Exception ex) { _output?.WriteLine(ex.ToString()); throw; } } eventOccurred.Set(); }; watcher.Renamed += handler; return(eventOccurred, handler); }
public ChangeWatcher(List <string> pathList, FileSystemEventHandler changedEventHandler, FileSystemEventHandler createdEventHandler, FileSystemEventHandler deletedEventHandler, RenamedEventHandler renamedEventHandler) { if (pathList == null || pathList.Count < 1) { return; } _changedEventHandler = changedEventHandler; _createdEventHandler = createdEventHandler; _deletedEventHandler = deletedEventHandler; _renamedEventHandler = renamedEventHandler; try { foreach (string path in pathList) { FileSystemWatcher watcher = new FileSystemWatcher(path) { NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Size }; watcher.Changed += _changedEventHandler; watcher.Created += _createdEventHandler; watcher.Deleted += _deletedEventHandler; watcher.Renamed += _renamedEventHandler; _watchers.Add(watcher); } } catch (Exception e) { ShellLogger.Error($"ChangeWatcher: Unable to instantiate watcher: {e.Message}"); } }
public virtual IObservable <FileSystemEvent> Watch(string path, string filter = "*.*") => Observable.Create <FileSystemEvent>(ob => { var watcher = new FileSystemWatcher(path, filter) { EnableRaisingEvents = true }; var handler = new FileSystemEventHandler((sender, args) => ob.OnNext(new FileSystemEvent(args.ChangeType, args.Name, args.FullPath)) ); var renameHandler = new RenamedEventHandler((sender, args) => ob.OnNext(new FileSystemEvent(args.ChangeType, args.Name, args.FullPath, args.OldName, args.OldFullPath)) ); var errorHandler = new ErrorEventHandler((sender, args) => ob.OnError(args.GetException()) ); watcher.Created += handler; watcher.Changed += handler; watcher.Deleted += handler; watcher.Error += errorHandler; watcher.Renamed += renameHandler; return(() => { watcher.EnableRaisingEvents = false; watcher.Created -= handler; watcher.Changed -= handler; watcher.Deleted -= handler; watcher.Renamed -= renameHandler; watcher.Error -= errorHandler; watcher.Dispose(); }); });
public WatcherTimer(FileSystemEventHandler changeHandler, RenamedEventHandler renamedHandler, int timerInterval) { m_timer = new System.Threading.Timer(new TimerCallback(OnTimer), null, Timeout.Infinite, Timeout.Infinite); TimeoutMillis = timerInterval; fswHandler = changeHandler; reHandler = renamedHandler; }
static void SetupOfflineWatch() { lock (appOfflineLock) { FileSystemEventHandler seh = new FileSystemEventHandler(AppOfflineFileChanged); RenamedEventHandler reh = new RenamedEventHandler(AppOfflineFileRenamed); string app_dir = AppDomainAppPath; FileSystemWatcher watcher; string offlineFile = null, tmp; foreach (string f in app_offline_files) { watcher = new FileSystemWatcher(); watcher.Path = Path.GetDirectoryName(app_dir); watcher.Filter = Path.GetFileName(f); watcher.NotifyFilter |= NotifyFilters.Size; watcher.Deleted += seh; watcher.Changed += seh; watcher.Created += seh; watcher.Renamed += reh; watcher.EnableRaisingEvents = true; tmp = Path.Combine(app_dir, f); if (File.Exists(tmp)) { offlineFile = tmp; } } if (offlineFile != null) { SetOfflineMode(true, offlineFile); } } }
internal static bool WatchLocationForRestart(string virtualPath, string filter, bool watchSubdirs) { // map the path to the physical one string physicalPath = HttpRuntime.AppDomainAppPath; physicalPath = Path.Combine(physicalPath, virtualPath); bool isDir = Directory.Exists(physicalPath); bool isFile = isDir ? false : File.Exists(physicalPath); if (isDir || isFile) { // create the watcher FileSystemEventHandler fseh = new FileSystemEventHandler(OnFileChanged); RenamedEventHandler reh = new RenamedEventHandler(OnFileRenamed); FileSystemWatcher watcher = CreateWatcher(Path.Combine(physicalPath, filter), fseh, reh); if (isDir) { watcher.IncludeSubdirectories = watchSubdirs; } lock (watchers_lock) { watchers.Add(watcher); } return(true); } else { return(false); } }
internal FileChangeEventTarget(string fileName, OnChangedCallback onChangedCallback) { _fileName = fileName; _onChangedCallback = onChangedCallback; _changedHandler = new FileSystemEventHandler(this.OnChanged); _errorHandler = new ErrorEventHandler(this.OnError); _renamedHandler = new RenamedEventHandler(this.OnRenamed); }
/// <summary> /// Runs the class. Starts the drive watcher thread and saves passed parameters /// </summary> /// <param name="changedHandler">Delegate to be called when a file or folder is changed/created/deleted in the system</param> /// <param name="renamedHandler">Dalegate to be called when a file or folder is renamed in the system</param> /// <param name="drivesRoot">PowerItem, under which drives list is located</param> public static void Init(FileSystemEventHandler changedHandler, RenamedEventHandler renamedHandler, PowerItem drivesRoot) { _fileChanged = changedHandler; _fileRenamed = renamedHandler; _drivesRoot = drivesRoot; SettingsManager.WatchRemovablesChanged += SettingsManagerOnWatchRemovablesChanged; Util.ForkStart(Worker, "DriveWatchThread"); Util.ForkStart(FsWorker, "File system events dequeuer"); }
/// <summary> /// Extends BeginInvoke so that when a state object is not needed, null does not need to be passed. /// <example> /// renamedeventhandler.BeginInvoke(sender, e, callback); /// </example> /// </summary> public static IAsyncResult BeginInvoke(this RenamedEventHandler renamedeventhandler, Object sender, RenamedEventArgs e, AsyncCallback callback) { if (renamedeventhandler == null) { throw new ArgumentNullException("renamedeventhandler"); } return(renamedeventhandler.BeginInvoke(sender, e, callback, null)); }
protected void OnRenamed(RenamedEventArgs e) { RenamedEventHandler renamedHandler = _onRenamedHandler; if (renamedHandler != null) { renamedHandler(this, e); } }
public FileSystemWatcherOptions(string path, string filter, FileSystemEventHandler changedAction, FileSystemEventHandler createdAction, ErrorEventHandler errorAction, FileSystemEventHandler deletedAction, RenamedEventHandler renamedAction) { Path = path; Filter = filter; ChangedAction = changedAction; CreatedAction = createdAction; ErrorAction = errorAction; DeletedAction = deletedAction; RenamedAction = renamedAction; }
public FileSystemWatcherOptions(string path, string filter, FileSystemEventHandler changedAction, FileSystemEventHandler createdAction, ErrorEventHandler errorAction, FileSystemEventHandler deletedAction, RenamedEventHandler renamedAction) { Path = path; Filter = filter; ChangedAction = changedAction; CreatedAction = createdAction; ErrorAction = errorAction; DeletedAction = deletedAction; RenamedAction = renamedAction; }
public void Initialize() { base.CheckDisposed(); lock (this) { if (!this.Initialized) { FileSystemEventHandler value = delegate(object sender, FileSystemEventArgs e) { if (string.Equals("TextMessagingHostingData-System.xml", e.Name, StringComparison.OrdinalIgnoreCase) || string.Equals("TextMessagingHostingData-Site.xml", e.Name, StringComparison.OrdinalIgnoreCase)) { this.LoadFromFiles(); } }; RenamedEventHandler value2 = delegate(object sender, RenamedEventArgs e) { if (string.Equals("TextMessagingHostingData-System.xml", e.Name, StringComparison.OrdinalIgnoreCase) || string.Equals("TextMessagingHostingData-Site.xml", e.Name, StringComparison.OrdinalIgnoreCase) || string.Equals("TextMessagingHostingData-System.xml", e.OldName, StringComparison.OrdinalIgnoreCase) || string.Equals("TextMessagingHostingData-Site.xml", e.OldName, StringComparison.OrdinalIgnoreCase)) { this.LoadFromFiles(); } }; Exception ex = null; try { this.fileWatcher = new FileSystemWatcher(TextMessagingHostingDataCache.ExecutingAssemblyLocation, "TextMessagingHostingData-*.xml"); this.fileWatcher.Changed += value; this.fileWatcher.Created += value; this.fileWatcher.Deleted += value; this.fileWatcher.Renamed += value2; this.fileWatcher.EnableRaisingEvents = true; } catch (ArgumentException ex2) { ex = ex2; } catch (FileNotFoundException ex3) { ex = ex3; } finally { if (ex != null) { TextMessagingHostingDataCache.EventLog.LogEvent(ApplicationLogicEventLogConstants.Tuple_MonitorHostingDataFileFailure, null, new object[] { TextMessagingHostingDataCache.ExecutingAssemblyLocation, ex }); } } this.LoadFromFiles(); this.Initialized = true; } } }
private void TryCreateWatcher(string[] paths, string[] extensions) { _watchers = new FileSystemWatcher[paths.Length, extensions.Length + 1]; var notify = NotifyFilters.FileName | NotifyFilters.LastWrite; var onChange = new FileSystemEventHandler(OnChanged); var onRename = new RenamedEventHandler(OnRenamed); var onError = new ErrorEventHandler(OnError); var onChangeDir = new FileSystemEventHandler(OnChangedDir); var onRenameDir = new RenamedEventHandler(OnRenamedDir); var onErrorDir = new ErrorEventHandler(OnErrorDir); FileSystemWatcher watcher; for (int i = 0; i < paths.Length; i++) { for (int j = 0; j < _extensions.Length; j++) { watcher = new FileSystemWatcher { Path = paths[i], Filter = _extensions[j], NotifyFilter = notify, IncludeSubdirectories = true, EnableRaisingEvents = true, }; watcher.Changed += onChange; watcher.Created += onChange; watcher.Deleted += onChange; watcher.Renamed += onRename; watcher.Error += onError; _watchers[i, j] = watcher; } watcher = new FileSystemWatcher { Path = paths[i], Filter = "*.*", NotifyFilter = NotifyFilters.DirectoryName, IncludeSubdirectories = true, EnableRaisingEvents = true, }; watcher.Changed += onChangeDir; watcher.Created += onChangeDir; watcher.Deleted += onChangeDir; watcher.Renamed += onRenameDir; watcher.Error += onErrorDir; _watchers[i, extensions.Length] = watcher; } }
/// <summary> /// Raises the event to each handler in the list. /// </summary> private void NotifyRenameEventArgs(WatcherChangeTypes action, ReadOnlySpan <char> name, ReadOnlySpan <char> oldName) { // filter if there's no handler or neither new name or old name match a specified pattern RenamedEventHandler handler = _onRenamedHandler; if (handler != null && (MatchPattern(name) || MatchPattern(oldName))) { handler(this, new RenamedEventArgs(action, _directory, name.IsEmpty ? null : name.ToString(), oldName.IsEmpty ? null : oldName.ToString())); } }
/// <devdoc> /// Raises the event to each handler in the list. /// </devdoc> /// <internalonly/> private void NotifyRenameEventArgs(WatcherChangeTypes action, string name, string oldName) { // filter if there's no handler or neither new name or old name match a specified pattern RenamedEventHandler handler = _onRenamedHandler; if (handler != null && (MatchPattern(name) || MatchPattern(oldName))) { handler(this, new RenamedEventArgs(action, _directory, name, oldName)); } }
static Watcher() { Watchers = new ConcurrentDictionary<String, WatcherInfo>(); FileWatchersFactory = ProduceFileWatcher; DirectoryWatchersFactory = ProduceDirectoryWatcher; FileCreatedOrChangedHandler = HandleFileCreatedOrChanged; FileDeletedHandler = HandleFileDeleted; FileRenamedHandler = HandleFileRenamed; FileWatchingErrorHandler = HandleFileWatchingError; DirectoryWatchingErrorHandler = HandleDirectoryWatchingError; FileInDirectoryRenamedHandler = HandleFileInDirectoryRenamed; }
private static void CreateWatcher( Settings settings, FileSystemEventHandler handler, RenamedEventHandler renamedHandler) { var watcher = new FileSystemWatcher(settings.Path) { IncludeSubdirectories = true, NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite, EnableRaisingEvents = true, Filter = "*.sql" }; watcher.Changed += handler; watcher.Created += handler; watcher.Deleted += handler; watcher.Renamed += renamedHandler; }
/// <summary> /// Constructor. /// </summary> public Watcher(string folder) { #if __MonoCS__ // http://stackoverflow.com/questions/16859372/why-doesnt-the-servicestack-razor-filesystemwatcher-work-on-mono-mac-os-x Environment.SetEnvironmentVariable("MONO_MANAGED_WATCHER", "enabled"); #endif Path = System.IO.Path.GetFullPath(folder); IncludeSubdirectories = true; Filter = "*"; InternalBufferSize = 4 * 1024 * 16; Error += new ErrorEventHandler(OnError); Created += new FileSystemEventHandler(OnCreated); Deleted += new FileSystemEventHandler(OnDeleted); Changed += new FileSystemEventHandler(OnChanged); Renamed += new RenamedEventHandler(OnRenamed); EnableRaisingEvents = true; EnableEvent = true; }
protected override void DoWork(CancellationToken token) { if (this.token.IsCancellationRequested) { this.DisableWatcher(); return; } try { this.token = token; bool watchSubdirectories = bool.Parse(this.configuration[WatchSubdirectoriesSetting]); this.fileSystemWatcher.Path = this.WatchPath; this.fileSystemWatcher.IncludeSubdirectories = watchSubdirectories; this.changeEventHandler = (source, args) => this.OnChanged(source, args); this.renamedEventHandler = this.OnRenamed; this.fileSystemWatcher.Created += changeEventHandler; this.fileSystemWatcher.Changed += changeEventHandler; this.fileSystemWatcher.Renamed += renamedEventHandler; this.CheckFolder().ContinueWith( (obj) => { this.fileSystemWatcher.EnableRaisingEvents = true; }, token); } catch (Exception ex) { this.logger.LogException(ex); throw; } }
public void Start(string path, FileSystemEventHandler OnChanged, RenamedEventHandler OnRenamed) { // Create a new FileSystemWatcher and set its properties. watcher.Path = path; watcher.IncludeSubdirectories = false; // Watch for changes in LastAccess and LastWrite times, and the renaming of files or directories. watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; // Only watch text files. watcher.Filter = "*.txt"; // Add event handlers. if (OnChanged != null) { watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Created += new FileSystemEventHandler(OnChanged); watcher.Deleted += new FileSystemEventHandler(OnChanged); } if (OnRenamed != null) { watcher.Renamed += new RenamedEventHandler(OnRenamed); } // Begin watching. watcher.EnableRaisingEvents = true; }
private void startActivityMonitoring() { // Make sure you use the OR on each Filter because we need to monitor // all of those activities NotifyFilter = System.IO.NotifyFilters.DirectoryName; NotifyFilter = NotifyFilter | System.IO.NotifyFilters.FileName; NotifyFilter = NotifyFilter | System.IO.NotifyFilters.Attributes; // Now hook the triggers(events) to our handler (eventRaised) Changed += new FileSystemEventHandler(eventRaised); Created += new FileSystemEventHandler(eventRaised); Deleted += new FileSystemEventHandler(eventRaised); // Occurs when a file or directory is renamed in the specific path Renamed += new RenamedEventHandler(eventRaised); // And at last.. We connect our EventHandles to the system API (that is all // wrapped up in System.IO) try { EnableRaisingEvents = true; } catch (ArgumentException e) { abortActivityMonitoring(); Logger.Write(@"Argument exception: " + e.Message, System.Diagnostics.EventLogEntryType.Error); } }
public EnhancedFileSystemWatcher(string folderToWatch, string includeFilter, string excludeFilter, int pollTime, bool includeSubdirectories) { FolderToWatch = folderToWatch; IncludeFilter = includeFilter; ExcludeFilter = excludeFilter; PollTime = pollTime; IncludeSubdirectories = includeSubdirectories; _timer = new System.Timers.Timer(); _timer.Elapsed += OnTimeUp; _timer.Interval = PollTime; _timer.Enabled = false; _timer.AutoReset = false; _timerForFileActivityFinished = new System.Timers.Timer(); _timerForFileActivityFinished.Elapsed += OnTimeUpForFileActivityFinished; _timerForFileActivityFinished.Interval = PollTime; _timerForFileActivityFinished.Enabled = false; _timerForFileActivityFinished.AutoReset = false; _fileSystemWatcherChangedEvent = OnFileChanged; _fileSystemWatcherCreatedEvent = OnFileCreated; _fileSystemWatcherDeletedEvent = OnFileDeleted; _fileSystemWatcherRenamedEvent = OnFileRenamed; _fileFinishedChangingCallback = OnFileFinishedChanging; _fileSystemWatcher = new FileSystemWatcher(FolderToWatch) { IncludeSubdirectories = IncludeSubdirectories, EnableRaisingEvents = false, NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite }; _fileSystemWatcher.Changed += _fileSystemWatcherChangedEvent; _fileSystemWatcher.Created += _fileSystemWatcherCreatedEvent; _fileSystemWatcher.Deleted += _fileSystemWatcherDeletedEvent; _fileSystemWatcher.Renamed += _fileSystemWatcherRenamedEvent; }
public FileSystemWatcher SetupFileWatcher(string filePath, string filter, FileSystemEventHandler changeAction, FileSystemEventHandler createdAction, FileSystemEventHandler deletedAction, RenamedEventHandler renamedAction, ErrorEventHandler errorAction) { var fileWatcher = new FileSystemWatcher(filePath, filter); fileWatcher.Changed += changeAction; fileWatcher.Created += createdAction; fileWatcher.Deleted += deletedAction; fileWatcher.Renamed += renamedAction; fileWatcher.Error += errorAction; fileWatcher.Error += delegate(object sender, ErrorEventArgs e) { fileWatcher.EnableRaisingEvents = false; while (!fileWatcher.EnableRaisingEvents) { try { fileWatcher.Changed -= changeAction; fileWatcher.Created -= createdAction; fileWatcher.Deleted -= deletedAction; fileWatcher.Renamed -= renamedAction; fileWatcher.Error -= errorAction; fileWatcher = new FileSystemWatcher(filePath, filter); fileWatcher.Changed += changeAction; fileWatcher.Created += createdAction; fileWatcher.Deleted += deletedAction; fileWatcher.Renamed += renamedAction; fileWatcher.Error += errorAction; fileWatcher.EnableRaisingEvents = true; } catch { fileWatcher.EnableRaisingEvents = false; System.Threading.Thread.Sleep(5000); } } }; return fileWatcher; }
public static void FileSystemWatcher_Renamed() { using (FileSystemWatcher watcher = new FileSystemWatcher()) { var handler = new RenamedEventHandler((o, e) => { }); // add / remove watcher.Renamed += handler; watcher.Renamed -= handler; // shouldn't throw watcher.Renamed -= handler; } }
/// <devdoc> /// </devdoc> protected virtual void Dispose(bool disposing) { try { if (disposing) { //Stop raising events cleans up managed and //unmanaged resources. StopRaisingEvents(); // Clean up managed resources _onChangedHandler = null; _onCreatedHandler = null; _onDeletedHandler = null; _onRenamedHandler = null; _onErrorHandler = null; } else { FinalizeDispose(); } } finally { _disposed = true; } }
protected override void OnStart(string[] args) { var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var jobs = XElement.Load(config.FilePath).Element("syncJobs").Elements("syncJob").ToArray(); foreach (XElement job in jobs) { var source = Path.Combine(job.Element("source").Value); var target = Path.Combine(job.Element("target").Value); if (!source.EndsWith(Path.DirectorySeparatorChar.ToString())) source += Path.DirectorySeparatorChar; if (!target.EndsWith(Path.DirectorySeparatorChar.ToString())) target += Path.DirectorySeparatorChar; var types = job.Element("fileTypes").Elements("type").Select(x => x.Value).ToArray(); foreach (string type in types) { var watcher = new FileSystemWatcher(); watcher.Path = source; watcher.IncludeSubdirectories = true; watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; watcher.Filter = type; Action<string> copy = fullPath => { var targetRelPath = fullPath.Substring(fullPath.IndexOf(source) + source.Length); var targetFullPath = Path.Combine(target, targetRelPath); try { File.Copy(fullPath, targetFullPath, true); } catch (IOException ex) { Debug.WriteLine(ex.Message); EventLog.WriteEntry(ex.GetType().ToString() + "\r\n" + ex.Message + "\r\n" + ex.StackTrace, EventLogEntryType.Error); } }; var directCopy = new FileSystemEventHandler((sender, e) => copy(e.FullPath)); var renameCopy = new RenamedEventHandler((sender, e) => copy(e.FullPath)); var del = new FileSystemEventHandler((sender, e) => { try { File.Delete(Path.Combine(target, e.FullPath.Substring(e.FullPath.IndexOf(source) + source.Length))); } catch (Exception ex) { Debug.WriteLine(ex.Message); EventLog.WriteEntry(ex.GetType().ToString() + "\r\n" + ex.Message + "\r\n" + ex.StackTrace, EventLogEntryType.Error); } }); watcher.Changed += directCopy; watcher.Created += directCopy; watcher.Deleted += del; watcher.Renamed += renameCopy; watchers.Add(watcher); watcher.EnableRaisingEvents = true; } } }
/// <devdoc> /// </devdoc> protected override void Dispose(bool disposing) { try { if (disposing) { //Stop raising events cleans up managed and //unmanaged resources. StopRaisingEvents(); // Clean up managed resources onChangedHandler = null; onCreatedHandler = null; onDeletedHandler = null; onRenamedHandler = null; onErrorHandler = null; readGranted = false; } else { stopListening = true; // Clean up unmanaged resources if (!IsHandleInvalid) { directoryHandle.Close(); } } } finally { this.disposed = true; base.Dispose(disposing); } }
/// <devdoc> /// <para> /// A synchronous /// method that returns a structure that contains specific information on the change that occurred, given the /// type of change that you wish to monitor and the time (in milliseconds) to wait before timing out. /// </para> /// </devdoc> public WaitForChangedResult WaitForChanged(WatcherChangeTypes changeType, int timeout) { FileSystemEventHandler dirHandler = new FileSystemEventHandler(this.OnInternalFileSystemEventArgs); RenamedEventHandler renameHandler = new RenamedEventHandler(this.OnInternalRenameEventArgs); this.isChanged = false; this.changedResult = WaitForChangedResult.TimedOutResult; // Register the internal event handler from the given change types. if ((changeType & WatcherChangeTypes.Created) != 0) { this.Created += dirHandler; } if ((changeType & WatcherChangeTypes.Deleted) != 0) { this.Deleted += dirHandler; } if ((changeType & WatcherChangeTypes.Changed) != 0) { this.Changed += dirHandler; } if ((changeType & WatcherChangeTypes.Renamed) != 0) { this.Renamed += renameHandler; } // Save the Enabled state of this component to revert back to it later (if needed). bool savedEnabled = EnableRaisingEvents; if (savedEnabled == false) { runOnce = true; EnableRaisingEvents = true; } // For each thread entering this wait loop, addref it and wait. When the last one // exits, reset the waiterObject. WaitForChangedResult retVal = WaitForChangedResult.TimedOutResult; lock (this) { if (timeout == -1) { while (!isChanged) { System.Threading.Monitor.Wait(this); } } else { System.Threading.Monitor.Wait(this, timeout, true); } retVal = changedResult; } // Revert the Enabled flag to its previous state. EnableRaisingEvents = savedEnabled; runOnce = false; // Decouple the event handlers added above. if ((changeType & WatcherChangeTypes.Created) != 0) { this.Created -= dirHandler; } if ((changeType & WatcherChangeTypes.Deleted) != 0) { this.Deleted -= dirHandler; } if ((changeType & WatcherChangeTypes.Changed) != 0) { this.Changed -= dirHandler; } if ((changeType & WatcherChangeTypes.Renamed) != 0) { this.Renamed -= renameHandler; } // Return the struct. return retVal; }
static FileSystemWatcher CreateWatcher (string file, FileSystemEventHandler hnd, RenamedEventHandler reh) { FileSystemWatcher watcher = new FileSystemWatcher (); watcher.Path = Path.GetFullPath (Path.GetDirectoryName (file)); watcher.Filter = Path.GetFileName (file); // This will enable the Modify flag for Linux/inotify watcher.NotifyFilter |= NotifyFilters.Size; watcher.Changed += hnd; watcher.Created += hnd; watcher.Deleted += hnd; watcher.Renamed += reh; watcher.EnableRaisingEvents = true; return watcher; }
internal static bool WatchLocationForRestart(string virtualPath, string filter, bool watchSubdirs) { // map the path to the physical one string physicalPath = HttpRuntime.AppDomainAppPath; physicalPath = Path.Combine(physicalPath, virtualPath); bool isDir = Directory.Exists(physicalPath); bool isFile = isDir ? false : File.Exists(physicalPath); if (isDir || isFile) { // create the watcher FileSystemEventHandler fseh = new FileSystemEventHandler(OnFileChanged); RenamedEventHandler reh = new RenamedEventHandler(OnFileRenamed); FileSystemWatcher watcher = CreateWatcher(Path.Combine(physicalPath, filter), fseh, reh); if (isDir) watcher.IncludeSubdirectories = watchSubdirs; lock (watchers_lock) { watchers.Add(watcher); } return true; } else { return false; } }
public void remove_Renamed (RenamedEventHandler value) { }
public void add_Renamed (RenamedEventHandler value) { }
static void SetupOfflineWatch () { lock (appOfflineLock) { FileSystemEventHandler seh = new FileSystemEventHandler (AppOfflineFileChanged); RenamedEventHandler reh = new RenamedEventHandler (AppOfflineFileRenamed); string app_dir = AppDomainAppPath; FileSystemWatcher watcher; string offlineFile = null, tmp; foreach (string f in app_offline_files) { watcher = new FileSystemWatcher (); watcher.Path = Path.GetDirectoryName (app_dir); watcher.Filter = Path.GetFileName (f); watcher.NotifyFilter |= NotifyFilters.Size; watcher.Deleted += seh; watcher.Changed += seh; watcher.Created += seh; watcher.Renamed += reh; watcher.EnableRaisingEvents = true; tmp = Path.Combine (app_dir, f); if (File.Exists (tmp)) offlineFile = tmp; } if (offlineFile != null) SetOfflineMode (true, offlineFile); } }
public WatcherTimer(FileSystemEventHandler changeHandler, RenamedEventHandler renamedHandler, int timerInterval) { m_timer = new System.Threading.Timer(new TimerCallback(OnTimer), null, Timeout.Infinite, Timeout.Infinite); TimeoutMillis = timerInterval; fswHandler = changeHandler; reHandler = renamedHandler; }