FileSystemWatcher

Question

का उपयोग कर एकाधिक फ़ोल्डरों की निगरानी करें C# में FileSystemWatcher का उपयोग करके एकाधिक फ़ोल्डर्स (उपनिर्देशिका नहीं) की निगरानी करने का सबसे अच्छा तरीका क्या है?

Answer 1

मुझे नहीं लगता कि FSW से अधिक फ़ोल्डर की निगरानी का समर्थन करता है, तो बस आप निगरानी करना चाहते फ़ोल्डर प्रति एक दृष्टांत है। आप इवेंट हैंडलर को एक ही तरीके से इंगित कर सकते हैं, हालांकि, जो मुझे लगता है कि काम करना समाप्त हो जाना चाहिए।

Answer 2

आप बस FileSystemWatcher, प्रत्येक निर्देशिका के लिए एक के कई उदाहरण का उपयोग कर सकते हैं?

Answer 3

सबसे आसान तरीका है FileSystemWatcher वस्तु के कई उदाहरण बनाने के लिए है।

http://www.c-sharpcorner.com/UploadFile/mokhtarb2005/FSWatcherMB12052005063103AM/FSWatcherMB.aspx

आप सुनिश्चित करें कि आप सही ढंग से दो फ़ोल्डरों के बीच की घटनाओं को संभाल करने के लिए होगा:

हालांकि कुछ सामान्य आवृत्तियां, इस तरह के नकल या एक फ़ाइल जाने के रूप में, अनुरूप नहीं सीधे एक घटना के लिए, इन घटनाएं घटनाओं को उठाती हैं। जब आप किसी फ़ाइल की प्रतिलिपि बनाते हैं, तो सिस्टम निर्देशिका में एक निर्मित ईवेंट उठाता है जिस पर फ़ाइल कॉपी की गई थी लेकिन मूल निर्देशिका में कोई भी ईवेंट नहीं उठाती है। जब आप फ़ाइल ले जाते हैं, तो सर्वर दो ईवेंट उठाता है: स्रोत निर्देशिका में 0 हटाया गया ईवेंट, लक्ष्य निर्देशिका में एक निर्मित ईवेंट के बाद।

उदाहरण के लिए, आप FileSystemWatcher के दो उदाहरण बनाते हैं। FileSystemWatcher1 "सी: \ मेरे दस्तावेज़" देखने के लिए सेट है, और FileSystemWatcher2 "सी: \ आपके दस्तावेज़" देखने के लिए सेट है। अब, यदि आप "मेरे दस्तावेज़" से "आपके दस्तावेज़" में एक फ़ाइल कॉपी करते हैं, तो एक निर्मित ईवेंट फ़ाइलसिस्टम वाटर 2 द्वारा उठाया जाएगा, लेकिन ईवेंट फ़ाइलसिस्टम वाटर 1 के लिए उठाया गया है। प्रतिलिपि के विपरीत, फ़ाइल या निर्देशिका को स्थानांतरित करने से दो ईवेंट बढ़ेगा। पिछले उदाहरण से, यदि आप "मेरे दस्तावेज़" से एक फ़ाइल ले जाया करने के लिए "आपका दस्तावेज़", एक बनाया गया ईवेंट FileSystemWatcher2 द्वारा उठाए किया जाएगा और एक इवेंट हटा दिया गया FileSystemWatcher

द्वारा

लिंक उठाया जाना होगा FileSystemEventArgs

Answer 4

बॉक्स से बाहर करने के लिए, FileSystemWatcher केवल एक ही मूल निर्देशिका की निगरानी का समर्थन करता है। एकाधिक भाई निर्देशिकाओं की निगरानी करने के लिए, आपको FileSystemWatcher के कई उदाहरण बनाना होगा।

