// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
if (!IsFileLocked(e.FullPath)) {
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
}
protected void OnDeleted(object sender, FileSystemEventArgs args)
{
var onDeleted = Deleted;
if (onDeleted != null)
{
onDeleted(sender, args);
}
}
private void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
if (!useKeyboard) {
flagFileChanged = true;
locSoundFile = e.Name;
}
}
static void Deleted (object sender, FileSystemEventArgs args)
{
if (args.ChangeType != WatcherChangeTypes.Deleted)
throw new Exception (string.Format ("Wrong ChangeType: {0} instead of {1}.",
args.ChangeType, WatcherChangeTypes.Deleted));
_events.Add (args);
}
static void FrameAdded(object source, FileSystemEventArgs e)
{
try {
maxFrame = LineSynchronizer.LastRecordedFrameNumber();
if (frame > maxFrame) {
frame = maxFrame;
}
} catch (IOException) { }
}
public void RaseEventThrowsArgumentExceptionOnUnknownEvent()
{
MockFileSystemWatcher mockWatcher = new MockFileSystemWatcher();
using (SafeEventFileSystemWatcher tested = new SafeEventFileSystemWatcher(mockWatcher))
{
var evt = new FileSystemEventArgs((WatcherChangeTypes)666, "", "");
DoAssert.Throws<ArgumentException>(() => tested.RaiseEvent(evt));
}
}
private static void RunTests(object source, FileSystemEventArgs e)
{
DateTime lastWriteTime = File.GetLastWriteTime(e.FullPath);
if (lastWriteTime != lastRead)
{
Console.WriteLine("File event occured, requesting test run");
HttpClient client = new HttpClient();
client.GetAsync("http://localhost:5004/api/TestRunner");
lastRead = lastWriteTime;
}
}
public static void FileSystemEventArgs_ctor(WatcherChangeTypes changeType, string directory, string name)
{
FileSystemEventArgs args = new FileSystemEventArgs(changeType, directory, name);
if (!directory.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
{
directory += Path.DirectorySeparatorChar;
}
Assert.Equal(changeType, args.ChangeType);
Assert.Equal(directory + name, args.FullPath);
Assert.Equal(name, args.Name);
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
try
{
//to avoid double changes
watcher.EnableRaisingEvents = false;
//elaborate info about file
//FileInfo fi = new FileInfo(e.FullPath);
//exclude files started from '~','$' and '.'(hidden files)
//if (fi.Name[0].Equals('~') == false && fi.Name[0].Equals('$') == false && fi.Name[0].Equals('.') == false && fi.Extension.Equals(".tmp") == false && fi.Extension.Equals(".TMP") == false && fi.Extension.Equals("") == false)
//{
// Determine if entry is directory or file
if (Directory.Exists(e.FullPath))
{ //directory
DirectoryInfo di = new DirectoryInfo(e.FullPath);
Console.WriteLine("Directory: " + e.FullPath + " " + e.ChangeType);
}
if (File.Exists(e.FullPath))
{
//file
/******Usefull but not working*****/
/*
//check if file is hidden or not
if ((fi.Attributes & FileAttributes.Hidden) ==FileAttributes.Hidden)
{
//file is not hidden
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
*/
//FileInfo fi = new FileInfo(e.FullPath);
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
}
//}
}
catch (System.UnauthorizedAccessException) {
//file protetto o non puo essere aperto perche' e' eseguibile
Console.WriteLine("PROTECTED File: " + e.FullPath + " " + e.ChangeType);
}
finally
{
watcher.EnableRaisingEvents = true;
}
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
// Specify what is done when a file is changed, created, or deleted.
//Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
if (e.ChangeType.Equals(WatcherChangeTypes.Created))
{
FileManager.Copy(sourceFolder, targetFolder, e.Name);
} else if (e.ChangeType.Equals(WatcherChangeTypes.Deleted))
{
FileManager.Delete(targetFolder, e.Name);
}
}
// Define the event handlers.
private static void OnChanged(object source, FileSystemEventArgs e)
{
try
{
watcher.EnableRaisingEvents = false;
// Specify what is done when a file is changed, created, or deleted.
Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
File.Copy(e.FullPath,
Path.Combine(Path.Combine(dir, "CONFIGBAK"), DateTime.Now.ToString("yyyy-MM-dd-hh-mm-ss") + "_" + e.Name));
}
finally
{
watcher.EnableRaisingEvents = true;
}
}
public void method_0(FileSystemEventArgs fileSystemEventArgs_0)
{
foreach (ListViewItem item2 in this.listView1.Items)
{
if (item2.ToolTipText.CompareIgnoreCase(fileSystemEventArgs_0.FullPath))
{
return;
}
}
ListViewItem item = new ListViewItem(fileSystemEventArgs_0.Name, 0) {
ToolTipText = fileSystemEventArgs_0.FullPath
};
item.SubItems.Add(fileSystemEventArgs_0.ChangeType.ToString());
item.Tag = fileSystemEventArgs_0;
this.listView1.Items.Add(item);
}
// Define the event handlers.
private static void OnDeleted(object source, FileSystemEventArgs e)
{
if (!Path.HasExtension(e.FullPath))
{
//directory: a file with no extension is treated like a directory
Console.WriteLine("Directory: " + e.FullPath + " Deleted");
}
else
{
//file
if ( !Path.GetFileName(e.FullPath)[0].Equals('~') && !Path.GetFileName(e.FullPath)[0].Equals('$') &&
!Path.GetFileName(e.FullPath)[0].Equals('~') && !Path.GetExtension(e.FullPath).Equals(".tmp") &&
!Path.GetExtension(e.FullPath).Equals(".TMP") )
{
Console.WriteLine("File: " + e.FullPath + " Deleted");
}
}
}
private static void OnCreated(object source, FileSystemEventArgs e)
{
if (Directory.Exists(e.FullPath))
{
//directory
//DirectoryInfo di = new DirectoryInfo(e.FullPath);
Console.WriteLine("Directory: " + e.FullPath + " Created");
}
if (File.Exists(e.FullPath))
{
//exclude files started from '~','$' and '.'(hidden files) and without extensions
FileInfo fi = new FileInfo(e.FullPath);
if ( !fi.Name[0].Equals('~') && !fi.Name[0].Equals('$') && !fi.Name[0].Equals('.') &&
!fi.Extension.Equals(".tmp") && !fi.Extension.Equals(".TMP") && !fi.Extension.Equals("") )
{
//file
Console.WriteLine("File: " + e.FullPath + " Created");
}
}
}
void watcher_Changed(object sender, FileSystemEventArgs e)
{
FSWatcher watcher = (FSWatcher)sender;
try
{
using (FileStream fs = new FileStream(e.FullPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
fs.Seek(watcher.currentPosition, SeekOrigin.Begin);
using (StreamReader reader = new StreamReader(fs, Encoding.UTF8))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.Length > 0 && OnNewLine != null)
{
OnNewLine(line);
}
}
if (fs.Length > 0)
watcher.currentPosition = fs.Length;
}
fs.Close();
}
}
#if DEBUG
catch (Exception err)
{
System.Diagnostics.Debug.WriteLine("FSWatcher: " + err.Message);
}
#else
catch
{
}
#endif
}
void watcher_Created(object sender, FileSystemEventArgs e)
{
this.OnFileFound(new PluginDirectoryEventArgs(e.FullPath));
}
private void OnWatcher_Created(object sender, FileSystemEventArgs e)
{
string ext = Path.GetExtension(e.FullPath).Replace(".", "");
string directory = e.FullPath;
if (ext != "")
{
directory = e.FullPath.Replace("\\" + Path.GetFileName(e.FullPath), "");
TreeNode[] nodes = Nodes.Find(directory, true);
nodes[0].Nodes.Add(e.FullPath, Path.GetFileName(e.FullPath), ext, ext);
nodes[0].Nodes[e.FullPath].ContextMenuStrip = contextMenu;
}
else if (Path.GetDirectoryName(directory).Equals(pathProject))
{
Nodes.Add(e.FullPath, GetDirectory(e.FullPath), "briefcaseClose", "briefcaseClose");
Nodes[e.FullPath].ContextMenuStrip = contextMenu;
}
else
{
directory = Path.GetDirectoryName(directory);
TreeNode[] nodes = Nodes.Find(directory, true);
nodes[0].Nodes.Add(e.FullPath, GetDirectory(e.FullPath), "folderClose", "folderClose");
nodes[0].Nodes[e.FullPath].ContextMenuStrip = contextMenu;
}
}
// temporary
private void Watcher_Changed(object sender, FileSystemEventArgs e)
{
try
{
Logger.LogWarning("Updating account aliases");
var json = File.ReadAllText(Config.AccountsPath);
var accounts = JsonSerializer.Deserialize <List <AccountMetadata> >(json);
var dic1 = Metadata.Values.ToDictionary(x => Aliases.First(a => a.Alias == x.Alias).Address);
var changed = new List <AccountMetadata>();
foreach (var acc2 in accounts)
{
if (!dic1.TryGetValue(acc2.Address, out var acc1) ||
acc2.Alias != acc1.Alias ||
acc2.Description != acc1.Description ||
acc2.Discord != acc1.Discord ||
acc2.Email != acc1.Email ||
acc2.Facebook != acc1.Facebook ||
acc2.Github != acc1.Github ||
acc2.Instagram != acc1.Instagram ||
acc2.Kind != acc1.Kind ||
acc2.Logo != acc1.Logo ||
acc2.Owner != acc1.Owner ||
acc2.Reddit != acc1.Reddit ||
acc2.Riot != acc1.Riot ||
acc2.Site != acc1.Site ||
acc2.Slack != acc1.Slack ||
acc2.Support != acc1.Support ||
acc2.Telegram != acc1.Telegram ||
acc2.Twitter != acc1.Twitter)
{
changed.Add(acc2);
}
}
Logger.LogWarning($"{changed.Count} changes detected");
if (changed.Count > 0)
{
using var db = GetConnection();
var links = db.Query <(int Id, string Address)>(
@"
SELECT ""Id"", ""Address""
FROM ""Accounts""
WHERE ""Address"" = ANY (@addresses)
",
new { addresses = changed.Select(x => x.Address).ToArray() });
foreach (var(Id, Address) in links)
{
var acc = changed.First(x => x.Address == Address);
if (!Metadata.ContainsKey(Id))
{
Aliases.Add(new AccountMetadataAlias
{
Address = acc.Address,
Alias = acc.Alias,
Logo = acc.Logo
});
Metadata.Add(Id, acc);
}
else
{
var alias = Aliases.First(x => x.Address == Address);
alias.Alias = acc.Alias;
alias.Logo = acc.Logo;
Metadata[Id] = acc;
}
}
Logger.LogWarning($"{links.Count()} changes applied");
}
}
catch (Exception ex)
{
Logger.LogError($"Failed to refresh account aliases: {ex.Message}");
}
}
//create a blob of the file added to the folder we are watching in azure
public void OnChanged(object source, FileSystemEventArgs e)
{
CloudStorageProvider.Create(FilePath, e.Name);
}
private void thr_onFileChanged(object source, FileSystemEventArgs e)
{
disp.BeginInvoke(DispatcherPriority.Normal, new onFileChangedDelegate(onFileChanged), e);
}
private void UpdateUIWithDiffThread(FileSystemEventArgs e)
{
richUpdate.ForeColor = e.ChangeType == WatcherChangeTypes.Created ? Color.Blue : Color.Magenta;
richUpdate.AppendText(string.Format("File {0}, {1}{2}{3}", e.FullPath, e.ChangeType, Environment.NewLine, Environment.NewLine));
}
static void fsw_Created(object sender, FileSystemEventArgs e)
{
Console.WriteLine("{0} ({1})", e.FullPath, e.ChangeType);
Console.ReadKey();
}
private void FileWatcher_CreateOrDelete(object sender, FileSystemEventArgs e)
{
if (mmApp.Model == null || mmApp.Model.Window == null)
{
return;
}
if (!Directory.Exists(FolderPath))
{
FolderPath = null;
return;
}
var file = e.FullPath;
if (string.IsNullOrEmpty(file))
{
return;
}
if (e.ChangeType == WatcherChangeTypes.Deleted)
{
mmApp.Model.Window.Dispatcher.Invoke(() =>
{
var pi = FolderStructure.FindPathItemByFilename(ActivePathItem, file);
if (pi == null)
{
return;
}
pi.Parent.Files.Remove(pi);
//Debug.WriteLine("After: " + pi.Parent.Files.Count + " " + file);
}, DispatcherPriority.ApplicationIdle);
}
if (e.ChangeType == WatcherChangeTypes.Created)
{
mmApp.Model.Window.Dispatcher.Invoke(() =>
{
// Skip ignored Extensions
string[] extensions = null;
if (!string.IsNullOrEmpty(mmApp.Model.Configuration.FolderBrowser.IgnoredFileExtensions))
{
extensions = mmApp.Model.Configuration.FolderBrowser.IgnoredFileExtensions.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
}
if (extensions != null && extensions.Any(ext => file.EndsWith(ext, StringComparison.InvariantCultureIgnoreCase)))
{
return;
}
var pi = FolderStructure.FindPathItemByFilename(ActivePathItem, file);
if (pi != null) // Already exists in the tree
{
return;
}
// does the path exist?
var parentPathItem =
FolderStructure.FindPathItemByFilename(ActivePathItem, Path.GetDirectoryName(file));
// Path either doesn't exist or is not expanded yet so don't attach - opening will trigger
if (parentPathItem == null ||
(parentPathItem.Files.Count == 1 && parentPathItem.Files[0] == PathItem.Empty))
{
return;
}
bool isFolder = Directory.Exists(file);
pi = new PathItem()
{
FullPath = file,
IsFolder = isFolder,
IsFile = !isFolder,
Parent = parentPathItem
};
pi.SetIcon();
FolderStructure.InsertPathItemInOrder(pi, parentPathItem);
}, DispatcherPriority.ApplicationIdle);
}
}
private static void OnAdd(object sender, FileSystemEventArgs e)
{
System.Diagnostics.Debug.WriteLine("detected file change");
}
void folderWatcher_Changed(object sender, FileSystemEventArgs e)
{
IRunnerBroadcaster runnerBroadcaster = _ResourceResolver.Resolve <IRunnerBroadcaster>();
runnerBroadcaster.StartAll();
}
void LoadCurrentMentors(object source, FileSystemEventArgs e)
{
LoadCurrentMentors();
}
void LoadWhiteList(object source, FileSystemEventArgs e)
{
LoadWhiteList();
}
private void PackagesChanged(object sender, FileSystemEventArgs e)
{
// have a delay before refreshing because there's probably more than one write,
// so we wait until things have been quiet for a second.
_timer.Change(1000, Timeout.Infinite);
}
protected virtual void config_watcher_Changed(object sender, FileSystemEventArgs e)
{
if(e.ChangeType== WatcherChangeTypes.Changed&&e.Name==file_name) {
try {
loadSettings();
} catch (Exception ex) {
//MessageHandler.SendError("Settings Error","Error while auto-updating settings: " + ex.Message,ex);
}
}
}
private void FileSystemWatcher_Deleted(object sender, FileSystemEventArgs e)
{
this.OnDeleted(e.FullPath);
}
public void OnChanged(object sender, FileSystemEventArgs e)
{
Task.Factory.StartNew(() => updateDisplay());
}
//METODY PRZYPISANE DO EVENTÓW
/// <summary>
/// Metoda obsługująca FileSystemWatcher
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void FileSystemWatcher_Created(object sender, FileSystemEventArgs e)
{
Application.Current.Dispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => { button_Click(this, null); }));
}
private void OnChanged(object source, FileSystemEventArgs e)
{
if (_handleEvents)
{
try
{
_handleEvents = false;
_watcher.EnableRaisingEvents = false;
Dictionary <string, Config> sourceConfigs = new Dictionary <string, Config>();
string thisFile = e.FullPath;
Debug.WriteLine($"Trigger file is {thisFile}");
Thread.Sleep(250);
using (StreamReader sr = File.OpenText(e.FullPath))
{
using (JsonTextReader reader = new JsonTextReader(sr))
{
JObject jObject = (JObject)JToken.ReadFrom(reader);
foreach (var config in _watchedConfigs)
{
JToken t = jObject[config.Name];
if (t != null)
{
sourceConfigs.Add(config.Name, new Config {
Type = config.Type, Value = t.Value <string>()
});
}
}
}
}
if (sourceConfigs.Any())
{
string[] files = Directory.GetFiles(_watchedPath, _filter);
foreach (var file in files)
{
if (!file.Equals(thisFile))
{
JObject jObject = null;
List <JToken> targetTokens = new List <JToken>();
using (StreamReader sr = File.OpenText(file))
{
using (JsonTextReader reader = new JsonTextReader(sr))
{
jObject = (JObject)JToken.ReadFrom(reader);
foreach (var config in _watchedConfigs)
{
JToken t = jObject[config.Name];
if (t != null)
{
targetTokens.Add(t);
}
}
}
}
if (targetTokens.Any())
{
bool write = false;
foreach (var target in targetTokens)
{
foreach (var kvp in sourceConfigs)
{
if (target.Path.Equals(kvp.Key))
{
if (!target.Value <string>().Equals(kvp.Value.Value))
{
Debug.WriteLine($"Changing setting {kvp.Key} to {kvp.Value.Value}");
switch (kvp.Value.Type)
{
case "bool":
jObject[kvp.Key] = bool.Parse(kvp.Value.Value);
write = true;
break;
case "int":
jObject[kvp.Key] = int.Parse(kvp.Value.Value);
write = true;
break;
}
}
}
}
}
if (write)
{
Debug.WriteLine($"Writing file {file}");
// Globals.Chem4WordV3.OptionsReloadRequired = true;
string json = JsonConvert.SerializeObject(jObject, Formatting.Indented);
File.WriteAllText(file, json);
}
}
}
}
}
_watcher.EnableRaisingEvents = true;
_handleEvents = true;
}
catch
{
// Do Nothing
}
}
}
private void Watcher_Created(object sender, FileSystemEventArgs e)
{
Dispatcher.Invoke(RefreshRecordings);
}
private void OnChanged(object sender, FileSystemEventArgs e)
{
var templates = fileService.GetTemplates().ToList();
UpdateTemplate(e.FullPath, templates);
}
private void SampleTextsOnChange(object sender, FileSystemEventArgs fileSystemEventArgs)
{
_sampleTextsChanged = true;
}
private void UpdateUIWatcher(FileSystemEventArgs e) => _ = Invoke(new UpdateUIWatcherDelegate(UpdateUIWithDiffThread), e);
//////////////////////////////////////////////////
// Watcher event handlers
protected virtual void FileChanged(object source, FileSystemEventArgs e)
{
string s;
bool match = mFilterRe.IsMatch(e.Name);
// Log message depending on the file matches our filter or should be
// ignored
if (match)
{
s = string.Format("[{0}] {1} {2} {3}",
mName,
DateTime.Now.ToString(),
e.ChangeType,
e.Name);
}
else
{
s = string.Format("[{0}] {1} Ignored changes to {2}",
mName,
DateTime.Now.ToString(),
e.Name);
}
OnLog(s);
// Perform operation if the file matches
if (match)
{
Operation o = new Operation(e.ChangeType,
e.FullPath,
mWorkingDirectory,
new List<string>(mCommands));
mOperator.EnqueueOperation(o);
}
}
private void OnChanged(object sender, FileSystemEventArgs e)
{
InsertHeaderIntoCsvFile(e.FullPath, header);
UploadFileToSftpServer(host, port, username, password, sftpDir, e.FullPath);
}
private void OnChanged(object source, FileSystemEventArgs e)
{
this.PathChanged(e.FullPath);
}
static void OnDeleted(object sender, FileSystemEventArgs e)
{
Console.WriteLine("Delete: " + e.Name);
}
protected void OnDeleted(object sender, FileSystemEventArgs args)
{
if (Deleted != null)
Deleted(sender, args);
}
private void Watcher_Process(object sender, FileSystemEventArgs e)
{
this._action?.Invoke();
}
static void fw_created(object sender, FileSystemEventArgs e)
{
try
{
f.EnableRaisingEvents = false;
// count++;
Console.WriteLine("in the file handler {0}", e.FullPath);
string path = @e.FullPath;
int index = path.LastIndexOf("\\");
string p = path.Substring(0, index);
int index2 = p.LastIndexOf("\\");
string p1 = path.Substring(0, index2);
;
//string fName = @path;//path to text file
//StreamReader testTxt = new StreamReader(fName);
//string allRead = testTxt.ReadToEnd();//Reads the whole text file to the end
//testTxt.Close(); //Closes the text file after it is fully read.
//string regMatch = "LASTMODDATE";//string to search for inside of text file. It is case sensitive.
//if (Regex.IsMatch(allRead, regMatch))
//{
//If the match is found in allRead
//Console.WriteLine("new path {0}", p);
// if (count == 1)
//{
Console.WriteLine("Path to server is {0}", p1);
Console.WriteLine("in the file handler {0}", e.FullPath);
writer.WriteLine(p1);
writer.Flush();
//}
//}
//if (count == 2)
//count = 0;
//}
}
catch
{
Console.WriteLine("error in the handler for file");
}
}
// Define the event handlers.
public void OnChanged(object source, FileSystemEventArgs e)
{
// When a file is changed, created, or deleted.
string text = "File " + e.ChangeType.ToString().ToLower() + ": " + Path.GetFileName(e.FullPath.ToString()).ToString();
if (statusLabel.InvokeRequired)
{
statusLabel.Invoke(new MethodInvoker(delegate
{
Label sl = new Label();
sl = statusLabel;
sl.Text = text;
}));
}
updateProgress();
}
private static void OnChanged(object source, FileSystemEventArgs e)
{
Console.Error.WriteLine("** FS Event: '{0}' {1}.", e.FullPath, e.ChangeType);
ScheduleWriteFilename(e.FullPath);
}
void watcher_Deleted(object sender, FileSystemEventArgs e)
{
this.OnFileLost(new PluginDirectoryEventArgs(e.FullPath));
}
protected void UpdateStatus(object sender, FileSystemEventArgs e)
{
UpdateStatus(e.FullPath, 0);
}
private void OnWatcher_Deleted(object sender, FileSystemEventArgs e)
{
if (e.FullPath.Equals(pathProject))
{
Nodes[e.FullPath].Remove();
}
else
{
TreeNode[] nodes = Nodes.Find(e.FullPath, true);
nodes[0].Remove();
}
}
// Changed, renamed
//this.m_FileSysWatcher.Changed += new System.IO.FileSystemEventHandler(this.FileSysWatcher_Event);
//this.m_FileSysWatcher.Renamed += new System.IO.RenamedEventHandler(this.FileSysWatcher_Event);
private void FileSysWatcher_Event(object sender, FileSystemEventArgs e)
{
ScanFileAsync(e.FullPath);
}
private void mainFileSystemWatcher_AllActions(object sender, FileSystemEventArgs e)
{
this.MainOptions.Update();
}
private void OnChanged(object sender, FileSystemEventArgs e)
{
_hubContext.Clients.All.SendAsync("Refreshfilewatcher");
}
protected void OnChanged(object sender, FileSystemEventArgs args)
{
if (Changed != null)
Changed(sender, args);
}
private static void Watcher_Event(object sender, FileSystemEventArgs e)
{
KnownFiles.Clear();
}
protected void OnCreated (FileSystemEventArgs e) { throw new NotImplementedException (); }
void handleFileEvent(FileSystemEventArgs e)
{
this.handleFile(e.FullPath);
}
public static void FileSystemWatcher_OnDeleted()
{
using (TestFileSystemWatcher watcher = new TestFileSystemWatcher())
{
bool eventOccured = false;
object obj = null;
FileSystemEventArgs actualArgs = null, expectedArgs = new FileSystemEventArgs(WatcherChangeTypes.Deleted, "directory", "file");
watcher.Deleted += (o, e) =>
{
eventOccured = true;
obj = o;
actualArgs = e;
};
watcher.CallOnDeleted(expectedArgs);
Assert.True(eventOccured, "Event should be invoked");
Assert.Equal(watcher, obj);
Assert.Equal(expectedArgs, actualArgs);
}
}
private static void Watcher_Changed(object sender, FileSystemEventArgs e)
{
MemoryCache.Default.Remove(_cacheKey);
}
void OnSceneFileWatcher_Changed(object sender, FileSystemEventArgs e)
{
wantsFullRebuild = true;
}
private void OnFileChange(object sender, FileSystemEventArgs e)
{
HasFileChangedExternally = true;
}
