दिलचस्प पोस्ट
एएसपी.नेट 4.5 एमवीसी 4 विंडोज सर्वर 2008 आईआईएस 7 पर काम नहीं कर रहा है जावा का इटरेटर क्यों नहीं है? एक्सेल VBA – तिथि करने के लिए पाठ कन्वर्ट? Node.js के साथ उपयोग करने के लिए कौन सा websocket लाइब्रेरी? मोर्चे पर टंकिनर खिड़की कूदने के लिए कैसे करें? एक टेक्स्टरेआ के अंदर पाठ हाइलाइट करें जावास्क्रिप्ट में "अपरिभाषित x 1" क्या है? एंड्रॉइड में होम बटन दबाएं क्या मैं HTML5 के उपयोग से <<inside> एक <बटन> तत्व घोंसला कर सकता हूं? जावा के साथ फ़ाइल अपलोड करें (प्रगति बार के साथ) बाश में हैश टेबल कैसे परिभाषित करें? वर्तमान कार्यशील निर्देशिका के सापेक्ष पथ प्राप्त करना? कर्ल के साथ $ _POST मान पासिंग फिबोनैकी अनुक्रम की कम्प्यूटेशनल जटिलता HTTPS और SSL3_GET_SERVER_CERTIFICATE: प्रमाणपत्र विफल हो गया, CA ठीक है

FileSystemWatcher परिवर्तित ईवेंट दो बार उठाया गया है

मेरे पास एक ऐसा एप्लिकेशन है जहां मैं एक पाठ फ़ाइल की तलाश कर रहा हूं और यदि फ़ाइल में किए गए कोई भी परिवर्तन है तो मैं घटना को संभालने के लिए OnChanged चेंग्ड OnChanged का उपयोग कर रहा हूं। मैं NotifyFilters.LastWriteTime का उपयोग कर रहा NotifyFilters.LastWriteTime लेकिन अभी भी घटना दो बार निकाल रही है NotifyFilters.LastWriteTime यहां कोड है

 public void Initialize() { FileSystemWatcher _fileWatcher = new FileSystemWatcher(); _fileWatcher.Path = "C:\\Folder"; _fileWatcher.NotifyFilter = NotifyFilters.LastWrite; _fileWatcher.Filter = "Version.txt"; _fileWatcher.Changed += new FileSystemEventHandler(OnChanged); _fileWatcher.EnableRaisingEvents = true; } private void OnChanged(object source, FileSystemEventArgs e) { ....... } 

मेरे मामले में OnChanged को दो बार कहा जाता है, जब मैं पाठ फ़ाइल version.txt बदलता हूं और इसे सहेजता हूं।

वेब के समाधान से एकत्रित समाधान "FileSystemWatcher परिवर्तित ईवेंट दो बार उठाया गया है"

मुझे डर है कि यह FileSystemWatcher क्लास का एक प्रसिद्ध बग / फीचर है। यह कक्षा के दस्तावेज़ीकरण से है:

आप कुछ स्थितियों में देख सकते हैं कि एकल निर्माण इवेंट ने कई घटक बनाए जो आपके घटक द्वारा प्रबंधित किए जाते हैं। उदाहरण के लिए, यदि आप एक फाइलसिस्टमवाटचर घटक का उपयोग डायरेक्टरी में नई फाइल बनाने की निगरानी करने के लिए करते हैं, और उसके बाद फ़ाइल बनाने के लिए नोटपैड का उपयोग कर जांचते हैं, तो आप केवल दो फाइलें बनाई हैं, भले ही केवल एक फ़ाइल बनाई गई हो। ऐसा इसलिए है क्योंकि नोटपैड लेखन प्रक्रिया के दौरान कई फाइल सिस्टम क्रियाओं को करता है। नोटपैड डिस्क में लिखता है जो फ़ाइल की सामग्री बनाते हैं और फिर फ़ाइल विशेषताएँ अन्य अनुप्रयोग एक ही तरीके से प्रदर्शन कर सकते हैं। क्योंकि FileSystemWatcher ऑपरेटिंग सिस्टम की गतिविधियों पर नज़र रखता है, सभी ईवेंट जो इन एप्लिकेशन को आग में उठाए जाएंगे।

