private void ProcessFileWatcherEvent(FileSystemEventArgs e)
{
FileWatcherEventArgs args = new FileWatcherEventArgs();
args.FileName = e.Name;
args.EventName = e.ChangeType.ToString();
args.EventTime = DateTime.Now;
OnFileProcess?.Invoke(this, args);
//
string time_string =
String.Format("{0:D4}-{1:D2}-{2:D2} {3:D2}:{4:D2}:{5:D2}:{6:D4}",
args.EventTime.Year, args.EventTime.Month, args.EventTime.Day, args.EventTime.Hour, args.EventTime.Minute, args.EventTime.Second, args.EventTime.Millisecond);
string s = String.Format("{0,-24} - {1,-10} - {2,-255}", time_string, args.EventName, args.FileName);
_logger.WriteLine(s);
//
string destFileName = Path.Combine(_watcherParams.OutputDir, e.Name);
string sourceFileName = e.FullPath;
//
if (!File.Exists(destFileName) && e.ChangeType == WatcherChangeTypes.Created)
{
_queueTaskWorker.AddToQueue(args);
}
else if (File.Exists(destFileName) && e.ChangeType == WatcherChangeTypes.Deleted)
{
File.Delete(destFileName);
}
else if (File.Exists(destFileName) && e.ChangeType == WatcherChangeTypes.Changed)
{
_queueTaskWorker.AddToQueue(args);
}
}
/// <summary>
/// Multithreading
/// </summary>
/// <param name="handler"></param>
/// <param name="e"></param>
void EventHandler(FileWatcherEvent handler, EventArgs e)
{
var fileWatcherEventArgs = new FileWatcherEventArgs(e);
handler?.Invoke(fileWatcherEventArgs);
AllChanged?.Invoke(fileWatcherEventArgs);
}
public void ShouldWatchRenamedFile()
{
// Arrange
FileWatcherEventArgs args = null;
const string fileName = "FileWatcherRename.test";
const string fileName2 = "FileWatcherRename2.test";
FileWatcher fileWatcher = new FileWatcher(new FileInfo(fileName));
fileWatcher.OnChange += (s, a) => args = a;
using (StreamWriter writer = File.CreateText(fileName))
{
writer.WriteLine();
writer.Flush();
}
// Act
fileWatcher.Start();
File.Move(fileName, fileName2);
Thread.Sleep(1200);
FileWatcherEventArgs previousArgs = args;
fileWatcher.ChangeFileToWatch(new FileInfo(fileName2));
fileWatcher.Start();
File.Delete(fileName2);
Thread.Sleep(1200);
fileWatcher.Dispose();
// Assert
Assert.IsNotNull(previousArgs);
Assert.IsTrue(previousArgs.IsFileNameChanged);
Assert.IsNotNull(previousArgs.NewFilePath);
Assert.AreEqual(fileName2, new FileInfo(previousArgs.NewFilePath).Name);
Assert.IsNotNull(args);
Assert.IsTrue(args.IsFileDeleted);
}
public void ShouldWatchChangedFile()
{
// Arrange
FileWatcherEventArgs args = null;
const string fileName = "FileWatcherChange.test";
FileWatcher fileWatcher = new FileWatcher(new FileInfo(fileName));
fileWatcher.OnChange += (s, a) => args = a;
using (StreamWriter writer = File.CreateText(fileName))
{
writer.WriteLine();
writer.Flush();
}
// Act
fileWatcher.Start();
using (StreamWriter writer = new StreamWriter(fileName, true))
{
writer.WriteLine();
writer.Flush();
}
Thread.Sleep(1200);
fileWatcher.Dispose();
File.Delete(fileName);
// Assert
Assert.IsNotNull(args);
Assert.IsTrue(args.IsFileChanged);
}
public void RenameFileTest()
{
string fileName = Path.Combine(_testDirectory, "Test.txt");
File.WriteAllText(fileName, "Test");
var settings = new FileWatchSetting();
settings.Directory = _testDirectory;
settings.DelayInMS = 100;
FileWatcherEventArgs args = null;
int events = 0;
using (var watch = new FileWatch(settings))
{
watch.StartWatching();
watch.Changed += (o, a) =>
{
args = a;
events++;
};
string newFileName = Path.Combine(_testDirectory, "TestNew.txt");
File.Move(fileName, newFileName);
Thread.Sleep(50);
Assert.AreEqual(0, events);
Thread.Sleep(80);
Assert.AreEqual(1, events);
Assert.AreEqual(1, args.NewFiles.Length);
Assert.AreEqual(newFileName, args.NewFiles[0]);
Assert.AreEqual(0, args.ChangedFiles.Length);
Assert.AreEqual(1, args.DeletedFiles.Length);
Assert.AreEqual(fileName, args.DeletedFiles[0]);
Thread.Sleep(200);
Assert.AreEqual(1, events);
};
}
public void NewAndChangeDeleteFileTest()
{
var settings = new FileWatchSetting();
settings.Directory = _testDirectory;
settings.DelayInMS = 100;
FileWatcherEventArgs args = null;
int events = 0;
using (var watch = new FileWatch(settings))
{
watch.StartWatching();
watch.Changed += (o, a) =>
{
args = a;
events++;
};
string fileName = Path.Combine(_testDirectory, "Test.txt");
File.WriteAllText(fileName, "Test");
Thread.Sleep(20);
File.AppendAllText(fileName, "Test");
Thread.Sleep(20);
File.Delete(fileName);
Thread.Sleep(20);
Assert.AreEqual(0, events);
Thread.Sleep(100);
Assert.AreEqual(0, events);
};
}
public void AddToQueue(FileWatcherEventArgs fileWatcherEventArgs)
{
lock (_lockObject)
{
_uniqueQueue.Enqueue(fileWatcherEventArgs);
}
}
private static void ProcessQueue()
{
while (_stopQueue == false)
{
int count = 0;
FileWatcherEventArgs fileWatcherEventArgs = null;
lock (_lockObject)
{
count = _uniqueQueue.Count;
}
while (_stopQueue == false && count > 0)
{
fileWatcherEventArgs = _uniqueQueue.Peek();
string sourceFileName = Path.Combine(_fileWatcherParams.InputDir, Path.GetFileName(fileWatcherEventArgs.FileName));
string destFileName = Path.Combine(_fileWatcherParams.OutputDir, Path.GetFileName(fileWatcherEventArgs.FileName));
Task task = CopyFileEx(sourceFileName, destFileName);
task.Wait();
lock (_lockObject)
{
_uniqueQueue.Dequeue();
count = _uniqueQueue.Count;
Debug.WriteLine($"{Path.GetFileName(fileWatcherEventArgs.FileName)}, Queue items: {count}");
}
}
Thread.Sleep(100);
}
}
public void MultipleChangesWhileDelayTimeTest()
{
string fileName1 = Path.Combine(_testDirectory, "Test1.txt");
File.WriteAllText(fileName1, "Test");
string fileName2 = Path.Combine(_testDirectory, "Test2.txt");
File.WriteAllText(fileName2, "Test");
var settings = new FileWatchSetting();
settings.Directory = _testDirectory;
settings.DelayInMS = 100;
FileWatcherEventArgs args = null;
int events = 0;
using (var watch = new FileWatch(settings))
{
watch.StartWatching();
watch.Changed += (o, a) =>
{
args = a;
events++;
};
string fileName3 = Path.Combine(_testDirectory, "Test3.txt");
File.WriteAllText(fileName3, "Test");
string fileName4 = Path.Combine(_testDirectory, "Test4.txt");
File.WriteAllText(fileName4, "Test");
Thread.Sleep(50);
Assert.AreEqual(0, events);
Thread.Sleep(80);
Assert.AreEqual(1, events);
Assert.AreEqual(2, args.NewFiles.Length);
Assert.AreEqual(fileName3, args.NewFiles[0]);
Assert.AreEqual(fileName4, args.NewFiles[1]);
Assert.AreEqual(0, args.ChangedFiles.Length);
Assert.AreEqual(0, args.DeletedFiles.Length);
Thread.Sleep(200);
Assert.AreEqual(1, events);
File.Delete(fileName1);
File.Delete(fileName2);
File.AppendAllText(fileName3, "Test");
File.AppendAllText(fileName4, "Test");
string fileName5 = Path.Combine(_testDirectory, "Test5.txt");
File.WriteAllText(fileName5, "Test");
string fileName6 = Path.Combine(_testDirectory, "Test6.txt");
File.WriteAllText(fileName6, "Test");
Thread.Sleep(50);
Assert.AreEqual(1, events);
Thread.Sleep(80);
Assert.AreEqual(2, events);
Assert.AreEqual(fileName5, args.NewFiles[0]);
Assert.AreEqual(fileName6, args.NewFiles[1]);
Assert.AreEqual(fileName3, args.ChangedFiles[0]);
Assert.AreEqual(fileName4, args.ChangedFiles[1]);
Assert.AreEqual(fileName1, args.DeletedFiles[0]);
Assert.AreEqual(fileName2, args.DeletedFiles[1]);
Thread.Sleep(200);
Assert.AreEqual(2, events);
};
}
private void Watcher_FileChanged(object sender, FileWatcherEventArgs e)
{
this.logFileContent.InvokeIfRequired(() =>
{
this.logFileContent.AppendText(e.AppendedContent);
this.logFileContent.ScrollToCaret();
});
}
private void _fileWatcher_FileChanged(object sender, FileWatcherEventArgs e)
{
if (!New <LicensePolicy>().Capabilities.Has(LicenseCapability.SecureFolders))
{
return;
}
OnChanged(e);
}
protected virtual void OnChanged(FileWatcherEventArgs eventArgs)
{
EventHandler <FileWatcherEventArgs> fileChanged = FileChanged;
if (fileChanged != null)
{
fileChanged(null, eventArgs);
}
}
private void FileSystemChanged(FileWatcherEventArgs e)
{
if (Resolve.Log.IsInfoEnabled)
{
Resolve.Log.LogInfo("Watcher says {0} changed.".InvariantFormat(e.FullNames.Aggregate(String.Empty, (acc, fullName) => acc + "'" + fullName + "' ")));
}
lock (_notifications)
{
_notifications.Add(e);
}
_delayedAction.StartIdleTimer();
}
private async void HandleWorkFolderFileChangedEvent(object sender, FileWatcherEventArgs e)
{
foreach (string fullName in e.FullNames)
{
if (fullName == Resolve.FileSystemState.PathInfo.FullName)
{
continue;
}
await Resolve.SessionNotify.NotifyAsync(new SessionNotification(SessionNotificationType.WorkFolderChange, fullName));
}
}
private void SendNotification()
{
for (int i = 1; i <= 20; i++)
{
FileWatcherEventArgs args = new FileWatcherEventArgs();
args.FileName = i.ToString().PadLeft(4, '0') + ".xml";
args.EventName = (i % 2 == 0) ? "Changed" : "Created";
args.EventTime = DateTime.Now;
//
OnFileProcess?.Invoke(this, args);
}
}
private async void watchedFolder_Changed(object sender, FileWatcherEventArgs e)
{
WatchedFolder watchedFolder = (WatchedFolder)sender;
foreach (string fullName in e.FullNames)
{
IDataItem dataItem = New <IDataItem>(fullName);
await HandleWatchedFolderChangesAsync(watchedFolder, dataItem);
await Resolve.SessionNotify.NotifyAsync(new SessionNotification(SessionNotificationType.WatchedFolderChange, dataItem.FullName));
}
}
/// <summary>
/// Handles system changed event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">Event data.</param>
/// <exception cref="ArgumentNullException">e is null.</exception>
protected virtual void OnSystemChanged(object sender,
FileWatcherEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e",
Resources.ArgumentNullException);
}
if (e.ConfigurationKeyValuePair.Value.LogFileSystemChange)
{
AddLogMessage(_formatter.Format(e));
}
}
/// <summary>
/// Handles system changed event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">Event data.</param>
/// <exception cref="ArgumentNullException">e is null.</exception>
protected override void OnSystemChanged(object sender,
FileWatcherEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e",
Resources.ArgumentNullException);
}
base.OnSystemChanged(sender, e);
_fileWatcherSortedDictionary[e.ConfigurationKeyValuePair.Key].LastEventType =
e.ChangeType;
_fileWatcherSortedDictionary[e.ConfigurationKeyValuePair.Key].LastEventTime =
e.DateTime.ToLocalTime().ToString(CultureInfo.CurrentCulture);
IncreaseEventCount(e.ConfigurationKeyValuePair.Key);
UpdateList(false);
}
/// <summary>
/// Handles system changed event.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">Event data.</param>
/// <exception cref="ArgumentNullException">e is null.</exception>
protected override void OnSystemChanged(object sender,
FileWatcherEventArgs e)
{
if (e == null)
{
throw new ArgumentNullException("e",
Resources.ArgumentNullException);
}
base.OnSystemChanged(sender, e);
if (e.ConfigurationKeyValuePair.Value.DisplayFileSystemChange)
{
_consoleView.EchoLine(String.Format(CultureInfo.CurrentCulture,
Resources.MessageFileChanged,
@e.ChangeType,
@e.FileName));
}
}
/// <summary>
/// Formats message.
/// </summary>
/// <param name="fileWatcherEventArgs">Message.</param>
/// <returns>Formatted message.</returns>
/// <exception cref="ArgumentNullException">fileWatcherEventArgs is null.</exception>
public string Format(FileWatcherEventArgs fileWatcherEventArgs)
{
if (fileWatcherEventArgs == null)
{
throw new ArgumentNullException("fileWatcherEventArgs",
Resources.ArgumentNullException);
}
if (String.Compare(fileWatcherEventArgs.ChangeType, Resources.ChangeTypeSystemGenerated, StringComparison.Ordinal) == 0)
{
return(String.Format(CultureInfo.CurrentCulture,
@Resources.MessageFileSystemChange,
@DateTime.Now,
@Resources.MessageTypeInfo,
@Resources.MessageSystemGenerated,
@fileWatcherEventArgs.FullPath));
}
return(String.Format(CultureInfo.CurrentCulture,
@Resources.MessageFileSystemChange,
@DateTime.Now,
@Resources.MessageTypeInfo,
@fileWatcherEventArgs.ChangeType.ToLower(CultureInfo.CurrentCulture),
@fileWatcherEventArgs.FullPath));
}
private void HandleWorkFolderFileChangedEvent(object sender, FileWatcherEventArgs e)
{
NotifyWorkFolderStateChanged();
}
protected void OnADUserFileChanged(object sender, FileWatcherEventArgs e)
{
InvokeTaskForRun();
}
protected void OnObjectFileChanged(object sender, FileWatcherEventArgs e)
{
CheckFiledChanged(ref IsObjectFileChanged);
}
protected void OnReferenceFileChanged(object sender, FileWatcherEventArgs e)
{
CheckFiledChanged(ref IsReferenceFileChanged);
}
protected virtual void OnChanged(FileWatcherEventArgs e)
{
Changed?.Invoke(this, e);
}
private void _fileWatcher_OnFileProcess(object sender, FileWatcherEventArgs e)
{
_syncContext.Post(o => AddInfoLine(e.FileName, e.EventName, e.EventTime), null);
}
void HandleExcelChange(object sender, FileWatcherEventArgs args)
{
Console.WriteLine("Excel change called");
}
/// <summary>
/// 文件发生变动事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void WatcherChangedEvent(object sender, FileWatcherEventArgs e)
{
AddToBackupFiles(e.FullPath);
}
private async void HandleActiveFileFolderChangedEvent(object sender, FileWatcherEventArgs e)
{
await Resolve.SessionNotify.NotifyAsync(new SessionNotification(SessionNotificationType.UpdateActiveFiles, e.FullNames));
}
public void StartTextImport([FromBody] FileWatcherEventArgs args)
{
_logger.LogInformation("Text import triggered");
}
