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