private void OnChanged(object sender, FileSystemEventArgs e) { if (!_isClosed) { if (ChkRealTimeAnalysis.IsChecked) { try { Application.Current.Dispatcher?.BeginInvoke(new Action(async() => { if (_idle) { _silently = true; await BtnFindMutantsClick(_selectedMutators); if (!_testsAreFailing) { await BtnApplyMutantsClick(); } } }), DispatcherPriority.ApplicationIdle); } catch (Exception exception) { Trace.TraceError("Closing Real Time Mutation {0}", exception); _watcher?.Dispose(); } } } else { _watcher?.Dispose(); } }
protected override void _Load() { _luaEnv?.Dispose(); _watcher?.Dispose(); _luaEnv = new LuaEnv(); _luaEnv.Global.Set("Game", Game); _luaEnv.Global.Set("Logger", LogSystem); _luaEnv.Global.Set("Plugin", this); _luaEnv.Global.Set("DataPath", Path.Combine(Descriptor.Directory, "Data")); _luaEnv.DoString(_luaSandbox); _sandbox = _luaEnv.Global.Get <LuaTable>("sandbox_env"); var entryScript = File.ReadAllText(EntryFilePath); _luaEnv.DoString(entryScript, "chunk", _sandbox); if (Convert.ToBoolean(Func("load"))) { _watcher = new FileSystemWatcher(); _watcher.Path = Path.GetDirectoryName(EntryFilePath); _watcher.Filter = Path.GetFileName(EntryFilePath); _watcher.EnableRaisingEvents = true; _watcher.Changed += (sender, e) => { _refresh = true; }; } Loaded = true; }
private void MakerExiting(object sender, EventArgs e) { _textureChanged?.Dispose(); _texChangeWatcher?.Dispose(); _bytesToLoad = null; _lastError = null; _loadToggle = null; }
private void MakerExiting(object sender, EventArgs e) { _textureChanged?.Dispose(); _texChangeWatcher?.Dispose(); _bytesToLoad = null; _lastError = null; GetControllerRegistration().MaintainState = false; }
/// <summary> /// Stop the filewatcher. /// </summary> public virtual void Stop() { _fileSystemWatcher?.Dispose(); lock (_filesProcessed) { _filesProcessed.Clear(); } IsStarted = false; }
protected override void PostStop() { ValidateFolderAndSettings?.Cancel(false); _watcher?.Dispose(); var self = Self; Context.ActorSelection("/user/DatabaseWatcher").Tell(new UnSubscribeToObjectChanges(self)); LogToEverything(Context, $"FileSystemWatcher has stopped monitoring {_folderPath.FullName.ToString()}"); _watcher = null; base.PostStop(); }
private void OnFileAccept(string[] strings, string type, bool hideMain) { _hideMainToLoad = hideMain; if (strings == null || strings.Length == 0) { return; } var texPath = strings[0]; if (string.IsNullOrEmpty(texPath)) { return; } _typeToLoad = type; void ReadTex(string texturePath) { try { _bytesToLoad = File.ReadAllBytes(texturePath); } catch (Exception ex) { _bytesToLoad = null; _lastError = ex; } } ReadTex(texPath); _texChangeWatcher?.Dispose(); if (KoiSkinOverlayGui.WatchLoadedTexForChanges?.Value ?? true) { var directory = Path.GetDirectoryName(texPath); if (directory != null) { _texChangeWatcher = new FileSystemWatcher(directory, Path.GetFileName(texPath)); _texChangeWatcher.Changed += (sender, args) => { if (File.Exists(texPath)) { ReadTex(texPath); } }; _texChangeWatcher.Deleted += (sender, args) => _texChangeWatcher?.Dispose(); _texChangeWatcher.Error += (sender, args) => _texChangeWatcher?.Dispose(); _texChangeWatcher.EnableRaisingEvents = true; } } }
protected void Dispose(bool disposing) { if (disposing) { _workspaceService.OnActiveWorkspaceChanged -= OnActiveWorkspaceChanged; if (_workspaceSettingsMgr != null) { _workspaceSettingsMgr.OnWorkspaceSettingsChanged -= OnSettingsChanged; } _folderWatcher?.Dispose(); _folderWatcherTimer?.Dispose(); } }
private async Task ChangeAssetFolderAsync(string path) { if (_assetFolder != path) { _assetFolderWatcher?.Dispose(); _assetFolderWatcher = null; Sprites = null; _assetFolder = path; UpdateSetFolderButtonTooltip(); await StartShowAssetFolderContent(); } }
protected void Dispose(bool disposing) { if (disposing) { _workspaceContextProvider.WorkspaceOpening -= OnWorkspaceOpening; _workspaceContextProvider.WorkspaceClosed -= OnWorkspaceClosed; if (_workspace != null) { _workspace.InterpreterSettingChanged -= OnInterpreterSettingChanged; } _folderWatcher?.Dispose(); _folderWatcherTimer?.Dispose(); } }
/// <inheritdoc /> public void Stop() { // FileSystemWatcher sometimes raises multiple events when a file changes - https://github.com/dotnet/runtime/issues/24079. // This can cause multiple uncesssary NodeJS process restarts (see OutOfProcessNodeJSService). // // To avoid such restarts, we need to stop/ignore events once one is raised. // Setting FileSystemWatcher.EnableRaisingEvents to false is insufficient - once set to true, previously buffered events may be raised (observed on macos). // // Disposing works since it removes all handlers from the instance - https://github.com/dotnet/runtime/blob/a27884006dc5515e072adb4fa7c6f97cca08abd8/src/libraries/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.cs#L343-L370. // Microsoft.AspNetCore.NodeServices took this approach as well. // // If stop is called before start, _fileSystemWatcher may be null. _fileSystemWatcher?.Dispose(); }
public void TryCreateTeleporterWatcher(DalamudPluginInterface pi, bool useTeleport) { const string teleporterPluginConfigFile = "TeleporterPlugin.json"; _teleporterLanguage = _language; if (!useTeleport || _teleporterWatcher != null) { _teleporterWatcher?.Dispose(); _teleporterWatcher = null; return; } var dir = new DirectoryInfo(pi.GetPluginConfigDirectory()); if (!dir.Exists || (dir.Parent?.Exists ?? false)) { return; } dir = dir.Parent; var file = new FileInfo(Path.Combine(dir !.FullName, teleporterPluginConfigFile)); if (file.Exists) { ParseTeleporterFile(file.FullName); } void OnTeleporterConfigChange(object source, FileSystemEventArgs args) { PluginLog.Verbose("Reloading Teleporter Config."); if (args.ChangeType != WatcherChangeTypes.Changed && args.ChangeType != WatcherChangeTypes.Created) { return; } ParseTeleporterFile(args.FullPath); } _teleporterWatcher = new FileSystemWatcher { Path = dir.FullName, NotifyFilter = NotifyFilters.LastWrite, Filter = teleporterPluginConfigFile, }; _teleporterWatcher.Changed += OnTeleporterConfigChange; _teleporterWatcher !.EnableRaisingEvents = true; }
private void UpdateAutosplitter() { var previousLatestSavePath = latestSavePath; latestSavePath = FindLatestSavePath(); if (latestSavePath != previousLatestSavePath) { if (timer.CurrentState.CurrentPhase == TimerPhase.Running) { ResetWools(); timer.Reset(true); } watcher?.Dispose(); watcher = new FileSystemWatcher { Path = latestSavePath, NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.Size | NotifyFilters.Attributes, Filter = "*.*" }; watcher.Renamed += NewLevelDat; watcher.Created += SessionLock; watcher.Changed += SessionLock; watcher.EnableRaisingEvents = true; CheckExistingSessionLock(); } if (timer.CurrentState.CurrentPhase == TimerPhase.NotRunning) { ResetWools(); } }
protected override void UnloadContent() { Batch?.Dispose(); Watcher?.Dispose(); base.Dispose(); }
public void Disconnect() { _fileWatcher.Created -= OnCreated; _fileWatcher.EnableRaisingEvents = false; _fileWatcher?.Dispose(); _rabbitMqHelper?.Dispose(); }
public void Dispose() { UnloadPlugin(); _watcher?.Dispose(); _watcher = null; }
public void Dispose() { m_watcher?.Dispose(); m_watcher = null; m_client?.Dispose(); m_client = null; }
private void InitializeWorkspace(IPythonWorkspaceContext workspace) { lock (_factories) { // Cleanup state associated with the previous workspace, if any if (_workspace != null) { _workspace.InterpreterSettingChanged -= OnInterpreterSettingChanged; _workspace = null; } _folderWatcher?.Dispose(); _folderWatcher = null; _folderWatcherTimer?.Dispose(); _folderWatcherTimer = null; // Setup new workspace _workspace = workspace; if (_workspace != null) { _workspace.InterpreterSettingChanged += OnInterpreterSettingChanged; try { _folderWatcher = new FileSystemWatcher(_workspace.Location, "*.*"); _folderWatcher.Created += OnFileCreatedDeletedRenamed; _folderWatcher.Deleted += OnFileCreatedDeletedRenamed; _folderWatcher.Renamed += OnFileCreatedDeletedRenamed; _folderWatcher.EnableRaisingEvents = true; _folderWatcher.IncludeSubdirectories = true; } catch (ArgumentException) { } catch (IOException) { } _folderWatcherTimer = new Timer(OnFileChangesTimerElapsed); } } }
public static void WaitForZipCreation(string path, string fileName) { if (string.IsNullOrWhiteSpace(path)) { throw new ArgumentNullException(nameof(path)); } if (string.IsNullOrWhiteSpace(fileName)) { throw new ArgumentNullException(nameof(fileName)); } FileSystemWatcher fsw = null; try { fsw = new FileSystemWatcher(); string[] data = new string[] { path, fileName }; fsw.Path = path; fsw.Filter = fileName; fsw.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; Task work = Task.Run(() => { try { Thread.Sleep(1000); if (data.Length == 2) { string dataPath = data[0]; string dataFile = path + data[1]; Console.WriteLine($"Creating {dataFile} in task..."); FileStream fileStream = File.Create(dataFile); fileStream.Close(); } } catch (Exception e) { Console.WriteLine(e); } }); WaitForChangedResult result = fsw.WaitForChanged(WatcherChangeTypes.Created, 3000); Console.WriteLine($"{result.Name} created at {path}."); } catch (Exception e) { Console.WriteLine(e); } finally { File.Delete(fileName); fsw?.Dispose(); } }
public void Dispose() { _fileSystemWatcher?.Dispose(); _timer?.Dispose(); Console.WriteLine($"Stopped watching {_watchFolder} for {_watchFilter} files"); }
public void Dispose() { View = null; m_DataWatcher?.Dispose(); m_DataWatcher = null; }
protected virtual void Dispose(bool disposing) { if (disposing) { _fw?.Dispose(); } }
protected override void Dispose(bool disposing) { if (disposing) { librariesWatcher?.Dispose(); } }
/// <summary> /// Protected implementation of Dispose pattern. /// </summary> /// <param name="isDisposing">Called from Dispose().</param> void Dispose(bool isDisposing) { if (isDisposing) { _watcher?.Dispose(); } }
/// <summary> /// Ends the watch on the log directory /// </summary> public void EndWatch() { //stop the file monitors if (_timerFileChecker != null && _timerFileChecker.Enabled) { _timerFileChecker?.Stop(); } if (_fsw != null) { _fsw.EnableRaisingEvents = false; _fsw?.Dispose(); _fsw = null; } //end all monitors var lstRemove = new List <string>(); foreach (var mon in _dicMonitors) { lstRemove.Add(mon.Key); } foreach (var monKey in lstRemove) { AuctionMonitor monOut; if (_dicMonitors.TryRemove(monKey, out monOut)) { this.OnAuctionMonitorEnded(monOut); } } _watching = false; }
public virtual Task UnloadAsync() { fileSystemWatcher?.Dispose(); folderSystemWatcher?.Dispose(); return(Task.CompletedTask); }
public void Stop() { // We're relying on callers to synchronize start/stops so we don't need to ensure one happens before the other. _watcher?.Dispose(); _watcher = null; }
private void DisposeResources() { _repo?.Dispose(); _repo = null; _fsw?.Dispose(); _fsw = null; }
public void Watch(string templateFolder) { if (currentFolder == templateFolder) { return; } lock (this) { if (currentFolder == templateFolder) { return; } currentFolder = templateFolder; currentWatcher?.Dispose(); currentWatcher = new FileSystemWatcher(templateFolder) { EnableRaisingEvents = true, IncludeSubdirectories = true }; currentWatcher.Changed += Handler; currentWatcher.Renamed += Handler; } }
protected virtual void Dispose(bool disposing) { if (disposing) { _fileWatcher?.Dispose(); } }
public void WatcherShouldBeDisposedOnDispose() { FileSystemWatcher tested = new FileSystemWatcher(); bool wasDisposed = false; tested.watcher.Disposed += (s,e) => wasDisposed = true; tested.Dispose(); Assert.IsTrue(wasDisposed); }
public static void FileSystemWatcher_Disposed() { FileSystemWatcher watcher = new FileSystemWatcher(); watcher.Dispose(); watcher.Dispose(); // shouldn't throw Assert.Throws<ObjectDisposedException>(() => watcher.EnableRaisingEvents = true); }
public static void FileSystemWatcher_StopCalledOnBackgroundThreadDoesNotDeadlock() { // Check the case where Stop or Dispose (they do the same thing) is called from // a FSW event callback and make sure we don't Thread.Join to deadlock using (var dir = Utility.CreateTestDirectory()) { FileSystemWatcher watcher = new FileSystemWatcher(); AutoResetEvent are = new AutoResetEvent(false); FileSystemEventHandler callback = (sender, arg) => { watcher.Dispose(); are.Set(); }; // Attach the FSW to the existing structure watcher.Path = Path.GetFullPath(dir.Path); watcher.Filter = "*"; watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size; watcher.Changed += callback; using (var file = File.Create(Path.Combine(dir.Path, "testfile.txt"))) { watcher.EnableRaisingEvents = true; // Change the nested file and verify we get the changed event byte[] bt = new byte[4096]; file.Write(bt, 0, bt.Length); file.Flush(); } are.WaitOne(Utility.WaitForExpectedEventTimeout); } }