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;
}