अब पाठ का यह छोटा Created ईवेंट के बारे में है, लेकिन वैसे ही अन्य फाइल इवेंट के लिए भी लागू होता है कुछ एप्लिकेशन में आप इस बारे में NotifyFilter संपत्ति का उपयोग कर प्राप्त कर सकते हैं, लेकिन मेरा अनुभव कहता है कि कभी-कभी आपको कुछ मैनुअल डुप्लिकेट फ़िल्टरिंग (हैक्स) भी करना पड़ता है

कुछ समय पहले मैंने कुछ फाइल सिस्टम वॉटर टिप के साथ एक पेज को बुक किया था। शायद आप इस पर एक नजर डालना चाहें।

मेरे "प्रतिनिधि" ने मेरे प्रतिनिधि में निम्नलिखित रणनीति का उपयोग करते हुए समस्या:

 // fsw_ is the FileSystemWatcher instance used by my application. private void OnDirectoryChanged(...) { try { fsw_.EnableRaisingEvents = false; /* do my stuff once asynchronously */ } finally { fsw_.EnableRaisingEvents = true; } } 

FileSystemWatcher से किसी भी डुप्लिकेट ऑन- File.GetLastWriteTime ईवेंट का पता लगाया जा सकता है और फ़ाइल में फाइल पर File.GetLastWriteTime कर दिया जा सकता है। इस तरह:

 DateTime lastRead = DateTime.MinValue; void OnChanged(object source, FileSystemEventArgs a) { DateTime lastWriteTime = File.GetLastWriteTime(uri); if (lastWriteTime != lastRead) { doStuff(); lastRead = lastWriteTime; } // else discard the (duplicated) OnChanged event } 

यहाँ मेरा समाधान है जिसने मुझे दो बार उठाए जाने वाले घटना को रोकने में मदद की:

 watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size; 

यहां मैंने NotifyFilter संपत्ति को केवल फाइल नाम और आकार के साथ सेट किया है
watcher मेरे FileSystemWatcher का उद्देश्य है आशा है कि इससे मदद मिलेगी

मेरा परिदृश्य यह है कि इसमें एक लिनक्स सर्वर के साथ एक वर्चुअल मशीन है I मैं विंडोज मेजबान पर फाइलें विकसित कर रहा हूँ जब मैं मेजबान के किसी फ़ोल्डर में कुछ बदलता हूं तो मैं चाहता हूं कि सभी परिवर्तन अपलोड किए जाएं, एफ़टीपी द्वारा वर्चुअल सर्वर पर सिंक्रनाइज़ किया गया। जब मैं किसी फ़ाइल को लिखता हूं (जो फ़ाइल को फ़ोल्डर में परिवर्तित करता है, तो इसके साथ ही संशोधित होने के लिए) मैं डुप्लिकेट परिवर्तन इवेंट को समाप्त कर रहा हूं:

 private Hashtable fileWriteTime = new Hashtable(); private void fsw_sync_Changed(object source, FileSystemEventArgs e) { string path = e.FullPath.ToString(); string currentLastWriteTime = File.GetLastWriteTime( e.FullPath ).ToString(); // if there is no path info stored yet // or stored path has different time of write then the one now is inspected if ( !fileWriteTime.ContainsKey(path) || fileWriteTime[path].ToString() != currentLastWriteTime ) { //then we do the main thing log( "A CHANGE has occured with " + path ); //lastly we update the last write time in the hashtable fileWriteTime[path] = currentLastWriteTime; } } 

मुख्य रूप से मैं फाइल लेखन समय की जानकारी को स्टोर करने के लिए एक हैशटेबल तैयार करता हूं। तब अगर हैशटेबल में फ़ाइलपथ है जिसे संशोधित किया गया है और इसका समय मान वर्तमान में अधिसूचित फाइल के परिवर्तन के समान है, तो मुझे पता है कि यह घटना का डुप्लिकेट है और इसे अनदेखा कर दिया है।

यहां मेरा दृष्टिकोण है:

 // Consider having a List<String> named _changedFiles private void OnChanged(object source, FileSystemEventArgs e) { lock (_changedFiles) { if (_changedFiles.Contains(e.FullPath)) { return; } } // do your stuff System.Timers.Timer timer = new Timer(1000) { AutoReset = false }; timer.Elapsed += (timerElapsedSender, timerElapsedArgs) => { lock (_changedFiles) { _changedFiles.Remove(e.FullPath); } }; timer.Start(); } 

यह एक ऐसा समाधान है जिसका उपयोग मैं एक प्रोजेक्ट पर इस मुद्दे को हल करने के लिए किया था, जहां मैं मेल में अनुलग्नक के रूप में फ़ाइल भेज रहा था। यह आसानी से एक छोटे टाइमर अंतराल के साथ दो बार भागने वाली घटना से बचता है, लेकिन मेरे मामले में 1000 ठीक था क्योंकि मुझे मेलबॉक्स से दूसरे संदेश> 1 संदेश प्रति सेकेंड के बाढ़ के मुकाबले कुछ परिवर्तनों में कमी के साथ खुश था। कम से कम यह ठीक काम करता है अगर कई फाइल ठीक उसी समय बदल जाती हैं

मैंने सोचा है कि एक अन्य समाधान अपने संबंधित एमडी 5 में एक शब्दकोश मैपिंग फाइलों के साथ सूची को बदलने के लिए होगा, इसलिए आपको एक मनमाना अंतराल नहीं चुनना होगा, क्योंकि आपको प्रविष्टि को हटाना होगा, इसके मूल्य को अपडेट नहीं करना होगा, और अपने सामान को रद्द करें यदि वह नहीं बदला है। इसमें मेमोरी में एक डिक्शनरी बढ़ने की नकारात्मकता है क्योंकि फाइल की निगरानी और अधिक मेमोरी होती है, लेकिन मैंने कहीं पढ़ा है कि निगरानी की गई फ़ाइलों की मात्रा एफएसडब्ल्यू के आंतरिक बफर पर निर्भर करती है, इसलिए हो सकता है कि यह महत्वपूर्ण नहीं हो। पता नहीं कैसे एमडी 5 कंप्यूटिंग का समय आपके कोड के प्रदर्शन को प्रभावित करेगा, सावधान = \

इस कोड के साथ प्रयास करें:

 class WatchPlotDirectory { bool let = false; FileSystemWatcher watcher; string path = "C:/Users/jamie/OneDrive/Pictures/Screenshots"; public WatchPlotDirectory() { watcher = new FileSystemWatcher(); watcher.Path = path; watcher.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; watcher.Filter = "*.*"; watcher.Changed += new FileSystemEventHandler(OnChanged); watcher.Renamed += new RenamedEventHandler(OnRenamed); watcher.EnableRaisingEvents = true; } void OnChanged(object sender, FileSystemEventArgs e) { if (let==false) { string mgs = string.Format("File {0} | {1}", e.FullPath, e.ChangeType); Console.WriteLine("onchange: " + mgs); let = true; } else { let = false; } } void OnRenamed(object sender, RenamedEventArgs e) { string log = string.Format("{0} | Renamed from {1}", e.FullPath, e.OldName); Console.WriteLine("onrenamed: " + log); } public void setPath(string path) { this.path = path; } } 

मुझे पता है यह एक पुरानी समस्या है, लेकिन एक ही समस्या थी और ऊपर दिए गए समाधान में से कोई भी वास्तव में समस्या का सामना करना पड़ रहा था जो मुझे सामना करना पड़ रहा था। मैंने एक शब्दकोश बनाया है जो अंतिम नाम के साथ फ़ाइल नाम को मैप करता है। इसलिए यदि फ़ाइल शब्दकोश में नहीं है तो प्रक्रिया के साथ आगे बढ़ेगा अन्य बुद्धिमान जांचें यह देखने के लिए कि अंतिम संशोधित समय कब हुआ था और अगर कोड में यह क्या होता है से अलग होता है तो कोड चलाते हैं।

  Dictionary<string, DateTime> dateTimeDictionary = new Dictionary<string, DateTime>(); private void OnChanged(object source, FileSystemEventArgs e) { if (!dateTimeDictionary.ContainsKey(e.FullPath) || (dateTimeDictionary.ContainsKey(e.FullPath) && System.IO.File.GetLastWriteTime(e.FullPath) != dateTimeDictionary[e.FullPath])) { dateTimeDictionary[e.FullPath] = System.IO.File.GetLastWriteTime(e.FullPath); //your code here } } 

एक संभव 'हैक' उदाहरण के लिए रिएक्टिव एक्सटेंशन्स का उपयोग करके घटनाओं को गड़बड़ाना होगा:

 var watcher = new FileSystemWatcher("./"); Observable.FromEventPattern<FileSystemEventArgs>(watcher, "Changed") .Throttle(new TimeSpan(500000)) .Subscribe(HandleChangeEvent); watcher.EnableRaisingEvents = true; 

इस मामले में मैं अपने सिस्टम पर 50ms तक थ्रॉटलिंग कर रहा हूं, जो कि पर्याप्त था, लेकिन उच्च मान सुरक्षित होना चाहिए। (और जैसे मैंने कहा, यह अभी भी 'हैक' है)।

मुख्य कारण पहली घटना का अंतिम एक्सेस समय वर्तमान समय था (फ़ाइल लिखना या परिवर्तित समय) तो दूसरी घटना फ़ाइल का मूल अंतिम एक्सेस समय था। मैं कोड के तहत हल

  var lastRead = DateTime.MinValue; Watcher = new FileSystemWatcher(...) { NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite, Filter = "*.dll", IncludeSubdirectories = false, }; Watcher.Changed += (senderObject, ea) => { var now = DateTime.Now; var lastWriteTime = File.GetLastWriteTime(ea.FullPath); if (now == lastWriteTime) { return; } if (lastWriteTime != lastRead) { // do something... lastRead = lastWriteTime; } }; Watcher.EnableRaisingEvents = true; 

मैं FileSystemWatcher का उपयोग करके कुछ महत्वपूर्ण समय व्यतीत किया है, और यहां कुछ तरीके काम नहीं करेंगे I मुझे वास्तव में निष्क्रिय करने वाले घटनाओं का दृष्टिकोण पसंद आया, लेकिन दुर्भाग्य से, अगर 1 फ़ाइल को हटाया गया है, तो यह काम नहीं करता है, दूसरी बार सबसे ज्यादा नहीं तो दूसरी फाइल को मिट जाएगा। इसलिए मैं निम्नलिखित दृष्टिकोण का उपयोग करता हूं:

 private void EventCallback(object sender, FileSystemEventArgs e) { var fileName = e.FullPath; if (!File.Exists(fileName)) { // We've dealt with the file, this is just supressing further events. return; } // File exists, so move it to a working directory. File.Move(fileName, [working directory]); // Kick-off whatever processing is required. } 

मेरे पास यहां एक बहुत ही त्वरित और सरल समाधान है, यह मेरे लिए काम करता है, और कोई फर्क नहीं पड़ता कि कभी-कभी यह घटना एक या दो बार या अधिक बार शुरू हो जाएगी, इसे जांचें:

 private int fireCount = 0; private void inputFileWatcher_Changed(object sender, FileSystemEventArgs e) { fireCount++; if (fireCount == 1) { MessageBox.Show("Fired only once!!"); dowork(); } else { fireCount = 0; } } } 

यह कोड मेरे लिए काम किया।

  private void OnChanged(object source, FileSystemEventArgs e) { string fullFilePath = e.FullPath.ToString(); string fullURL = buildTheUrlFromStudyXML(fullFilePath); System.Diagnostics.Process.Start("iexplore", fullURL); Timer timer = new Timer(); ((FileSystemWatcher)source).Changed -= new FileSystemEventHandler(OnChanged); timer.Interval = 1000; timer.Elapsed += new ElapsedEventHandler(t_Elapsed); timer.Start(); } private void t_Elapsed(object sender, ElapsedEventArgs e) { ((Timer)sender).Stop(); theWatcher.Changed += new FileSystemEventHandler(OnChanged); } 

यहाँ एक नया समाधान है जिसे आप कोशिश कर सकते हैं मेरे लिए अच्छा काम करता है परिवर्तित ईवेंट के लिए ईवेंट हैंडलर में प्रोग्रामर से डिज़ाइनर आउटपुट से हेन्डलर को एक संदेश भेजना चाहिए, यदि वांछित है, तो प्रोग्रामर रूप से हेन्डलर को वापस जोड़ें। उदाहरण:

 public void fileSystemWatcher1_Changed( object sender, System.IO.FileSystemEventArgs e ) { this.fileSystemWatcher1.Changed -= new System.IO.FileSystemEventHandler( this.fileSystemWatcher1_Changed ); MessageBox.Show( "File has been uploaded to destination", "Success!" ); this.fileSystemWatcher1.Changed += new System.IO.FileSystemEventHandler( this.fileSystemWatcher1_Changed ); } 

मैंने जिस तरीके से फाइलें डायरेक्टरीज में रखी हैं, उसके बदले FileSystemWatcher I मतदान स्थानों को दूसरे थ्रेड पर उपयोग करने के बजाय और फिर फ़ाइल के LastWriteTime को देखें।

 DateTime lastWriteTime = File.GetLastWriteTime(someFilePath); 

इस सूचना का उपयोग करना और किसी फ़ाइल पथ की एक अनुक्रमणिका रखना और यह नवीनतम लिखने का समय है, मैं उन फ़ाइलों को निर्धारित कर सकता हूं जो बदल गए हैं या जो किसी विशेष स्थान पर बनाए गए हैं। यह मुझे FileSystemWatcher की विषमताओं से हटा देता है मुख्य नकारात्मक पक्ष यह है कि आपको अंतिम वर्डटाइम और फ़ाइल के संदर्भ में स्टोर करने के लिए डेटा संरचना की आवश्यकता है, लेकिन यह विश्वसनीय और कार्यान्वयन करना आसान है

आप लिखने के लिए इसे खोलने की कोशिश कर सकते हैं, और यदि सफल हो तो आप यह सोच सकते हैं कि फाइल के साथ अन्य आवेदन किया जाता है।

 private void OnChanged(object source, FileSystemEventArgs e) { try { using (var fs = File.OpenWrite(e.FullPath)) { } //do your stuff } catch (Exception) { //no write access, other app not done } } 

बस इसे लिखने के लिए खोलने के लिए परिवर्तित घटना बढ़ा नहीं प्रतीत होता है। तो यह सुरक्षित होना चाहिए

गंभीर खुदाई के लिए खेद है, लेकिन मैं कुछ समय के लिए इस मुद्दे से जूझ रहा हूं और आखिरकार इन कई पचास घटनाओं को संभालने का एक तरीका तैयार किया है। मैं इस धागे में सभी को धन्यवाद देना चाहूंगा क्योंकि मैंने इसे इस मुद्दे से जूझते समय कई संदर्भों में उपयोग किया है।

यह मेरा पूरा कोड है यह फ़ाइल के आखिरी लिखित तारीख और समय को ट्रैक करने के लिए एक शब्दकोश का उपयोग करता है। यह उस मूल्य की तुलना करता है, और यदि वह समान है, तो वह घटनाओं को दबा देती है यह तब नया धागा शुरू करने के बाद मूल्य सेट करता है।

 using System.Threading; // used for backgroundworker using System.Diagnostics; // used for file information private static IDictionary<string, string> fileModifiedTable = new Dictionary<string, string>(); // used to keep track of our changed events private void fswFileWatch_Changed( object sender, FileSystemEventArgs e ) { try { //check if we already have this value in our dictionary. if ( fileModifiedTable.TryGetValue( e.FullPath, out sEmpty ) ) { //compare timestamps if ( fileModifiedTable[ e.FullPath ] != File.GetLastWriteTime( e.FullPath ).ToString() ) { //lock the table lock ( fileModifiedTable ) { //make sure our file is still valid if ( File.Exists( e.FullPath ) ) { // create a new background worker to do our task while the main thread stays awake. Also give it do work and work completed handlers BackgroundWorker newThreadWork = new BackgroundWorker(); newThreadWork.DoWork += new DoWorkEventHandler( bgwNewThread_DoWork ); newThreadWork.RunWorkerCompleted += new RunWorkerCompletedEventHandler( bgwNewThread_RunWorkerCompleted ); // capture the path string eventFilePath = e.FullPath; List<object> arguments = new List<object>(); // add arguments to pass to the background worker arguments.Add( eventFilePath ); arguments.Add( newEvent.File_Modified ); // start the new thread with the arguments newThreadWork.RunWorkerAsync( arguments ); fileModifiedTable[ e.FullPath ] = File.GetLastWriteTime( e.FullPath ).ToString(); //update the modified table with the new timestamp of the file. FILE_MODIFIED_FLAG.WaitOne(); // wait for the modified thread to complete before firing the next thread in the event multiple threads are being worked on. } } } } } catch ( IOException IOExcept ) { //catch any errors postError( IOExcept, "fswFileWatch_Changed" ); } } 

मैंने एक गिट रेपो बनाया है जो क्लास के साथ FileSystemWatcher को केवल घटनाओं को ट्रिगर करने के लिए FileSystemWatcher है जब प्रतिलिपि की जाती है यह सभी परिवर्तित घटनाओं को अंतिम रूप से छोड़ देता है और इसे केवल तभी उठाता है जब फ़ाइल पढ़ने के लिए उपलब्ध हो जाती है।

FileSystemSafeWatcher डाउनलोड करें और इसे अपने प्रोजेक्ट में जोड़ें।

फिर इसे एक सामान्य FileSystemWatcher रूप में उपयोग करें और जब ईवेंट ट्रिगर किए जाते हैं तो मॉनिटर करें

 var fsw = new FileExamSystemWatcher(file); fsw.EnableRaisingEvents = true; // Add event handlers here fsw.Created += fsw_Created; 

मैं ऐसा करने में सक्षम था एक समारोह जोड़ा है कि एक बफर सरणी में डुप्लिकेट के लिए जाँच करता है।

टाइमर का उपयोग करते हुए एक्स समय के लिए सरणी को संशोधित नहीं करने के बाद कार्रवाई करें: – हर बार कुछ बफर में लिखा जाता है – टाइमर पर कार्रवाई करें

यह भी एक और दोहराव प्रकार पकड़ता है। यदि आप किसी फ़ाइल के अंदर किसी फ़ाइल को संशोधित करते हैं, तो फ़ोल्डर में परिवर्तन ईवेंट भी फेंकता है

 Function is_duplicate(str1 As String) As Boolean If lb_actions_list.Items.Count = 0 Then Return False Else Dim compStr As String = lb_actions_list.Items(lb_actions_list.Items.Count - 1).ToString compStr = compStr.Substring(compStr.IndexOf("-") + 1).Trim If compStr <> str1 AndAlso compStr.parentDir <> str1 & "\" Then Return False Else Return True End If End If End Function Public Module extentions <Extension()> Public Function parentDir(ByVal aString As String) As String Return aString.Substring(0, CInt(InStrRev(aString, "\", aString.Length - 1))) End Function End Module 
 FileReadTime = DateTime.Now; private void File_Changed(object sender, FileSystemEventArgs e) { var lastWriteTime = File.GetLastWriteTime(e.FullPath); if (lastWriteTime.Subtract(FileReadTime).Ticks > 0) { // code FileReadTime = DateTime.Now; } } 

यह समाधान मेरे लिए उत्पादन अनुप्रयोग पर काम किया है:

वातावरण:

VB.Net फ्रेमवर्क 4.5.2

मैन्युअल ऑब्जेक्ट गुण सेट करें: NotifyFilter = Size

फिर इस कोड का उपयोग करें:

 Public Class main Dim CalledOnce = False Private Sub FileSystemWatcher1_Changed(sender As Object, e As IO.FileSystemEventArgs) Handles FileSystemWatcher1.Changed If (CalledOnce = False) Then CalledOnce = True If (e.ChangeType = 4) Then ' Do task... CalledOnce = False End If End Sub End Sub 

इसे इस्तेमाल करे!

 string temp=""; public void Initialize() { FileSystemWatcher _fileWatcher = new FileSystemWatcher(); _fileWatcher.Path = "C:\\Folder"; _fileWatcher.NotifyFilter = NotifyFilters.LastWrite; _fileWatcher.Filter = "Version.txt"; _fileWatcher.Changed += new FileSystemEventHandler(OnChanged); _fileWatcher.EnableRaisingEvents = true; } private void OnChanged(object source, FileSystemEventArgs e) { ....... if(temp=="") { //do thing you want. temp = e.name //name of text file. }else if(temp !="" && temp != e.name) { //do thing you want. temp = e.name //name of text file. }else { //second fire ignored. } } 

ज्यादातर मुझे भविष्य के लिए 🙂

मैंने आरएक्स का उपयोग कर आवरण लिखा था:

  public class WatcherWrapper : IDisposable { private readonly FileSystemWatcher _fileWatcher; private readonly Subject<FileSystemEventArgs> _infoSubject; private Subject<FileSystemEventArgs> _eventSubject; public WatcherWrapper(string path, string nameFilter = "*.*", NotifyFilters? notifyFilters = null) { _fileWatcher = new FileSystemWatcher(path, nameFilter); if (notifyFilters != null) { _fileWatcher.NotifyFilter = notifyFilters.Value; } _infoSubject = new Subject<FileSystemEventArgs>(); _eventSubject = new Subject<FileSystemEventArgs>(); Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Changed").Select(e => e.EventArgs) .Subscribe(_infoSubject.OnNext); Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Created").Select(e => e.EventArgs) .Subscribe(_infoSubject.OnNext); Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Deleted").Select(e => e.EventArgs) .Subscribe(_infoSubject.OnNext); Observable.FromEventPattern<FileSystemEventArgs>(_fileWatcher, "Renamed").Select(e => e.EventArgs) .Subscribe(_infoSubject.OnNext); // this takes care of double events and still works with changing the name of the same file after a while _infoSubject.Buffer(TimeSpan.FromMilliseconds(20)) .Select(x => x.GroupBy(z => z.FullPath).Select(z => z.LastOrDefault()).Subscribe( infos => { if (infos != null) foreach (var info in infos) { { _eventSubject.OnNext(info); } } }); _fileWatcher.EnableRaisingEvents = true; } public IObservable<FileSystemEventArgs> FileEvents => _eventSubject; public void Dispose() { _fileWatcher?.Dispose(); _eventSubject.Dispose(); _infoSubject.Dispose(); } } 

उपयोग:

 var watcher = new WatcherWrapper(_path, "*.info"); // all more complicated and scenario specific filtering of events can be done here watcher.FileEvents.Where(x => x.ChangeType != WatcherChangeTypes.Deleted).Subscribe(x => //do stuff) 

यदि आप ऑन-चेंंकेड ईवेंट में पंजीकृत हैं, तो मॉनिटर फाइल को हटाने से पहले इसे काम करने से पहले, जब तक आप केवल OnChange ईवेंट को मॉनिटर करने की आवश्यकता होती है ..

इसे एक सरल वैश्विक वैरिएबल var1 = true को परिभाषित करें।

 Private Sub FileWatchman_Changed(ByVal sender As System.Object, ByVal e As System.IO.FileSystemEventArgs) Handles FileWatchman.Changed If var1 = true your logic goes here var1 = false Else var1 = true End If End Sub 

ठीक है, यहाँ मेरा समाधान है कि एक बार केवल एक घटना कैसे बढ़ाएं:

 FileSystemWatcheк watcher = new FileSystemWatcher(); //'path' - path to the file that has been modified. watcher.Changed += (s, e) => FileChanged(path); 

यहाँ FileChanged के कार्यान्वयन है

 //count is our counter to triger when we can raise and when not. private int count = 0; private void FileChanged(string path) { if (count % 2 == 0) { //code here } count ++; }