FileSystem Watcher 간단 사용

26119 단어 Watcher
여기 서 폴 더 아래 에서 모니터링 하 는 예 를 봅 니 다.
우선 MSDN 에 있 는 비고 정 보 를 살 펴 보 겠 습 니 다.여기 주소:http://msdn.microsoft.com/zh-cn/library/system.io.filesystemwatcher.aspx
쓰다 FileSystemWatcher 지정 한 디 렉 터 리 의 변경 사항 을 감시 합 니 다.지정 한 디 렉 터 리 의 파일 이나 하위 디 렉 터 리 의 변경 을 감시 할 수 있 습 니 다.로 컬 컴퓨터, 네트워크 드라이브, 원 격 컴퓨터 의 파일 을 감시 하 는 구성 요 소 를 만 들 수 있 습 니 다.
모든 파일 의 변경 사항 을 감시 하려 면  Filter  속성 을 빈 문자열 (") 로 설정 하거나 마스크 (" *. * ") 를 사용 합 니 다.특정 파일 을 감시 하려 면  Filter  속성 을 이 파일 이름 으로 설정 합 니 다.예 를 들 어 파일 MyDoc. txt 의 변경 사항 을 감시 하려 면  Filter  속성 을 "MyDoc. txt" 로 설정 합 니 다.특정 유형의 파일 의 변경 도 감시 할 수 있다.예 를 들 어 텍스트 파일 의 변경 사항 을 감시 하려 면  Filter  속성 을 "*. txt" 로 설정 합 니 다.
디 렉 터 리 나 파일 의 변경 사항 을 감시 할 수 있 습 니 다.예 를 들 어 파일 이나 디 렉 터 리 를 감시 할 수 있 는 Attributes、LastWrite 날짜 와 시간 또는 Size 방면 의 변경.통과 장  NotifyFilter  속성  NotifyFilters  값 의 하나 로 이 목적 을 달성 하 다.감시 가능 한 변경 유형 에 대한 더 많은 정 보 는 참고 하 시기 바 랍 니 다.  NotifyFilters
파일 이나 디 렉 터 리 의 이름 바 꾸 기, 삭제, 생 성 을 감시 할 수 있 습 니 다.예 를 들 어 텍스트 파일 의 이름 을 바 꾸 는 것 을 감시 하려 면  Filter  속성 을 "*. txt" 로 설정 하고 매개 변수 로 지정 한 것 을 사용 합 니 다.  Renamed  호출  WaitForChanged  방법
윈도 운영 체제 FileSystemWatcher 만 든 버퍼 에서 구성 요소 파일 이 변경 되 었 음 을 알 립 니 다.짧 은 시간 안에 많은 변경 사항 이 있 으 면 버퍼 가 넘 칠 수 있 습 니 다.이것 은 구성 요소 가 디 렉 터 리 변경 에 대한 추적 을 잃 게 하고 일반적인 알림 만 제공 합 니 다.버퍼 크기 와  InternalBufferSize  속성 은 비용 이 비 싼 것 입 니 다. 디스크 로 교환 할 수 없 는 호출 되 지 않 은 메모리 가 있 을 때 버퍼 가 작 고 파일 변경 이벤트 가 부족 하지 않 습 니 다.버퍼 가 넘 치지 않도록 사용 하 십시오.  NotifyFilter  화해시키다  IncludeSubdirectories  원 하지 않 는 변경 알림 을 선택 할 수 있 도록 속성 입 니 다.
관련되다 FileSystemWatcher 인 스 턴 스 의 초기 속성 값 목록 을 참조 하 십시오.  FileSystemWatcher  구조 함수.
쓰다 FileSystemWatcher 유사 시 아래 사항 에 주의 하 시기 바 랍 니 다.
  • 숨겨 진 파일 을 무시 하지 않 습 니 다.
  • 일부 시스템 에서 FileSystem Watcher 8.3 짧 은 파일 이름 형식 으로 파일 변경 을 보고 합 니 다.예 를 들 어 'LongFileName. LongExtension' 으로 변경 하면 'LongFil ~. Lon' 으로 보고 할 수 있다.
  • 모든 구성원 에 게 적용 되 는 클래스 에 링크 요구 와 계승 요 구 를 포함 합 니 다.직접 호출 자 나 파생 류 가 완전한 신뢰 권한 을 가지 지 않 으 면  SecurityException 。안전 요구 에 관 한 상세 한 정 보 는 참고 하 시기 바 랍 니 다.  연결 요구 사항
  •   InternalBufferSize  속성 (네트워크 에 있 는 디 렉 터 리 감시 용) 설정 의 최대 크기 는 64KB 입 니 다.

  •    여기 서 스스로 공식 과 결합 하여 예 를 하나 썼 는데, 안에 틀림없이 많은 것들 이 생각 하지 못 했 을 것 이다. 여러분 의 지적 을 환영 합 니 다.
     
     
      1  class Program
    
      2     {
    
      3        private static  FileSystemWatcher watcher;
    
      4        private static string logDir = (AppDomain.CurrentDomain.BaseDirectory); //get current project bin dir
    
      5        private static string logFile = "Log";
    
      6        private static string sMonitorDir = @"D:\TDDOWNLOAD";
    
      7        private static string LogExt = "log";  // file suffix
    
      8 
    
      9         static void Main(string[] args)
    
     10         {
    
     11             Run();
    
     12         }
    
     13         [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
    
     14         public static void Run()
    
     15         {
    
     16             watcher = new FileSystemWatcher();
    
     17 
    
     18             //         ,        
    
     19             DirectoryInfo di = new DirectoryInfo(sMonitorDir);
    
     20             if (!di.Exists)
    
     21             {
    
     22                 di.Create();
    
     23             }
    
     24             watcher.Path = sMonitorDir;
    
     25             //
    
     26             watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.DirectoryName
    
     27                 | NotifyFilters.LastAccess | NotifyFilters.LastWrite;
    
     28             watcher.IncludeSubdirectories = true; //       
    
     29             watcher.Filter = "*.txt";
    
     30 
    
     31             watcher.Changed += new FileSystemEventHandler(OnChanged);
    
     32             watcher.Created += new FileSystemEventHandler(OnChanged);
    
     33             watcher.Deleted += new FileSystemEventHandler(OnChanged);
    
     34             watcher.Renamed += new RenamedEventHandler(OnRenamed);
    
     35             watcher.Error += new ErrorEventHandler(OnError);
    
     36 
    
     37             watcher.EnableRaisingEvents = true;
    
     38 
    
     39             Console.Read();
    
     40         }
    
     41 
    
     42         //changeed,deleted,created.
    
     43         static void OnChanged(object sender, FileSystemEventArgs e)
    
     44         {
    
     45             //  EnableRaisingEvents   false             true          。
    
     46             watcher.EnableRaisingEvents = false;
    
     47             //WatcherChangeTypes     
    
     48             if (WatcherChangeTypes.Changed == e.ChangeType)
    
     49             {
    
     50                 Console.WriteLine("File is changed");
    
     51             }
    
     52             if (WatcherChangeTypes.Created == e.ChangeType)
    
     53             {
    
     54                 Console.WriteLine("File is Created");
    
     55             }
    
     56             if (WatcherChangeTypes.Deleted == e.ChangeType)
    
     57             {
    
     58                 Console.WriteLine("File is deleted");
    
     59             }
    
     60             Console.WriteLine("File: " + e.FullPath + " " + e.ChangeType);
    
     61             WriteFile("File: " + e.FullPath + " " + e.ChangeType);
    
     62             watcher.EnableRaisingEvents = true;
    
     63         }
    
     64 
    
     65         //renamed event
    
     66         private static void OnRenamed(object source, RenamedEventArgs e)
    
     67         {
    
     68             watcher.EnableRaisingEvents = false;
    
     69             if (WatcherChangeTypes.Renamed == e.ChangeType)
    
     70             {
    
     71                 Console.WriteLine("File is renamed");                
    
     72 
    
     73             }
    
     74             Console.WriteLine("File: {0} renamed to {1}", e.OldFullPath, e.FullPath);
    
     75             WriteFile("File: " + e.FullPath + " " + e.ChangeType);
    
     76             watcher.EnableRaisingEvents = true;
    
     77         
    
     78         }
    
     79         private static void OnError(object source, ErrorEventArgs e)
    
     80         {
    
     81             Console.WriteLine("The FileSystemWatcher has detected an error");
    
     82 
    
     83             if (e.GetException().GetType() == typeof(InternalBufferOverflowException))
    
     84             {
    
     85                 Console.WriteLine(("The file system watcher experienced an internal buffer overflow: " + e.GetException().Message));
    
     86                 WriteFile(("The file system watcher experienced an internal buffer overflow: " + e.GetException().Message));
    
     87             }
    
     88         }
    
     89         //write the message to file
    
     90         private static void WriteFile(string sMessage)
    
     91         {
    
     92             try
    
     93             {
    
     94                 Log logEntry = new Log(sMessage);
    
     95                 string logPath = Path.Combine(logDir, logFile, logEntry.LogDate + "." + LogExt);
    
     96                 if ((logPath.Length > 0) && (!Directory.Exists(logPath)))
    
     97                 {
    
     98                     Directory.CreateDirectory(Path.GetDirectoryName(logPath));
    
     99                 }
    
    100                 // This could be optimised to prevent opening and closing the file for each write
    
    101                 using (FileStream fs = File.Open(logPath, FileMode.Append, FileAccess.Write))
    
    102                 {
    
    103                     using (StreamWriter log = new StreamWriter(fs))
    
    104                     {
    
    105                         log.WriteLine(string.Format("{0}\t{1}", logEntry.LogTime, logEntry.Message));
    
    106                     }
    
    107                 }
    
    108             }
    
    109             catch (Exception ex)
    
    110             {
    
    111                 throw ex;
    
    112             }
    
    113         }
    
    114     }
    
    115     /// <summary>
    
    116     /// A Log class to store the message and the Date and Time the log entry was created
    
    117     /// </summary>
    
    118     public class Log
    
    119     {
    
    120         public string Message { get; set; }
    
    121         public string LogTime { get; set; }
    
    122         public string LogDate { get; set; }
    
    123         public string LogFileName { get; set; }
    
    124         public Log(string message)
    
    125         {
    
    126             Message = message;
    
    127             DateTime curDT = DateTime.Now;
    
    128             LogDate = curDT.ToString("yyyy-MM-dd");
    
    129             LogTime = curDT.ToString("hh:mm:ss.fff tt");
    
    130             LogFileName = curDT.ToString("yyyyMMddhhmmssfff");
    
    131         }
    
    132     }

     

    좋은 웹페이지 즐겨찾기