आप FileSystemWatcher के उपनिर्देशिका शामिल करने की क्षमता का लाभ उठाते हुए इस व्यवहार को धोखा दे रहा कोशिश कर सकते हैं, हालांकि,। आप जिस निर्देशिका को देख रहे हैं उससे उपनिर्देशिका के रूप में आप एनटीएफएस जंक्शन पॉइंट (उर्फ प्रतीकात्मक लिंक) बना सकते हैं। Sysinternals प्रसिद्धि के मार्क Russinovich symlinks के निर्माण और प्रबंधन को सरल बनाने के लिए Junction नामक एक उपयोगिता है।

ध्यान दें कि आप केवल अपनी स्थानीय मशीन पर निर्देशिकाओं के लिए सिम्लिंक बना सकते हैं।

Answer 5

आपको FileSystemWatcher ऑब्जेक्ट के कई उदाहरणों को तुरंत चालू करना होगा। यद्यपि आप ईवेंट को उसी विधि से जोड़ सकते हैं और प्रेषक ऑब्जेक्ट का उपयोग यह निर्धारित करने के लिए कर सकते हैं कि FileSystemWatcher ने ईवेंट को ट्रिगर किया था।

 var fsw1 = new FileSystemWatcher(); 
     var fsw2 = new FileSystemWatcher(); 
     FileSystemEventHandler fsw_changed = delegate(object sender, FileSystemEventArgs e) 
     { 
      Console.WriteLine("{0} - {1}", (sender as FileSystemWatcher).Path, e.ChangeType); 
     }; 
     fsw1.Changed += fsw_changed; 
     fsw2.Changed += fsw_changed; 

Answer 6

हैं या अपने डोमेन इस में की तरह देखा की एक निश्चित सीमा को चिह्नित करने में कोड पथ पारित कर सकते हैं,:

multiple monitor link

आशा है कि यह मदद करता है।

Answer 7

हालांकि यह एक पुराना प्रश्न है, मैंने जवाब देने का फैसला किया, क्योंकि मुझे कहीं भी अच्छा जवाब नहीं मिला।

तो, लक्ष्य FileSystemWatcher का उपयोग कर एकाधिक फ़ोल्डर्स (उपनिर्देशिका नहीं) की निगरानी करना था? यहाँ मेरी सुझाव है:

using System; 
using System.IO; 
using System.Security.Permissions; 
using System.Collections.Generic; 

namespace MultiWatcher 
// ConsoleApplication, which monitors TXT-files in multiple folders. 
// Inspired by: 
// http://msdn.microsoft.com/en-us/library/system.io.filesystemeventargs(v=vs.100).aspx 

{ 
    public class Watchers 
    { 
     public static void Main() 
     { 
      Run(); 

     } 

     [PermissionSet(SecurityAction.Demand, Name = "FullTrust")] 
     public static void Run() 
     { 
      string[] args = System.Environment.GetCommandLineArgs(); 

      // If a directory is not specified, exit program. 
      if (args.Length < 2) 
      { 
       // Display the proper way to call the program. 
       Console.WriteLine("Usage: Watcher.exe PATH [...] [PATH]"; 
       return; 
      } 
      List<string> list = new List<string>(); 
      for (int i = 1; i < args.Length; i++) 
      { 
       list.Add(args[i]); 
      } 
      foreach (string my_path in list) 
      { 
       Watch(my_path); 
      } 

      // Wait for the user to quit the program. 
      Console.WriteLine("Press \'q\' to quit the sample."); 
      while (Console.Read() != 'q') ; 
     } 
     private static void Watch(string watch_folder) 
     { 
      // Create a new FileSystemWatcher and set its properties. 
      FileSystemWatcher watcher = new FileSystemWatcher(); 
      watcher.Path = watch_folder; 
      /* 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; 
      // Only watch text files. 
      watcher.Filter = "*.txt"; 

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

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

     private static void OnRenamed(object source, RenamedEventArgs e) 
     { 
      // Specify what is done when a file is renamed. 
      Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath); 
     } 
    } 
}