Monitorowanie wielu folderów przy użyciu FileSystemWatcher

Question

Jaki jest najlepszy sposób monitorowania wielu folderów (nie podkatalogów) przy użyciu FileSystemWatcher w C#?

Answer 1

Nie sądzę, że FSW obsługuje monitorowanie wielu folderów, więc po prostu stwórz po jednym folderze, który chcesz monitorować. Możesz jednak wskazać procedury obsługi zdarzeń przy użyciu tych samych metod, co powinno zakończyć się tak, jak sądzę, że chcesz.

Answer 2

Czy można po prostu użyć wielu instancji FileSystemWatcher, po jednym dla każdego katalogu?

Answer 3

Najprostszym sposobem jest utworzenie wielu wystąpień obiektu FileSystemWatcher.

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

Musisz upewnić się, że można obsłużyć zdarzenia pomiędzy dwoma folderami poprawnie:

Chociaż pewne wspólne wystąpień, takich jak kopiowania lub przenoszenia pliku, nie odpowiadają bezpośrednio na wydarzenie, te wystąpienia powodują wzrost liczby zdarzeń o . Podczas kopiowania pliku, system podnosi zdarzenie utworzone w katalogu , do którego plik został skopiowany , ale nie powoduje żadnych zdarzeń w oryginalnym katalogu . Po przeniesieniu pliku serwer przenosi dwa zdarzenia: Usunięto zdarzenie w katalogu źródłowym, , a następnie zdarzenie Utworzono w katalogu docelowym .

Na przykład można utworzyć dwie instancje FileSystemWatcher. FileSystemWatcher1 jest ustawiony do oglądania "C: \ My Documents", a FileSystemWatcher2 jest ustawiony do oglądania "C: \ Twoje dokumenty". Teraz, jeśli skopiujesz plik z "Moje dokumenty" do "Twoich dokumentów ", zdarzenie Utworzono będzie wywołane przez FileSystemWatcher2, ale nie zostanie zgłoszone żadne zdarzenie dla FileSystemWatcher1. W przeciwieństwie do kopiowania, przeniesienie pliku lub katalogu spowodowałoby powstanie dwóch zdarzeń: . Z poprzedniego przykładu, jeśli przeniósł plik z „Moich Dokumenty” do „dokumentów”, czyli Utworzono wydarzenie zostanie podniesione przez FileSystemWatcher2 oraz Usunięto wydarzenie byłyby podnoszone przez FileSystemWatcher

link do FileSystemEventArgs

Answer 4

Po wyjęciu z pudełka FileSystemWatcher obsługuje tylko monitorowanie pojedynczego katalogu nadrzędnego. Aby monitorować wiele katalogów dla rodzeństwa, należy utworzyć wiele instancji FileSystemWatcher.

Możesz spróbować oszukać to zachowanie, korzystając z możliwości FileSystemWatcher do dołączania podkatalogów. Możesz utworzyć punkt połączenia NTFS (znany także jako dowiązanie symboliczne) jako podkatalog z oglądanego katalogu. Mark Russinovich ze sławy Sisinternals ma narzędzie o nazwie Junction, które upraszcza tworzenie i zarządzanie dowiązaniami symbolicznymi.

Pamiętaj, że możesz tworzyć dowiązania symboliczne tylko do katalogów na komputerze lokalnym.

Answer 5

Należy utworzyć instancje wielu wystąpień obiektu FileSystemWatcher. Mimo że można powiązać zdarzenia z tą samą metodą i użyć obiektu nadawcy do określenia, które FileSystemWatcher wyzwoliło zdarzenie.

 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

lub można przekazać ścieżki w-kodu, aby zaznaczyć pewien zakres domeny obserwował jak w tym:

multiple monitor link

nadzieję, że to pomaga.

Answer 7

Mimo że jest to stare pytanie, postanowiłem odpowiedzieć, ponieważ nigdzie nie mogłem znaleźć dobrej odpowiedzi.

Tak więc celem było monitorowanie wielu folderów (nie podkatalogów) za pomocą FileSystemWatcher? Oto moja propozycja:

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