private static System.IO.FileSystemWatcher CreateWatcher(string dir, BlockingCollection <string> files) { var watcher = new System.IO.FileSystemWatcher(dir, "*.cs") { IncludeSubdirectories = true, InternalBufferSize = 1000000 }; System.IO.FileSystemEventHandler handler = (_s, _e) => { Console.WriteLine(_e.FullPath); Console.WriteLine(" {0}, {1}", _e.ChangeType, _e.Name); if (!_e.Name.EndsWith(".cs", StringComparison.InvariantCultureIgnoreCase)) { return; } files.TryAdd(_e.FullPath); }; watcher.Changed += handler; watcher.Created += handler; watcher.Deleted += handler; watcher.Renamed += (_s, _e) => handler(_s, _e); watcher.NotifyFilter = System.IO.NotifyFilters.FileName; watcher.EnableRaisingEvents = true; return(watcher); }
public void Add(string dir, string filter) { var fsw = new FileSystemWatcher(dir, filter); fsw.NotifyFilter = NotifyFilters.LastWrite; fsw.Changed += OnFileChanged; fsw.EnableRaisingEvents = true; }
public InputTranParser(LuaFixTransactionMessageAdapter transAdapter, FixMessageAdapter messAdapter, List<Security> securities) { _transAdapter = transAdapter; _messAdapter = messAdapter; _securities = securities; _watcher = new FileSystemWatcher(_tranFilePath, "*.tri"); _tranKeys = new List<TransactionKey> { new TransIdKey(), new AccountKey(), new ClientCodeKey(), new ClassCodeKey(), new SecCodeKey(), new ActionKey(), new OperationKey(), new PriceKey(), new StopPriceKey(), new QuantityKey(), new TypeKey(), new OrderKeyKey(), new OriginalTransIdKey(), new CommentKey() }; }
public async Task WillReindexAfterCrashing(string storage) { int port = 9999; var filesystem = Path.GetRandomFileName(); var nameof = "WillReindexAfterCrashing-" + DateTime.Now.Ticks; string dataDirectoryPath; using (var server = CreateServer(port, dataDirectory: nameof, runInMemory: false, requestedStorage: storage)) { dataDirectoryPath = server.Configuration.DataDirectory; var store = server.FilesStore; await store.AsyncFilesCommands.Admin.EnsureFileSystemExistsAsync(filesystem); using (var session = store.OpenAsyncSession(filesystem)) { session.RegisterUpload("test1.file", CreateUniformFileStream(128)); session.RegisterUpload("test2.file", CreateUniformFileStream(128)); session.RegisterUpload("test3.file.deleting", CreateUniformFileStream(128)); await session.SaveChangesAsync(); } } // Simulate a rude shutdown. var filesystemDirectoryPath = Path.Combine(dataDirectoryPath, "FileSystems"); var crashMarkerPath = Path.Combine(filesystemDirectoryPath, filesystem, "indexing.crash-marker"); using (var file = File.Create(crashMarkerPath)) { }; var writingMarkerPath = Path.Combine(filesystemDirectoryPath, filesystem, "Indexes", "writing-to-index.lock"); using (var file = File.Create(writingMarkerPath)) { }; bool changed = false; // Ensure the index has been reseted. var watcher = new FileSystemWatcher(Path.Combine(filesystemDirectoryPath, filesystem)); watcher.IncludeSubdirectories = true; watcher.Deleted += (sender, args) => changed = true; watcher.EnableRaisingEvents = true; using (var server = CreateServer(port, dataDirectory: nameof, runInMemory: false, requestedStorage: storage)) { var store = server.FilesStore; using (var session = store.OpenAsyncSession(filesystem)) { // Ensure the files are there. var file1 = await session.LoadFileAsync("test1.file"); Assert.NotNull(file1); // Ensure the files are indexed. var query = await session.Query() .WhereStartsWith(x => x.Name, "test") .ToListAsync(); Assert.True(query.Any()); Assert.Equal(2, query.Count()); } } Assert.True(changed); }
public void Setup(int delay, System.Collections.IList assemblies) #endif { log.Info("Setting up watcher"); files = new FileInfo[assemblies.Count]; fileWatchers = new FileSystemWatcher[assemblies.Count]; for (int i = 0; i < assemblies.Count; i++) { log.Debug("Setting up FileSystemWatcher for {0}", assemblies[i]); files[i] = new FileInfo((string)assemblies[i]); fileWatchers[i] = new FileSystemWatcher(); fileWatchers[i].Path = files[i].DirectoryName; fileWatchers[i].Filter = files[i].Name; fileWatchers[i].NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite; fileWatchers[i].Changed += new FileSystemEventHandler(OnChanged); fileWatchers[i].EnableRaisingEvents = false; } timer = new System.Timers.Timer(delay); timer.AutoReset = false; timer.Enabled = false; timer.Elapsed += new ElapsedEventHandler(OnTimer); }
public ScriptManager() { LoadScripts(); watcher = new FileSystemWatcher(Config.GetValue(ConfigSections.DEV, ConfigValues.SCRIPT_LOCATION)) { NotifyFilter = NotifyFilters .LastAccess | NotifyFilters .LastWrite | NotifyFilters .FileName | NotifyFilters .DirectoryName, Filter = "*.cs" }; watcher.Changed += ReloadScript; watcher.Created += LoadScript; watcher.Renamed += LoadScript; watcher.Deleted += UnloadScript; watcher.EnableRaisingEvents = true; }
protected override void OnStart(string[] args) { if (!EventLog.SourceExists("SSISIncomingDirectoryWatcher", ".")) { EventLog.CreateEventSource("SSISIncomingDirectoryWatcher", "Application"); } Lg = new EventLog("Application", ".", "SSISIncomingDirectoryWatcher"); Lg.WriteEntry("Service started at " + DateTime.Now, EventLogEntryType.Information); try { tw = File.CreateText(logFilePath); tw.WriteLine("Service started at {0}", DateTime.Now); readInConfigValues(); Watcher = new FileSystemWatcher(); Watcher.Path = dirToWatch; Watcher.IncludeSubdirectories = false; Watcher.Created += new FileSystemEventHandler(watcherChange); Watcher.EnableRaisingEvents = true; } catch (Exception ex) { Lg.WriteEntry(ex.Message, EventLogEntryType.Error); } finally { tw.Close(); } }
int TimerDue = 1000 * 60 * 60 * 24; // 24 hours public DiskManager() { userWatcher = new System.IO.FileSystemWatcher(userTemp); userWatcher.NotifyFilter = System.IO.NotifyFilters.Size; userWatcher.Deleted += ModifyTemp; userWatcher.Created += ModifyTemp; if (systemTemp != userTemp) { sysWatcher = new System.IO.FileSystemWatcher(systemTemp); sysWatcher.NotifyFilter = System.IO.NotifyFilters.Size; sysWatcher.Deleted += ModifyTemp; sysWatcher.Created += ModifyTemp; } TempScanTimer = new System.Timers.Timer(TimerDue); ScanTemp(); TempScanTimer.Elapsed += async(s, e) => { await ScanTemp().ConfigureAwait(false); }; TempScanTimer.Start(); Log.Information("<Maintenance> Temp folder scanner will be performed once per day."); onBurden += ReScanTemp; Log.Information("<Maintenance> Component loaded."); }
public async Task Start() { _isWatching = true; using (System.IO.FileSystemWatcher fileSystemWatcher = new System.IO.FileSystemWatcher(FolderPath)) { fileSystemWatcher.IncludeSubdirectories = true; fileSystemWatcher.NotifyFilter = NotifyFilters.Attributes | NotifyFilters.DirectoryName; fileSystemWatcher.Changed += FileSystemWatcher_Changed; fileSystemWatcher.Created += FileSystemWatcher_Created; fileSystemWatcher.Deleted += FileSystemWatcher_Deleted; fileSystemWatcher.Error += FileSystemWatcher_Error; fileSystemWatcher.Renamed += FileSystemWatcher_Renamed; fileSystemWatcher.EnableRaisingEvents = true; await Task.Run(() => { while (_isWatching) { ; } }); } }
private void StartWatcher() { watcher = new System.IO.FileSystemWatcher(); watcher.Path = TbDirectory.Text; watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; // Watch Specific File Types if (!CbDirectory.Text.Equals("")) { watcher.Filter = CbDirectory.Text; }//end if // Add event handlers. watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Created += new FileSystemEventHandler(OnChanged); watcher.Deleted += new FileSystemEventHandler(OnChanged); watcher.Renamed += new RenamedEventHandler(OnRenamed); // Begin watching. watcher.EnableRaisingEvents = true; watcher.IncludeSubdirectories = true; }//end Watcher
private static System.IO.FileSystemWatcher CreateFileSystemWatcher(string path, NotifyFilters notifyFilters, string fileFilter, bool includeSubDirectories, int internalBufferSize) { System.IO.FileSystemWatcher watcher = new System.IO.FileSystemWatcher { Path = path, EnableRaisingEvents = true, IncludeSubdirectories = includeSubDirectories, NotifyFilter = notifyFilters, }; if (!string.IsNullOrWhiteSpace(fileFilter)) { watcher.Filter = fileFilter; } else { watcher.Filter = _defaultFileFilter; } if (internalBufferSize > 0) { watcher.InternalBufferSize = internalBufferSize; } return(watcher); }
public BackUpSystem(string tracking_directory, string backup_directory, string filter, bool IsTracking) { this.tracking_directory = tracking_directory; this.backup_directory = backup_directory; this.filter = filter; logger_fullpath = Path.Combine(backup_directory, "logger.txt"); if (!Directory.Exists(backup_directory) || !File.Exists(logger_fullpath)) { Directory.CreateDirectory(backup_directory); string[] files_in_backup = Directory.GetFiles(backup_directory); foreach (var file in files_in_backup) { File.Delete(file); } (File.Create(logger_fullpath)).Close(); string[] all_tracking_files = Directory.GetFiles(tracking_directory, "*" + filter, SearchOption.AllDirectories); Save("Created", all_tracking_files); } else { var c = Directory.GetFiles(this.backup_directory, "BackUp*" + filter, SearchOption.AllDirectories); files_count = c.Length; } filewatcher = new FileSystemWatcher(tracking_directory); filewatcher.IncludeSubdirectories = true; filewatcher.Changed += FileSystemWatcher_OnChanged; filewatcher.Created += FileSystemWatcher_OnCreated; filewatcher.Deleted += FileSystemWatcher_OnCreated; filewatcher.Renamed += FileSystemWatcher_OnRenamed; filewatcher.Error += FileSystemWatcher_OnError; filewatcher.EnableRaisingEvents = IsTracking; }
void StartWatch(string PathToWatch, string Filter, bool IncludeSubdirectories) { m_bIsWatching = true; m_Watcher = new System.IO.FileSystemWatcher(); m_Watcher.Filter = Filter; // "*.*"; if (PathToWatch[PathToWatch.Length - 1] != '\\') { m_Watcher.Path = PathToWatch + "\\"; // txtFile.Text + "\\"; } else { m_Watcher.Path = PathToWatch; } m_Watcher.IncludeSubdirectories = IncludeSubdirectories; m_Watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; m_Watcher.Changed += new FileSystemEventHandler(OnChanged); m_Watcher.Created += new FileSystemEventHandler(OnCreated); m_Watcher.Deleted += new FileSystemEventHandler(OnDelete); m_Watcher.Renamed += new RenamedEventHandler(OnRenamed); m_Watcher.EnableRaisingEvents = true; }
private void InitFileSystemWatcher() { Info("Initializing FileSystemWatcher..."); Watcher = new IO.FileSystemWatcher { Path = FolderToWatch, Filter = Filter, IncludeSubdirectories = IncludeSubFolders }; // Add event handlers. Watcher.Created += OnCreated; Watcher.Changed += OnChanged; Watcher.Deleted += OnDeleted; // Begin watching. Watcher.EnableRaisingEvents = true; InfoFormat("FileSystemWatcher.Path={0}", Watcher.Path); InfoFormat("FileSystemWatcher.Filter={0}", Watcher.Filter); InfoFormat("FileSystemWatcher.EnableRaisingEvents={0}", Watcher.EnableRaisingEvents); Info("FileSystemWatcher Initialized."); Info("Begin watching ..."); CurrentLogs.AddRange(Logs); while (true) { Thread.Sleep(1); } }
public ViewLabels() { _labelTemplateManager = FirstFloor.ModernUI.App.App.Container.GetInstance<ILabelTemplateManager>(); _labelManager = FirstFloor.ModernUI.App.App.Container.GetInstance<ILabelManager>(); _bitmapGenerator = FirstFloor.ModernUI.App.App.Container.GetInstance<IBitmapGenerator>(); _fileManager = FirstFloor.ModernUI.App.App.Container.GetInstance<IFileManager>(); _labelLocation = new CommandLineArgs()["location"]; LabelImages = new ObservableCollection<DisplayLabel>(); InitializeComponent(); DataContext = this; var configDirectory = $@"{AppDomain.CurrentDomain.BaseDirectory}\Config\"; if (_fileManager.CheckDirectoryExists(configDirectory)) { _fsWatcher = new FileSystemWatcher { NotifyFilter = NotifyFilters.LastWrite, Path = configDirectory, Filter = "labels.json", EnableRaisingEvents = true }; _fsWatcher.Changed += FsWatcherOnChanged; GetImages(); } else { ModernDialog.ShowMessage($"An error occurred. The '{configDirectory}' directory could not be found.", "Error", MessageBoxButton.OK, Window.GetWindow(this)); } }
public void Add(string dir, string filter) { System.IO.FileSystemWatcher fsw = new System.IO.FileSystemWatcher(dir, filter); fsw.NotifyFilter = System.IO.NotifyFilters.LastWrite; fsw.Changed += new FileSystemEventHandler(OnFileChanged); fsw.EnableRaisingEvents = true; }
public string StartWatchWrongFiles(string PathToWatch, bool IncludeSubdirectories) { try { if (m_WatcherWrong != null) { StopWatchWrongFiles(); } m_WatcherWrong = new System.IO.FileSystemWatcher(); m_WatcherWrong.Filter = "*.wrong"; if (PathToWatch[PathToWatch.Length - 1] != '\\') { m_WatcherWrong.Path = PathToWatch + "\\"; // txtFile.Text + "\\"; } else { m_WatcherWrong.Path = PathToWatch; } m_WatcherWrong.IncludeSubdirectories = IncludeSubdirectories; m_WatcherWrong.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; m_WatcherWrong.Changed += new FileSystemEventHandler(OnChanged); m_WatcherWrong.Created += new FileSystemEventHandler(OnCreated); m_WatcherWrong.Deleted += new FileSystemEventHandler(OnDelete); m_WatcherWrong.Renamed += new RenamedEventHandler(OnRenamed); m_WatcherWrong.EnableRaisingEvents = true; m_bIsWatchingWrong = true; return("start watch ok on path, " + PathToWatch + " ,filter: " + "*.wrong"); } catch (Exception err) { throw (new SystemException(err.Message)); } }
public bool StopFTPWatcher() { try { Thread.Sleep(200); //threadReads.Abort(); if (watcher != null) { watcher.EnableRaisingEvents = false; watcher.Created -= new FileSystemEventHandler(OnCreated); watcher.Dispose(); watcher = null; // Form1.log.Info("Watcher Stopped"); } TimerMonitor.Stop(); TimerPending.Stop(); TimerMatch.Stop(); IsRunning = false; return(true); } catch (Exception ex) { //Form1.log.Error("StopFTPWatcher Error", ex); return(false); } }
/// <summary> /// 启用重载器 /// </summary> public static void Start() { // 指定文件改变时卸载程序域 Action<string> onFileChanged = (path) => { var ext = Path.GetExtension(path).ToLower(); if (ext == ".cs" || ext == ".json") { HttpRuntime.UnloadAppDomain(); } }; // 绑定文件监视器的事件处理函数并启用监视器 Action<FileSystemWatcher> startWatcher = (watcher) => { watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName; watcher.Changed += (sender, e) => onFileChanged(e.FullPath); watcher.Created += (sender, e) => onFileChanged(e.FullPath); watcher.Deleted += (sender, e) => onFileChanged(e.FullPath); watcher.Renamed += (sender, e) => { onFileChanged(e.FullPath); onFileChanged(e.OldFullPath); }; watcher.EnableRaisingEvents = true; }; // 监视插件目录 var pathManager = Application.Ioc.Resolve<PathManager>(); pathManager.GetPluginDirectories().Where(p => Directory.Exists(p)).ForEach(p => { var pluginFilesWatcher = new FileSystemWatcher(); pluginFilesWatcher.Path = p; pluginFilesWatcher.IncludeSubdirectories = true; startWatcher(pluginFilesWatcher); }); // 监视网站配置文件 var websiteConfigWatcher = new FileSystemWatcher(); websiteConfigWatcher.Path = PathConfig.AppDataDirectory; websiteConfigWatcher.Filter = "*.json"; startWatcher(websiteConfigWatcher); }
private void StartFileSystemWatcher() { if (string.IsNullOrWhiteSpace(SourceFolderPath)) { return; } var fileSystemWatcher = new System.IO.FileSystemWatcher { Path = SourceFolderPath, NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite | NotifyFilters.Size | NotifyFilters.DirectoryName, IncludeSubdirectories = true, EnableRaisingEvents = true, }; fileSystemWatcher.Created += fileSystemWatcher_CreatedChangedDeleted; fileSystemWatcher.Changed += fileSystemWatcher_CreatedChangedDeleted; fileSystemWatcher.Deleted += fileSystemWatcher_CreatedChangedDeleted; fileSystemWatcher.Renamed += fileSystemWatcher_Renamed; WriteLog(string.Format(Properties.Resources.MainWindowsVM_StartFileSystemWatcher_StartFileSystemWatcher, SourceFolderPath)); }
public LogViewer(string spacefilter, List <string> programs, List <string> excludes, AssemblaTicketWindow.LoginSucceedDel loginsuccess, string User, string Pw) { namefilter = spacefilter; loginsucceed = loginsuccess; programlist = programs; exclude = excludes; user = User; pw = Pw; if (loginsucceed == null) { loginsucceed = new AssemblaTicketWindow.LoginSucceedDel(succeed); } InitializeComponent(); if (namefilter != string.Empty) { Text = PROGRAM + " " + namefilter; Invalidate(); } ContextMenu = new ContextMenu(); ContextMenu.MenuItems.Add("View", new EventHandler(view)); ContextMenu.MenuItems.Add("Ticket", new EventHandler(aticket)); ContextMenu.MenuItems.Add("Delete", new EventHandler(del)); DoubleClick += new EventHandler(LogViewerMain_DoubleClick); _logs.DoubleClick += new EventHandler(_logs_DoubleClick); _logs.SelectionMode = SelectionMode.MultiExtended; _logs.Sorted = true; init(); fsw = new System.IO.FileSystemWatcher(PATH, WILDEXT); fsw.IncludeSubdirectories = true; fsw.Changed += new System.IO.FileSystemEventHandler(fsw_Changed); fsw.Created += new System.IO.FileSystemEventHandler(fsw_Created); }
//This method starts to listen to microphone stream public void startButton2(object sender, EventArgs e) { var watch = new System.IO.FileSystemWatcher(); watch.Path = ibtPath; watch.Filter = "mic.txt"; watch.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite; //more options watch.Changed += new FileSystemEventHandler(OnChanged); watch.EnableRaisingEvents = true; //determine the singer gender if (gender.Text == "Male") { setGender("Gender=Male;"); } else { setGender("Gender=Female;"); } minRate = Convert.ToDouble(minRateText.Text); maxRate = Convert.ToDouble(maxRateText.Text); //min BPM is 81 //max BPM is 160 interval = Convert.ToInt32((160 - 81) / (maxRate - minRate)); //start the IBT process using (process = new Process()) { process.StartInfo.UseShellExecute = false; process.StartInfo.RedirectStandardOutput = true; process.StartInfo.RedirectStandardError = true; process.StartInfo.WindowStyle = ProcessWindowStyle.Minimized; process.StartInfo.WorkingDirectory = @"C:\"; process.StartInfo.FileName = Path.Combine(Environment.SystemDirectory, "cmd.exe"); // Redirects the standard input so that commands can be sent to the shell. process.StartInfo.RedirectStandardInput = true; // Runs the specified command and exits the shell immediately. //process.StartInfo.Arguments = @"/c ""dir"""; process.OutputDataReceived += ProcessOutputDataHandler; process.ErrorDataReceived += ProcessErrorDataHandler; process.Start(); process.BeginOutputReadLine(); process.BeginErrorReadLine(); // Send a directory command and an exit command to the shell process.StandardInput.WriteLine("cd " + ibtPath); process.StandardInput.WriteLine("ibt -mic"); } //change the window title Console.WriteLine("Band Without Soloist - Running..."); BWS.setText("Band Without Soloist - Running..."); startButton.Enabled = false; }
public override void Run(IBuildContext context) { Context = context; Context.IsAborted = true; var include = context.Configuration.GetString(Constants.Configuration.WatchProjectInclude, "**"); var exclude = context.Configuration.GetString(Constants.Configuration.WatchProjectExclude, "**"); _pathMatcher = new PathMatcher(include, exclude); _publishDatabase = context.Configuration.GetBool(Constants.Configuration.WatchProjectPublishDatabase, true); _fileWatcher = new FileSystemWatcher(context.ProjectDirectory) { IncludeSubdirectories = true, NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName }; _fileWatcher.Changed += FileChanged; _fileWatcher.Deleted += FileChanged; _fileWatcher.Renamed += FileChanged; _fileWatcher.Created += FileChanged; _fileWatcher.Created += FileChanged; _fileWatcher.EnableRaisingEvents = true; Console.WriteLine(Texts.Type__q__to_quit___); string input; do { input = Console.ReadLine(); } while (!string.Equals(input, "q", StringComparison.OrdinalIgnoreCase)); }
private void StartFileSystemWatcher() { string folderPath = this.TextBoxFolderPath.Text; // If there is no folder selected, to nothing if (string.IsNullOrWhiteSpace(folderPath) || !System.IO.Directory.Exists(folderPath)) { return; } System.IO.FileSystemWatcher fileSystemWatcher = new System.IO.FileSystemWatcher(); // Set folder path to watch fileSystemWatcher.Path = folderPath; // Gets or sets the type of changes to watch for. // In this case we will watch change of filename, last modified time, size and directory name fileSystemWatcher.NotifyFilter = System.IO.NotifyFilters.FileName | System.IO.NotifyFilters.LastWrite | System.IO.NotifyFilters.Size | System.IO.NotifyFilters.DirectoryName; // Event handlers that are watching for specific event fileSystemWatcher.Created += new System.IO.FileSystemEventHandler(fileSystemWatcher_Created); //fileSystemWatcher.Changed += new System.IO.FileSystemEventHandler(fileSystemWatcher_Changed); fileSystemWatcher.Deleted += new System.IO.FileSystemEventHandler(fileSystemWatcher_Deleted); //fileSystemWatcher.Renamed += new System.IO.RenamedEventHandler(fileSystemWatcher_Renamed); // NOTE: If you want to monitor specified files in folder, you can use this filter // fileSystemWatcher.Filter // START watching fileSystemWatcher.EnableRaisingEvents = true; }
private void StartWatch_Click(object sender, EventArgs e) { var sourceButton = ((Button)sender).Name; DialogResult selectedFolder = fbdWatch.ShowDialog(); if (selectedFolder != DialogResult.OK) return; this.Watcher = new FileSystemWatcher(); this.Watcher.Path = fbdWatch.SelectedPath; if (sourceButton == "bPluginStartWatch") { this.Watcher.Filter = "*.dll"; lblPluginWatch.Text = $"Watching {fbdWatch.SelectedPath}"; bPluginStopWatch.Enabled = true; tbLogPlugin.Text = ""; } else if (sourceButton == "bJavascriptStartWatch") { this.Watcher.Filter = "*.js"; lblJavascriptWatch.Text = $"Watching {fbdWatch.SelectedPath}"; bJavascriptStopWatch.Enabled = true; tbLogJavascript.Text = ""; } this.Watcher.IncludeSubdirectories = true; this.Watcher.NotifyFilter = NotifyFilters.LastWrite; this.Watcher.EnableRaisingEvents = true; this.Watcher.Changed -= Watcher_OnChanged; this.Watcher.Changed += Watcher_OnChanged; }
private void InitWatchers() { System.IO.FileSystemWatcher watcher = null; System.String[] paths = System.Configuration.ConfigurationManager.AppSettings["folderPath"].Split(';'); System.String[] filters = System.Configuration.ConfigurationManager.AppSettings["fileFilter"].Split(';'); //System.Console.WriteLine(paths); //System.Console.WriteLine(filters); this.watchers = new System.Collections.Generic.List <System.IO.FileSystemWatcher>(); foreach (System.String path in paths) { if (path == "") { continue; } foreach (System.String filter in filters) { watcher = new System.IO.FileSystemWatcher(); ((System.ComponentModel.ISupportInitialize)(watcher)).BeginInit(); watcher.Path = path; watcher.Filter = filter; watcher.NotifyFilter = ((System.IO.NotifyFilters)((System.IO.NotifyFilters.FileName | System.IO.NotifyFilters.Size | System.IO.NotifyFilters.DirectoryName))); watcher.Changed += new System.IO.FileSystemEventHandler(this.watcherChanged); watcher.Created += new System.IO.FileSystemEventHandler(this.watcherCreated); watcher.Deleted += new System.IO.FileSystemEventHandler(this.watcherDeleted); watcher.Renamed += new System.IO.RenamedEventHandler(this.watcherRenamed); watcher.EnableRaisingEvents = true; watcher.IncludeSubdirectories = (System.Configuration.ConfigurationManager.AppSettings["includeSubDirs"] == "true") ? true : false; ((System.ComponentModel.ISupportInitialize)(watcher)).EndInit(); this.watchers.Add(watcher); } } }
internal void StartWatch() { m_FileWatcher = new FileSystemWatcher(); m_FileWatcher.Path =this.sourceFolder; m_FileWatcher.Created += new FileSystemEventHandler(FileWatcher_Created); m_FileWatcher.EnableRaisingEvents = true; }
private static void MonitorFolder(string folderFullPath) { System.IO.FileSystemWatcher watcher = new System.IO.FileSystemWatcher(folderFullPath, "*.csv"); watcher.EnableRaisingEvents = true; watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName | NotifyFilters.LastWrite; watcher.Created += new FileSystemEventHandler(OnChanged); }
public FileWatcher(bool initDirvers, bool subDirector, bool throwException) { try { if (initDirvers) { foreach (DriveInfo di in DriveInfo.GetDrives()) { try { FileSystemWatcher fsw = new FileSystemWatcher(); fsw.Path = di.Name; fsw.IncludeSubdirectories = subDirector; fsw.Changed += new FileSystemEventHandler(fsw_Changed); fsw.Created += new FileSystemEventHandler(fsw_Created); fsw.Deleted += new FileSystemEventHandler(fsw_Deleted); fsw.Renamed += new RenamedEventHandler(fsw_Renamed); _watcherArr.Add(fsw); } catch { if (throwException) throw new Exception(di.Name + "�̷���ʧ�ܣ�"); } } } } catch (Exception e) { MessageBox.Show(e.Message); MessageBox.Show(e.ToString()); } }
/// <summary>Fileモード用のファイルの監視の属性。 /// 秀丸がファイル名を変更したり、ディレクトリを変更したりしても追跡できるようにするため。 /// 又、ファイルの保存時は、webBrowserの内容を更新する。 /// </summary> protected void SetWatcherAttribute() { try { if (strCurFileFullPath.Length > 0) { if (watcher == null) { watcher = new System.IO.FileSystemWatcher(); watcher.NotifyFilter = (System.IO.NotifyFilters.LastAccess | System.IO.NotifyFilters.LastWrite | System.IO.NotifyFilters.FileName | System.IO.NotifyFilters.DirectoryName); } watcher.Path = System.IO.Path.GetDirectoryName(strCurFileFullPath); // wbとは内容更新が非同期衝突するので、そこは同期せよ watcher.SynchronizingObject = wb; watcher.Filter = "*.*"; watcher.Changed += new FileSystemEventHandler(watcher_Changed); watcher.IncludeSubdirectories = false; //監視を開始する watcher.EnableRaisingEvents = true; } } catch (Exception) { } }
/// <summary> /// Creates the fit function service. Starts a thread that will walk through all items in the fit function directory. /// </summary> /// <param name="fitFunctionDirectory">Directory where the fit functions reside.</param> /// <param name="isReadOnly">If true, only read access to that directory is allowed.</param> public FileBasedFitFunctionService(string fitFunctionDirectory, bool isReadOnly) { _userDefinedFunctions = new SortedList <string, FileBasedFitFunctionInformation>(); _filesToProcess = new Queue <string>(); _fitFunctionDirectory = fitFunctionDirectory; if (!Directory.Exists(_fitFunctionDirectory) && !isReadOnly) { System.IO.Directory.CreateDirectory(_fitFunctionDirectory); } if (Directory.Exists(_fitFunctionDirectory)) { _fitFunctionDirectoryWatcher = new FileSystemWatcher(_fitFunctionDirectory, "*,xml"); _fitFunctionDirectoryWatcher.Changed += new FileSystemEventHandler(EhChanged); _fitFunctionDirectoryWatcher.Created += new FileSystemEventHandler(EhChanged); _fitFunctionDirectoryWatcher.Deleted += new FileSystemEventHandler(EhDeleted); _fitFunctionDirectoryWatcher.Renamed += new RenamedEventHandler(EhRenamed); // Begin watching. _fitFunctionDirectoryWatcher.EnableRaisingEvents = true; // for the first, enqueue all files in this directory for processing string[] names = Directory.GetFiles(_fitFunctionDirectory, "*.xml", SearchOption.TopDirectoryOnly); foreach (string name in names) { _filesToProcess.Enqueue(name); } // Start the thread _threadIsWorking = true; System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(this.ProcessFiles)); } }
private void Btn_AutoRun_Click(object sender, EventArgs e) { if (v_IsWatching) { v_IsWatching = false; fileSystemWatcherLogs.EnableRaisingEvents = false; fileSystemWatcherLogs.Dispose(); Btn_AutoRun.BackColor = Color.Blue; Btn_AutoRun.Text = "Start Scan"; } else { v_IsWatching = true; Btn_AutoRun.BackColor = Color.Red; Btn_AutoRun.Text = "Stop Scan"; fileSystemWatcherLogs = new System.IO.FileSystemWatcher(); string v_FolderInput = ConfigurationManager.AppSettings["PathInput"].ToString(); fileSystemWatcherLogs.Filter = "*.*"; fileSystemWatcherLogs.Path = v_FolderInput + "\\"; fileSystemWatcherLogs.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; fileSystemWatcherLogs.Changed += new FileSystemEventHandler(OnChanged); //fileSystemWatcherLogs.Created += new FileSystemEventHandler(OnChanged); //fileSystemWatcherLogs.Deleted += new FileSystemEventHandler(OnChanged); //fileSystemWatcherLogs.Renamed += new RenamedEventHandler(OnRenamed); fileSystemWatcherLogs.EnableRaisingEvents = true; } }
public SingleFileWatcher(ToolStrip ui, string path, SingleFileWathcerChangedHandler callback) { singleFileWathcerChangedHandler = callback; delex = new DelayExecuter(1000, delegate() { singleFileWathcerChangedHandler(); }); watcher = new System.IO.FileSystemWatcher(); //監視するディレクトリを指定 watcher.Path = Path.GetDirectoryName(path); //監視するファイルを指定 watcher.Filter = Path.GetFileName(path); //最終更新日時、ファイルサイズの変更を監視する watcher.NotifyFilter = (System.IO.NotifyFilters.Size |System.IO.NotifyFilters.LastWrite); //UIのスレッドにマーシャリングする watcher.SynchronizingObject = ui; //イベントハンドラの追加 watcher.Changed += new System.IO.FileSystemEventHandler(watcherChanged); watcher.Created += new System.IO.FileSystemEventHandler(watcherChanged); //監視を開始する watcher.EnableRaisingEvents = true; }
public FileViewer() { Label = Icons.PanelFileViewer + Resources.GetString("FileViewer") + "###FileVeiwer"; Core.OnAfterLoad += OnAfterLoad; Core.OnAfterNew += OnAfterLoad; Core.OnAfterSave += OnAfterSave; UpdateFileListWithProjectPath(Core.Root.GetFullPath()); TabToolTip = Resources.GetString("FileViewer"); menuOpenFile = Resources.GetString("FileViewer_OpenFile"); if (swig.GUIManager.IsMacOSX()) { menuShowInFileManager = Resources.GetString("FileViewer_ShowInFinder"); } else { menuShowInFileManager = Resources.GetString("FileViewer_ShowInExplorer"); } menuImportFromPackage = Resources.GetString("FileViewer_ImportFromPackage"); menuExportToPackage = Resources.GetString("FileViewer_ExportToPackage"); directoryWatcher = new FileSystemWatcher(); directoryWatcher.Changed += (o, e) => { shouldUpdateFileList = true; }; directoryWatcher.Renamed += (o, e) => { shouldUpdateFileList = true; }; directoryWatcher.Deleted += (o, e) => { shouldUpdateFileList = true; }; directoryWatcher.Created += (o, e) => { shouldUpdateFileList = true; }; UpdateFileList(Directory.GetCurrentDirectory()); }
public FileWatcher(string path, string[] filter) { if (filter == null || filter.Length == 0) { FileSystemWatcher mWather = new FileSystemWatcher(path); mWather.Changed += new FileSystemEventHandler(fileSystemWatcher_Changed); mWather.Deleted += new FileSystemEventHandler(fileSystemWatcher_Changed); mWather.Created += new FileSystemEventHandler(fileSystemWatcher_Changed); mWather.EnableRaisingEvents = true; mWather.IncludeSubdirectories = false; mWathers.Add(mWather); } else { foreach (string item in filter) { FileSystemWatcher mWather = new FileSystemWatcher(path, item); mWather.Changed += new FileSystemEventHandler(fileSystemWatcher_Changed); mWather.Deleted += new FileSystemEventHandler(fileSystemWatcher_Changed); mWather.Created += new FileSystemEventHandler(fileSystemWatcher_Changed); mWather.EnableRaisingEvents = true; mWather.IncludeSubdirectories = false; mWathers.Add(mWather); } } mTimer = new System.Threading.Timer(OnDetect, null, 5000, 5000); }
public static void StartFileWatcher(IOptionsMonitor <LiveReloadConfiguration> config) { // If this is a first start, initialize the config monitoring if (Config is null) { Config = config; Config.OnChange(OnConfigChanged); } if (!Config.CurrentValue.LiveReloadEnabled) { return; } var path = Config.CurrentValue.FolderToMonitor; path = Path.GetFullPath(path); Watcher = new FileSystemWatcher(path); Watcher.Filter = "*.*"; Watcher.EnableRaisingEvents = true; Watcher.IncludeSubdirectories = true; Watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; Watcher.Changed += Watcher_Changed; Watcher.Created += Watcher_Changed; Watcher.Renamed += Watcher_Renamed; }
static void Main(string[] args) { FileSystemWatcher watcher = new FileSystemWatcher(); try { watcher.Path = @"C:\_test\photos\"; } catch (ArgumentException ex) { Console.WriteLine(ex.Message); return; } watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; watcher.Filter = "*.txt"; watcher.Created += (source, e) => Console.WriteLine("{0} -- {1}", e.FullPath, e.ChangeType); watcher.Changed += (source, e) => Console.WriteLine("{0} -- {1}", e.FullPath, e.ChangeType); watcher.Deleted += (source, e) => Console.WriteLine("{0} -- {1}", e.FullPath, e.ChangeType); watcher.Renamed += (source, e) => Console.WriteLine("{0} -- {1}", e.FullPath, e.ChangeType); // Begin watching the directory. watcher.EnableRaisingEvents = true; ReadAndWrite(); // Wait for the user to quit the program. Console.WriteLine(@"Press 'q' to quit app."); while (Console.Read() != 'q') ; }
public FormMods() { InitializeComponent(); CenterToScreen(); listBoxInstalled.DataSource = new BindingList <ModListing>(); listBoxNotInstalled.DataSource = new BindingList <ModListing>(); UpdateModList(); var feh = new System.IO.FileSystemEventHandler(OnFileEvent); var feh2 = new System.IO.RenamedEventHandler(OnFileEvent); System.IO.FileSystemWatcher watcher1 = new System.IO.FileSystemWatcher { Path = MainForm.Settings.NotInstalledModsDirectory, NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName, Filter = "*.botm.zip" }; watcher1.Created += feh; watcher1.Changed += feh; watcher1.Renamed += feh2; watcher1.Deleted += feh; watcher1.EnableRaisingEvents = true; System.IO.FileSystemWatcher watcher2 = new System.IO.FileSystemWatcher { Path = MainForm.Settings.NotInstalledModsDirectory, NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName, Filter = "*.botm.zip" }; watcher2.Created += feh; watcher2.Deleted += feh; watcher2.EnableRaisingEvents = true; }
/// <summary> /// Initializes the <see cref="ViewManager"/> class. /// </summary> static ViewManager() { if (_viewCache == null) { lock (_key) { if (_viewCache == null) { _viewCache = new Dictionary<string, CachedView>(); } } } if (_fileSystemWatcher == null) { lock (_fileWatcherKey) { if (_fileSystemWatcher == null) { try { _fileSystemWatcher = new FileSystemWatcher(HttpRuntime.AppDomainAppPath, "*.cshtml"); _fileSystemWatcher.Changed += new FileSystemEventHandler(OnChanged); _fileSystemWatcher.EnableRaisingEvents = true; _fileSystemWatcher.IncludeSubdirectories = true; } catch (Exception ex) { Sitecore.Diagnostics.Log.Error("Failed to setup Razor file watcher.", ex); } } } } }
public static void Main() { //Demonstrates the FileSystemWatcher class System.IO.FileSystemWatcher fileWatcher = new System.IO.FileSystemWatcher(); fileWatcher.Path = @"..\..\BaseClassLibrary\FileSystemWatcher\WatchFolder"; // Check changes in LastAccess/LastWrite times // Check for renaming of directories/files. fileWatcher.NotifyFilter = (System.IO.NotifyFilters.LastAccess | System.IO.NotifyFilters.LastWrite | System.IO.NotifyFilters.FileName | System.IO.NotifyFilters.DirectoryName); // determine which files to watch for fileWatcher.Filter = "*.xml"; // Add event handlers for change events. fileWatcher.Changed += new FileSystemEventHandler(fileWatcher_Change); fileWatcher.Created += new FileSystemEventHandler(fileWatcher_Change); fileWatcher.Deleted += new FileSystemEventHandler(fileWatcher_Change); // Start watching...this must be set to true fileWatcher.EnableRaisingEvents = true; Console.WriteLine("Watching for changes...."); Console.ReadLine(); }
public PythonInterpreterFactoryWithDatabase( Guid id, string description, InterpreterConfiguration config, bool watchLibraryForChanges ) { _description = description; _id = id; _config = config; if (watchLibraryForChanges && Directory.Exists(_config.LibraryPath)) { _refreshIsCurrentTrigger = new Timer(RefreshIsCurrentTimer_Elapsed); _libWatcher = CreateLibraryWatcher(); _isCheckingDatabase = true; _refreshIsCurrentTrigger.Change(1000, Timeout.Infinite); _verWatcher = CreateDatabaseVerWatcher(); _verDirWatcher = CreateDatabaseDirectoryWatcher(); } // Assume the database is valid if the directory exists, then switch // to invalid after we've checked. _isValid = Directory.Exists(DatabasePath); }
public void StopWatch() { try { if (m_Watcher != null) { m_bIsWatching = false; m_event.Set(); m_Watcher.EnableRaisingEvents = false; m_Watcher.Dispose(); m_Watcher = null; while (m_queue.Count > 0) { UploadFileToServerWithPath(m_queue.Dequeue()); } if (m_dropboxInitialized == true) { m_dropbox.Close(); m_dropboxInitialized = false; } } } catch (Exception err) { throw (new SystemException(err.Message)); } }
private void StartFileWatcher() { string methodName = MethodBase.GetCurrentMethod().Name; logger.InfoFormat("BEGIN: {0}()", methodName); try { var configurationFileDirectory = new FileInfo(Configuration.FilePath).Directory; string fileName = Path.GetFileName(Configuration.FilePath); logger.InfoFormat("Monitor Configuration path:{0} file:{1}", configurationFileDirectory.FullName, fileName); _fileWatcher = new FileSystemWatcher(configurationFileDirectory.FullName); _fileWatcher.Filter = fileName; _fileWatcher.NotifyFilter = NotifyFilters.DirectoryName | NotifyFilters.FileName | NotifyFilters.LastWrite; _fileWatcher.Changed += ConfigFileWatcherOnChanged; _fileWatcher.EnableRaisingEvents = true; } catch (Exception e) { logger.Error(methodName, e); } finally { logger.InfoFormat("END: {0}()", methodName); } }
/// <summary> /// Sets the file watchers for the local directory. /// </summary> public void Setup() { Log.Write(l.Debug, "Setting the file system watchers"); _fswFiles = new FileSystemWatcher(); _fswFolders = new FileSystemWatcher(); _fswFiles.Path = controller.Paths.Local; _fswFolders.Path = controller.Paths.Local; _fswFiles.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite; _fswFolders.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.DirectoryName; _fswFiles.Filter = "*"; _fswFolders.Filter = "*"; _fswFiles.IncludeSubdirectories = true; _fswFolders.IncludeSubdirectories = true; // add event handlers for files: _fswFiles.Changed += FileChanged; _fswFiles.Created += FileChanged; _fswFiles.Deleted += OnDeleted; _fswFiles.Renamed += OnRenamed; // and for folders: //fswFolders.Changed += new FileSystemEventHandler(FolderChanged); _fswFolders.Created += FolderChanged; _fswFolders.Deleted += OnDeleted; _fswFolders.Renamed += OnRenamed; _fswFiles.EnableRaisingEvents = true; _fswFolders.EnableRaisingEvents = true; Log.Write(l.Debug, "File system watchers setup completed!"); }
private void WatchChange() { if (string.IsNullOrEmpty(settings.ScanBasePath)) { log.LogError("Scan path is empty. Cannot start watching folder change."); return; } try { var changeWatcher = new System.IO.FileSystemWatcher(); changeWatcher.Path = settings.ScanBasePath; changeWatcher.IncludeSubdirectories = true; changeWatcher.Filter = "*.jpg"; changeWatcher.Created += ChangeHandler; changeWatcher.EnableRaisingEvents = true; log.LogInfo(string.Format("Start watching change in folder {0}", settings.ScanBasePath)); } catch (ArgumentException ae) { string msg = string.Format("Watching folder {0} is not valid, please indicate a valid folder and restart application", settings.ScanBasePath); log.LogError(msg); msgDispatcher.PopulateMessage(msg); } catch (Exception e) { log.LogException("Start watching change exception. ", e); } }
public TemplateFile(string templatePath, TransformationData data) { this.nonDynamicHTMLOutput = data.NonDynamicHTMLOutput; this.publishFlags = data.Markdown.PublishFlags; ParsedTemplate = null; if (string.IsNullOrWhiteSpace(templatePath)) { throw new System.ArgumentException("Template path should be valid path."); } ReparseTemplate(templatePath); var templatePathDir = Path.GetDirectoryName(templatePath); var templatePathFileName = Path.GetFileName(templatePath); if (templatePathDir != null && templatePathFileName != null) { fileWatcher = new FileSystemWatcher(templatePathDir, templatePathFileName) { EnableRaisingEvents = true }; fileWatcher.Changed += (sender, args) => { ReparseTemplate(templatePath); if (TemplateChanged != null) { TemplateChanged(); } }; } }
public MainWindowViewModel() { _searchText = string.Empty; _hostsFilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), @"drivers\etc"); _hostsFileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.System), @"drivers\etc\hosts"); _hostItems = new ObservableCollection <HostItem>(); _filteredHostItems = new ObservableCollection <HostItem>(); _hostItems.CollectionChanged += _hostItems_CollectionChanged; _targets = new ObservableCollection <TargetAddress>(); Browsers = BrowserHelper.GetInstalledBrowsers(); SelectedHostItemBindingChanged = new SelectedHostItemBindingChangedCommand(this); ClearSelectedTargetTag = new ClearSelectedTargetTagCommand(this); LaunchBrowser = new LaunchBrowserCommand(this); LoadHostsFile(); ParseHostFileContents(); PropertyChanged += MainWindowViewModel_PropertyChanged; _hostsWatcher = new FileSystemWatcher(); _hostsWatcher.Path = _hostsFilePath; _hostsWatcher.NotifyFilter = NotifyFilters.LastWrite; _hostsWatcher.Changed += _hostsWatcher_Changed; _hostsWatcher.EnableRaisingEvents = true; }
public static void Init() { watcher = new FileSystemWatcher(Folder.GetWatcherPath()); watcher.IncludeSubdirectories = false; watcher.Created += new FileSystemEventHandler(OnCreate); watcher.EnableRaisingEvents = true; }
// ************************************************ // Class constructor public XmlHotDocument() : base() { m_watcher = new FileSystemWatcher(); HasChanges = false; EnableFileChanges = false; }
public DummyDoc() { InitializeComponent(); Global.myDebug("after InitializeComponent()"); #region MarkdownWin // MarkdownWin *21 browser.DocumentCompleted += browser_DocumentCompleted; // browser.PreviewKeyDown += browser_PreviewKeyDown; browser.AllowWebBrowserDrop = false; // browser.IsWebBrowserContextMenuEnabled = false; // ContextMenu Enabled //browser.WebBrowserShortcutsEnabled = false; // Shortcuts Enabled //browser.AllowNavigation = false; browser.ScriptErrorsSuppressed = true; browser.StatusTextChanged += browser_StatusTextChange; // new DWebBrowserEvents2_StatusTextChangeEventHandler(AxWebBrowser_StatusTextChange) _fileWatcher = new FileSystemWatcher(); // need assign in Class constructor _fileWatcher.NotifyFilter = NotifyFilters.Size | NotifyFilters.LastWrite; _fileWatcher.Changed += new FileSystemEventHandler(OnWatchedFileChanged); bgRefreshWorker.RunWorkerAsync(); this.Disposed += new EventHandler(Watcher_Disposed); browser.AllowWebBrowserDrop = false; #endregion }
public void StartListening(string directory, string filter, Func<string, Task> updated) { _fileSystemWatcher?.Dispose(); _fileSystemWatcher = new FileSystemWatcher(directory, filter) { EnableRaisingEvents = true, IncludeSubdirectories = true }; _fileSystemWatcher.Created += async (sender, eventArgs) => { await updated(eventArgs.FullPath).ConfigureAwait(false); }; _fileSystemWatcher.Changed += async (sender, eventArgs) => { await updated(eventArgs.FullPath).ConfigureAwait(false); }; _fileSystemWatcher.Deleted += async (sender, eventArgs) => { await updated(eventArgs.FullPath).ConfigureAwait(false); }; _fileSystemWatcher.Renamed += async (sender, eventArgs) => { await updated(eventArgs.FullPath).ConfigureAwait(false); }; }
public override void Close () { if (file_watcher != null) { file_watcher.EnableRaisingEvents = false; file_watcher = null; // force creation of new FileSystemWatcher } }
static void SetupFileSynchronization() { FileSystemEventHandler onFileCreatedOrChanged = (object sender, FileSystemEventArgs e) => { var blob = _container.GetBlockBlobReference(e.Name); Console.WriteLine("Uploading '{0}'", e.Name); blob.UploadFromFileAsync(e.FullPath, FileMode.Open); }; FileSystemEventHandler onFileDeleted = (object sender, FileSystemEventArgs e) => { var blob = _container.GetBlockBlobReference(e.Name); Console.WriteLine("Deleting '{0}'", e.Name); blob.DeleteIfExists(); }; var watcher = new System.IO.FileSystemWatcher(_path); watcher.Created += onFileCreatedOrChanged; watcher.Changed += onFileCreatedOrChanged; watcher.Deleted += onFileDeleted; watcher.EnableRaisingEvents = true; Console.WriteLine("Watching {0}!", _path); }
public Form1() { InitializeComponent(); //初始化得到配置文件中的SVN内网外网CheckOut地址 string SVN_W = AppSettings.GetValue("SVN_W"); string SVN_N = AppSettings.GetValue("SVN_N"); string SVN_TIME = AppSettings.GetValue("SVN_TIME"); string SlEEP_TIME = AppSettings.GetValue("SlEEP_TIME"); textBox1.Text = SVN_W; textBox2.Text = SVN_N; textBox3.Text = SlEEP_TIME; textBox4.Text = SVN_TIME; //定时器打开 InitalizeTimer(); //监视外网文件 this.watcher_W = new FileSystemWatcher(); this.watcher_W.Deleted += new FileSystemEventHandler(watcher_Deleted); this.watcher_W.Renamed += new RenamedEventHandler(watcher_Renamed); this.watcher_W.Changed += new FileSystemEventHandler(watcher_Changed); this.watcher_W.Created += new FileSystemEventHandler(watcher_Created); //监视内网仓库 this.watcher_N = new FileSystemWatcher(); this.watcher_N.Deleted += new FileSystemEventHandler(watcher_Deleted_N); this.watcher_N.Renamed += new RenamedEventHandler(watcher_Renamed_N); this.watcher_N.Changed += new FileSystemEventHandler(watcher_Changed_N); this.watcher_N.Created += new FileSystemEventHandler(watcher_Created_N); }
public static int Main(string[] args) { List<string> pargs = ndclTools.ParamForm(args); if (pargs.FindParam("-h") || pargs.FindParam("--help")) { outputHelp(); return 0; } int timeout; if (!getTimeout(pargs, out timeout)) return 1; watch = new FileSystemWatcher(); if(!getPath(pargs, watch)) return 1; if (pargs.FindParam("-d")) watch.Deleted += new FileSystemEventHandler(handler); if (!pargs.FindParam("-c")) watch.Changed += new FileSystemEventHandler(handler); if (!pargs.FindParam("-C")) watch.Created += new FileSystemEventHandler(handler); if (!pargs.FindParam("-r")) watch.Renamed += new RenamedEventHandler(handler); watch.IncludeSubdirectories = pargs.FindParam("-s"); last = new Tuple<string, DateTime>("", DateTime.Now); watch.EnableRaisingEvents = true; if (timeout == -1) while (Console.Read() != 'q') ; else System.Threading.Thread.Sleep(timeout); return 0; }
public FileWatcher(string path, string filer, string outFile) { var a = new System.IO.FileSystemWatcher(path, filer) { IncludeSubdirectories = true, EnableRaisingEvents = true }; OutFile = outFile; Path = path; Filter = filer; FileModels = new List<FileModel>(); a.Changed += async (sender, e) => { var sw = new Stopwatch(); sw.Start(); if (isIn) return; lock (this) { if (isIn) return; isIn = true; } if ((e is FileSystemEventArgs ee)) { FileModels.Clear(); await UpdateFiles(); //var TsProj = new DataAtr.Models.Typescript.TypeDeffinition(new DataAtr.Models.ProjectModel { FileModels = FileModels }).TypescriptPoject(); //File.WriteAllText(outFile, TsProj); //Console.WriteLine($"{DateTime.Now.ToLongTimeString()}: Update ({sw.ElapsedMilliseconds}ms) {(isIn ? "" : "false")}"); isIn = false; } }; }
public MainWindow() { InitializeComponent(); ConnectionsListView.ItemsSource = _storageAccountConnections; IDeploymentRepositoryFactory deploymentRepositoryFactory = new DeploymentRepositoryFactory(); _deploymentRepositoryManager = new DeploymentRepositoryManager(deploymentRepositoryFactory); _jsonSerializer = new JsonSerializer(new DiagnosticsTraceWriter()); _deploymentConfigSerializer = new JsonDeploymentConfigSerializer(_jsonSerializer); if (File.Exists(SettingsFilePath)) { string json = File.ReadAllText(SettingsFilePath); _storageAccountConnections = _jsonSerializer.Deserialize<List<StorageAccountConnectionInfo>>(json); ConnectionsListView.ItemsSource = _storageAccountConnections; } if (!Directory.Exists(DeploymentsConfigsDirPath)) { Directory.CreateDirectory(DeploymentsConfigsDirPath); } _deploymentConfigFileWatcher = new FileSystemWatcher { Path = Path.GetFullPath(DeploymentsConfigsDirPath), NotifyFilter = NotifyFilters.LastWrite, Filter = "*.json" }; _deploymentConfigFileWatcher.Changed += OnDeploymentConfigFileChanged; _deploymentConfigFileWatcher.EnableRaisingEvents = true; }
private static void Run() { try { // Check is valid directory if(string.IsNullOrEmpty(BaseConfig.Watcher.Path) && !Directory.Exists(BaseConfig.Watcher.Path)) { Console.WriteLine("Invalid directory. Please check configuration."); return; } // Create watcher FileSystemWatcher watcher = new FileSystemWatcher() { Path = BaseConfig.Watcher.Path, NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName, Filter = BaseConfig.Watcher.Filter, EnableRaisingEvents = true, }; // Add event handlers. watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Created += new FileSystemEventHandler(OnChanged); watcher.Deleted += new FileSystemEventHandler(OnChanged); watcher.Renamed += new RenamedEventHandler(OnRenamed); // Wait for the user to quit the program. Console.WriteLine("Press \'q\' to quit the sample."); while (Console.Read() != 'q') ; } catch(Exception e) { Console.WriteLine(e.Message); } }
private void Run() { // Create a new FileSystemWatcher and set its properties. watcher = new FileSystemWatcher(); try { watcher.Path = path; /* Watch for changes in LastAccess and LastWrite times, and the renaming of files or directories. */ watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; // Watch all files watcher.Filter = "*.*"; // Add event handlers. watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Created += new FileSystemEventHandler(OnCreated); watcher.Deleted += new FileSystemEventHandler(OnDeleted); watcher.Renamed += new RenamedEventHandler(OnRenamed); //set to watch subfolders watcher.IncludeSubdirectories = true; // Begin watching. watcher.EnableRaisingEvents = true; } catch (SystemException) { //wrong folder return; } }
/// <summary> /// 返回ConfigReader 对象(单件模式) /// </summary> /// <returns></returns> private static ConfigReader Create() { if (_ConfigReader != null) { return(_ConfigReader); } if (watcher == null) { watcher = new System.IO.FileSystemWatcher(); watcher.Path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Config"); watcher.Filter = "*.config"; watcher.Changed += new System.IO.FileSystemEventHandler(watcher_Changed); watcher.EnableRaisingEvents = true; watcher.IncludeSubdirectories = true; } if (_ConfigReader == null) { lock (_lock) { _ConfigReader = new ConfigReader(); } } return(_ConfigReader); }