1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:

using System;  
using System.Collections.Generic;  
using System.ComponentModel;  
using System.Data;  
using System.Diagnostics;  
using System.ServiceProcess;  
using System.Text;  
using System.IO;  
using System.Threading;  
using System.Collections.Specialized;  
using System.Reflection;  

 
namespace FileWatchService  
{  
   public partial class Service1 : ServiceBase  
   {  
      private Thread thread;  
      private string path = "";  

 

 
      public Service1()  
      {  
         InitializeComponent();  
      }  

 
      protected override void OnStart(string[] args)  
      {  
         if (args.Length != 0)  
            this.path = args[0];  
         Worker worker = new Worker(this.path);  
         thread = new Thread(new ThreadStart(worker.StartWorker));  
         thread.Start();  
         this.EventLog.WriteEntry("FileWatchService wurde erfolgreich gestartet");  
      }  

 
      protected override void OnStop()  
      {  
         thread.Abort();  
         thread = null;  
         this.EventLog.WriteEntry("FileWatchService wurde beendet");  
      }  

 
      protected override void OnPause()  
      {  
         thread.Suspend();  
         this.EventLog.WriteEntry("FileWatchService wurde angehalten");  
      }  

 
      protected override void OnContinue()  
      {  
         thread.Resume();  
         this.EventLog.WriteEntry("FileWatchService wurde fortgesetzt");  
      }  
   }  

 
   public class Worker  
   {  
      private string protocolFile = "C:\\Projekte\\FileWatchSystem\\FileWatchLog.log";  
      private string path = "C:\\";  

 
      // Konstruktor  
      public Worker(string path)  
      {  
         if (path != "")  
            this.path = path;  
      }  

 
      // Startmethode des Threads  
      public void StartWorker()  
      {  
         FileSystemWatcher fsw = new FileSystemWatcher(this.path);  

 
         // Überwachen aller Unterverzeichnisse einschließen  
         fsw.IncludeSubdirectories = true;  

 
         // Eventauslösung aktivieren  
         fsw.EnableRaisingEvents = true;  

 
         // Ereignishandler  
         fsw.Changed += new FileSystemEventHandler(ChangeFile);  
         fsw.Deleted += new FileSystemEventHandler(DeleteFile);  
         fsw.Created += new FileSystemEventHandler(CreateFile);  
         fsw.Renamed += new RenamedEventHandler(RenameFile);  

 
         try  
         {  
            // in dieser Schleife wird auf etwaige Änderungen im   
            // Dateisystem gewartet  
            while (true)  
            {  
               fsw.WaitForChanged(WatcherChangeTypes.All);  
            }  
         }  
         catch  
         {  
         }  

 
         // Eventauslösung deaktivieren  
         fsw.EnableRaisingEvents = false;  
      }  

 
      // Datei wurde umbenannt  
      private void RenameFile(object sender, RenamedEventArgs e)  
      {  
         string entry = "[" + DateTime.Now.ToShortTimeString() + "] "  
         + String.Format("Pfad: {0}; Datei umbenannt: von {1} nach {2}",  
         Path.GetDirectoryName(e.FullPath), e.OldName, e.Name);  
         WriteToLogFile(entry);  
      }  

 
      // Datei wurde neu erzeugt  
      private void CreateFile(object sender, FileSystemEventArgs e)  
      {  
         string entry = "[" + DateTime.Now.ToShortTimeString() + "] "  
         + String.Format("Pfad: {0}; Datei erstellt{1}",  
         Path.GetDirectoryName(e.FullPath), e.Name);  
         WriteToLogFile(entry);  
      }  

 
      // Datei wurde gelöscht  
      private void DeleteFile(object sender, FileSystemEventArgs e)  
      {  
         string entry = "[" + DateTime.Now.ToShortTimeString() + "]"  
         + String.Format("Pfad: {0}; Datei gelöscht: {1}",  
         Path.GetDirectoryName(e.FullPath), e.Name);  
         WriteToLogFile(entry);  
      }  

 
      // Datei wurde geändert  
      private void ChangeFile(object sender, FileSystemEventArgs e)  
      {  
         // wenn es sich bei der geänderten Datei um die Protokolldatei  
         // des Dienstes handelt, die Methode abbrechen  
         string pathChanged = e.FullPath.ToLower();  
         string pathProtocol = protocolFile.ToLower();  

 
         // Änderungen in der Protokolldatei nicht aufzeichnen  
         if (pathChanged == pathProtocol)  
            return;  
         string entry = "[" + DateTime.Now.ToShortTimeString() + "] "  
         + String.Format("Pfad: {0}; Datei geändert:{1}",  
         Path.GetDirectoryName(e.FullPath), e.Name);  
         WriteToLogFile(entry);  
      }  

 
      private StringCollection ReadFromLogFile()  
      {  
         StringCollection strCol = new StringCollection();  
         StreamReader sr = new StreamReader(this.protocolFile);  
         string line = "";  
         int count = 1;  

 
         while ((line = sr.ReadLine()) != null)  
         {  
            // maximal 999 Einträge lesen  
            if (count == 999)  
               break;  
            strCol.Add(line);  
            count++;  
         }  

 
         sr.Close();  
         return strCol;  
      }  

 
      // Schreibt eine Änderung in die Protokolldatei  
      private void WriteToLogFile(string entry)  
      {  
         StringCollection changedEntriesCol;  
         if (File.Exists(this.protocolFile))  
            changedEntriesCol = ReadFromLogFile();  
         else  
            changedEntriesCol = new StringCollection();  

 
         // neuen Eintrag an erster Stelle einfügen  
         changedEntriesCol.Insert(0, entry);  

 
         // Schreibt Einträge in eine Log-Datei, dabei neue Datei  
         // erzeugen oder alte überschreiben  
         FileStream fs = new FileStream(this.protocolFile, FileMode.Create);  
         StreamWriter sw = new StreamWriter(fs);  

 
         foreach (string str in changedEntriesCol)  
            sw.WriteLine(str);  
         sw.Close();  
      }  
   }  
}