void OnChange(string filename, FileSystemEvent @event)
{
if (Change != null)
{
Change(filename, @event);
}
}
private void PostponeEventDelivery(FileSystemEvent fileEvent)
{
if (!postponedEvents.ContainsKey(fileEvent.Filename))
{
postponedEvents.Add(fileEvent.Filename, fileEvent);
}
}
public void OnEvent(FileSystemEvent e)
{
var path = e.Path;
switch (e.ChangeType)
{
case ChangeType.Created:
_createEventHandler.Handle(path);
break;
case ChangeType.Changed:
_changeEventHandler.Handle(path);
break;
case ChangeType.Deleted:
_deleteEventHandler.Handle(path);
break;
case ChangeType.Rename:
_renameEventHandler.Handle(e.OldPath, path);
break;
case ChangeType.Log:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
public FileSystemEventData(
AbsoluteFilePath file,
FileSystemEvent evt,
Optional <AbsoluteFilePath> oldFile = default(Optional <AbsoluteFilePath>))
{
File = file;
Event = evt;
OldFile = oldFile;
}
private void FireEvent(string path)
{
FileSystemEvent evt = this.Change;
if (evt != null)
{
evt(path);
}
}
void OnFSeventClose(FSEvent fsEvent, FileSystemEvent fileSystemEvent)
{
this.callbackCount++;
if (this.callbackCount == 3)
{
fsEvent.CloseHandle(this.OnClose);
}
}
private void FlushPostponedEvents(FileSystemEvent fileEvent)
{
if (postponedEvents.ContainsKey(fileEvent.Filename))
{
var postponedEvent = postponedEvents[fileEvent.Filename];
postponedEvents.Remove(fileEvent.Filename);
DeliverEvent(postponedEvent, false);
}
}
private bool EventShouldBeIgnored(FileSystemEvent fileEvent)
{
if (fileEvent is RenameOrMoveEvent)
{
return(fileEvent.Filename.StartsWith(RECYCLE_BIN_PREFIX, StringComparison.CurrentCultureIgnoreCase));
}
return(false);
}
void OnFSEventFile(FSEvent fsEvent, FileSystemEvent fileSystemEvent)
{
if (fileSystemEvent.EventType == FSEventType.Change)
{
this.callbackCount++;
}
fsEvent.Stop();
fsEvent.CloseHandle(this.OnClose);
}
void OnFSEventDirectory(FSEvent fsEvent, FileSystemEvent fileSystemEvent)
{
if (fileSystemEvent.EventType == FSEventType.Rename)
{
this.callbackCount++;
}
fsEvent.Stop();
fsEvent.CloseHandle(this.OnClose);
}
private void FireEvent(string path)
{
Console.WriteLine("Change detected at: {0}", path);
FileSystemEvent evt = Change;
if (evt != null)
{
evt(path);
}
}
private static FileSystemEvent CreateFileSystemEvent(LogRecord record, string[] strings)
{
var fileSystemEvent = new FileSystemEvent()
{
Filename = PathConverter.ReplaceDevicePath(strings[0]),
ProcessId = record.Data.ProcessId,
Type = record.Data.EventType
};
return(fileSystemEvent);
}
void OnFSEventFileCurrentDir(FSEvent fsEvent, FileSystemEvent fileSystemEvent)
{
if (this.callbackCount == 0 &&
fileSystemEvent.EventType == FSEventType.Change &&
!string.IsNullOrEmpty(fileSystemEvent.FileName))
{
this.callbackCount++;
}
this.loop.CreateTimer()
.Start(this.OnTimerClose, 250, 0);
}
private void FireChangedEvent(FileSystemObserverKey key)
{
FileSystemEvent evt = ChangedEvent;
if (evt != null)
{
// make sure the path still exist before throwing an event
if (PathExists(key.FullPath) && CheckIfWeWantToFireThisEvent(key.FullPath))
{
// okay you can fire the Changed event now
evt(key.FullPath);
}
}
}
private void HandleFileEvent(FileSystemEvent fileEvent)
{
if (fileEvent.Type == EventType.Close)
{
FlushPostponedEvents(fileEvent);
}
else if (CanBePostponed(fileEvent) && AggregateEvents)
{
PostponeEventDelivery(fileEvent);
}
else if (!EventShouldBeIgnored(fileEvent))
{
DeliverEvent(fileEvent, AggregateEvents);
}
}
void OnFSEventDirMultipleFile(FSEvent fsEvent, FileSystemEvent fileSystemEvent)
{
this.callbackCount++;
if (this.fileCreated + this.fileRemoved == FileEventCount)
{
// Once we've processed all create events, delete all files
this.timer.Start(this.OnTimerDeleteFile, 1, 0);
}
else if (this.callbackCount == 2 * FileEventCount)
{
// Once we've processed all create and delete events, stop watching
this.timer.CloseHandle(this.OnClose);
fsEvent.CloseHandle(this.OnClose);
}
}
public void Work(FileSystemEvent e)
{
_inner.Work(e);
if (e.EventArgs.FullPath.Contains(".svn"))
{
return;
}
_logger.DebugFormat("Work completed for {0}.", e.EventArgs.Name);
if (_nextTaskSource != null)
{
_nextTaskSource.SetResult(e);
_nextTaskSource = null;
}
}
private void FireDeletedEvent(FileSystemObserverKey key)
{
FileSystemEvent evt = DeletedEvent;
if (evt != null)
{
// if the Path still exist on the fileSystem then it wasn't deleted
// this can happen during the saving file process.
// Don't thrown this event unless the path doesn't exist
if (!PathExists(key.FullPath) && CheckIfWeWantToFireThisEvent(key.FullPath))
{
// remove the path from existing paths
_existingPaths.Remove(key.FullPath);
// okay you can fire the Deleted event now
evt(key.FullPath);
}
}
}
private void FireCreatedEvent(FileSystemObserverKey key)
{
FileSystemEvent evt = CreatedEvent;
if (evt != null)
{
// check if the path still exist before firing this created event. this should filter out some temp files
if (PathExists(key.FullPath) && CheckIfWeWantToFireThisEvent(key.FullPath))
{
// check if path already exist. Can't create a path that already exist.
if (!_existingPaths.Contains(key.FullPath))
{
// need to add this to the existing paths list
_existingPaths.Add(key.FullPath);
// okay you can fire the Created event now
evt(key.FullPath);
}
}
}
}
static void Main(string[] args)
{
EventLooper looper = new EventLooper(null);
FileSystemEvent fsEvent = new FileSystemEvent(
null,
looper,
null
);
fsEvent.Start(
@"F:\",
FileSystemEventFlags.WatchEntry,
(name, eventType) =>
{
Console.WriteLine(name);
Console.WriteLine(eventType);
}
);
looper.Run();
}
private void DeliverEvent(FileSystemEvent fileEvent, bool postponeDelivery)
{
switch (fileEvent.Type)
{
case EventType.Change:
OnChange?.Invoke(fileEvent.Filename, fileEvent.ProcessId);
break;
case EventType.Create:
OnCreate?.Invoke(fileEvent.Filename, fileEvent.ProcessId);
break;
case EventType.Delete:
OnDelete?.Invoke(fileEvent.Filename, fileEvent.ProcessId);
break;
case EventType.Move:
OnRenameOrMove?.Invoke(fileEvent.Filename, ((RenameOrMoveEvent)fileEvent).OldFilename, fileEvent.ProcessId);
break;
default:
break;
}
}
void HandleFileSystemDeleted(FileSystemEvent fileEvent)
{
RemoveHash(fileEvent.Path);
}
void HandleFileSystemDeleted(FileSystemEvent fileEvent)
{
RemoveHash(fileEvent.Path);
}
void OnFSEvent(FSEvent fsEvent, FileSystemEvent fileSystemEvent) => this.callbackCount++;
private bool CanBePostponed(FileSystemEvent fileEvent)
{
return(fileEvent.Type == EventType.Change || fileEvent.Type == EventType.Create);
}
void HandleFileSystemChangedAndCreated(FileSystemEvent fileEvent)
{
HandleHash(fileEvent.Path, GenerateHashForFile(fileEvent.Path));
}
public void Add(FileSystemEvent e) => _eventQueue.Enqueue(e);
void FireEvent(string path)
{
FileSystemEvent evt = Change;
evt(path);
}
void HandleFileSystemChangedAndCreated(FileSystemEvent fileEvent)
{
HandleHash(fileEvent.Path, GenerateHashForFile(fileEvent.Path));
}
