VC++ 监控指定目录改变

 1 // .h文件
 2 #pragma once
 3 
 4 typedef void (*PFN_NotifyAction)(DWORD dwAction, LPWSTR szFile, DWORD dwLength);
 5 
 6 class CDirectoryWatch
 7 {
 8 public:
 9     CDirectoryWatch(void);
10     virtual ~CDirectoryWatch(void);
11 
12 public:
13     BOOL StartDirectoryWatch(LPCTSTR lpszDirectory, PFN_NotifyAction pFn_NotifyAction);
14     BOOL StopDirectoryWatch(void);
15 
16 private:
17     static UINT __cdecl ThreadProc(LPVOID lParam);
18     static UINT __cdecl DirectoryWatch(LPVOID lParam);
19 
20 private:
21     HANDLE m_hFile;
22     CWinThread* m_pThread;
23     TCHAR m_szDirectory[MAX_PATH];
24 };

  1 // .cpp文件
  2 #include "StdAfx.h"
  3 #include "DirectoryWatch.h"
  4 #include <strsafe.h>
  5 
  6 typedef enum
  7 {
  8     MSG_STARTWATCH = (WM_USER + 0x11),
  9     MSG_STOPWATCH,
 10     MSG_EXITTHREAD
 11 };
 12 
 13 #define MAX_BUFFER_SIZE    (1024)
 14 
 15 typedef struct _tagWATCHPARAMETERS
 16 {
 17     _tagWATCHPARAMETERS()
 18     {
 19         hFile = INVALID_HANDLE_VALUE;
 20         hEvent = NULL;
 21         memset(&ol, 0, sizeof(OVERLAPPED));
 22         pBuffer = NULL;
 23         dwBufferSize = 0;
 24         bExit = FALSE;
 25         pFn_NotifyAction = NULL;
 26     }
 27     HANDLE hFile;
 28     HANDLE hEvent;
 29     OVERLAPPED ol;
 30     BYTE* pBuffer;
 31     DWORD dwBufferSize;
 32     BOOL bExit;
 33     PFN_NotifyAction pFn_NotifyAction;
 34 }WATCH_PARAMETERS, *PWATCH_PARAMETERS;
 35 
 36 CDirectoryWatch::CDirectoryWatch() : m_hFile(INVALID_HANDLE_VALUE), m_pThread(NULL)
 37 {
 38     memset(m_szDirectory, 0, sizeof(m_szDirectory));
 39 
 40     m_pThread = AfxBeginThread(ThreadProc, NULL, 0, CREATE_SUSPENDED, 0, NULL);
 41     if(NULL == m_pThread)
 42     {
 43         TRACE("Error Code : %d\n", GetLastError());
 44         return ;
 45     }
 46     m_pThread->m_bAutoDelete = FALSE;
 47     m_pThread->ResumeThread();
 48 }
 49 
 50 
 51 CDirectoryWatch::~CDirectoryWatch()
 52 {
 53     if(INVALID_HANDLE_VALUE != m_hFile)
 54     {
 55         CloseHandle(m_hFile);
 56         m_hFile = INVALID_HANDLE_VALUE;
 57     }
 58 
 59     if((NULL != m_pThread) && (NULL != m_pThread->m_hThread))
 60     {
 61 
 62         m_pThread->PostThreadMessage(MSG_EXITTHREAD, 0, 0);
 63         WaitForSingleObject(m_pThread->m_hThread, INFINITE);
 64         delete m_pThread;
 65         m_pThread = NULL;
 66     }
 67 }
 68 
 69 BOOL CDirectoryWatch::StartDirectoryWatch(LPCTSTR lpszDirectory, PFN_NotifyAction pFn_NotifyAction)
 70 {
 71     if(NULL == m_pThread)
 72     {
 73         return FALSE;
 74     }
 75 
 76     if(NULL == lpszDirectory)
 77     {
 78         return FALSE;
 79     }
 80 
 81     if(NULL == pFn_NotifyAction)
 82     {
 83         return FALSE;
 84     }
 85 
 86     if(!PathFileExists(lpszDirectory))
 87     {
 88         TRACE("Error Code : %d\n", GetLastError());
 89         return FALSE;
 90     }
 91 
 92     if(!PathIsDirectory(lpszDirectory))
 93     {
 94         TRACE("Error Code : %d\n", GetLastError());
 95         return FALSE;
 96     }
 97 
 98     if(0 == _tcslen(m_szDirectory))
 99     {
100         StringCchPrintf(m_szDirectory, _countof(m_szDirectory), _T("%s"), lpszDirectory);
101     }
102     else if(CSTR_EQUAL != CompareStringOrdinal(m_szDirectory, -1, lpszDirectory, -1, TRUE))
103     {
104         TRACE("Not Change Directory.\n");
105         return FALSE;
106     }
107 
108     if(INVALID_HANDLE_VALUE == m_hFile)
109     {
110         m_hFile = CreateFile(lpszDirectory, FILE_LIST_DIRECTORY, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
111             NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED, NULL);
112         if(INVALID_HANDLE_VALUE == m_hFile)
113         {
114             TRACE("Error Code : %d\n", GetLastError());
115             return FALSE;
116         }
117     }
118 
119     return m_pThread->PostThreadMessage(MSG_STARTWATCH, (WPARAM)m_hFile, (LPARAM)pFn_NotifyAction);
120 }
121 
122 BOOL CDirectoryWatch::StopDirectoryWatch()
123 {
124     if(NULL != m_pThread)
125     {
126         return m_pThread->PostThreadMessage(MSG_STOPWATCH, 0, 0);
127     }
128 
129     return FALSE;
130 }
131 
132 UINT __cdecl CDirectoryWatch::DirectoryWatch(LPVOID lParam)
133 {
134     WATCH_PARAMETERS* pParam = (WATCH_PARAMETERS*)lParam;
135     if(NULL == pParam)
136     {
137         return 0;
138     }
139     HANDLE& hFile = pParam->hFile;
140     BYTE* pBuffer = pParam->pBuffer;
141     DWORD dwBufferSize = pParam->dwBufferSize;
142     OVERLAPPED& ol = pParam->ol;
143     HANDLE& hEvent = pParam->hEvent;
144     BOOL& bExit = pParam->bExit;
145     PFN_NotifyAction pFn_NotifyAction = pParam->pFn_NotifyAction;
146     DWORD dwBytesReturn = 0;
147     DWORD dwRet = WAIT_FAILED;
148     DWORD dwOffSet = 0;
149     TCHAR szFile[MAX_PATH] = {0};
150     while(TRUE)
151     {
152         if(WAIT_OBJECT_0 != WaitForSingleObject(hEvent, INFINITE))
153         {
154             TRACE("Error Code : %d\n", GetLastError());
155             break;
156         }
157 
158         if(bExit)
159         {
160             break;
161         }
162     
163         if(!ReadDirectoryChangesW(hFile, pBuffer, dwBufferSize, TRUE, 
164             FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_ATTRIBUTES
165             | FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_LAST_ACCESS
166             | FILE_NOTIFY_CHANGE_CREATION | FILE_NOTIFY_CHANGE_SECURITY, &dwBytesReturn, &ol, NULL))
167         {
168             TRACE("Error Code : %d\n", GetLastError());
169             break;
170         }
171         if(!GetOverlappedResult(hFile, &ol, &dwBytesReturn, TRUE))
172         {
173             TRACE("Error Code : %d\n", GetLastError());
174             break;
175         }
176         FILE_NOTIFY_INFORMATION* pFileNotify = (FILE_NOTIFY_INFORMATION*)pBuffer;
177         
178         do 
179         {
180             if(pFn_NotifyAction && (WAIT_OBJECT_0 == WaitForSingleObject(hEvent, 0)))
181             {
182                 pFn_NotifyAction(pFileNotify->Action, pFileNotify->FileName, (pFileNotify->FileNameLength) / sizeof(WCHAR));
183             }
184 
185             dwOffSet = pFileNotify->NextEntryOffset;
186             pFileNotify = (FILE_NOTIFY_INFORMATION*)((BYTE*)pFileNotify + dwOffSet);
187         } while (dwOffSet);
188     }
189     TRACE0("DirectoryWatch Thread Exit ... \n");
190     return 0;
191 }
192 
193 UINT __cdecl CDirectoryWatch::ThreadProc(LPVOID lParam)
194 {
195     WATCH_PARAMETERS* pParam = new WATCH_PARAMETERS;
196 
197     if(NULL == pParam)
198     {
199         goto __CLEANUP__;
200     }
201 
202     BYTE* pBuffer = new BYTE[MAX_BUFFER_SIZE];
203     if(NULL == pBuffer)
204     {
205         goto __CLEANUP__;
206     }
207     memset(pBuffer, 0, MAX_BUFFER_SIZE);
208     pParam->pBuffer = pBuffer;
209     pParam->dwBufferSize = MAX_BUFFER_SIZE;
210     HANDLE hWatchEvent  = CreateEvent(NULL, TRUE, FALSE, NULL);
211     if(NULL == hWatchEvent)
212     {
213         goto __CLEANUP__;
214     }
215     pParam->ol.hEvent = hWatchEvent;
216     CWinThread* pThread = NULL;
217     HANDLE hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
218     if(NULL == hEvent)
219     {
220         goto __CLEANUP__;
221     }
222     pParam->hEvent = hEvent;
223     MSG msg;
224     while(GetMessage(&msg, NULL, 0, 0))
225     {
226         switch(msg.message)
227         {
228         case MSG_STARTWATCH:
229             {
230                 HANDLE hFile = (HANDLE)(msg.wParam);
231                 PFN_NotifyAction pFn_NotifyAction = (PFN_NotifyAction)(msg.lParam);
232                 if((INVALID_HANDLE_VALUE == hFile) && (NULL == pFn_NotifyAction))
233                 {
234                     break;
235                 }
236                 if(NULL == pThread)
237                 {
238                     pParam->hFile = hFile;
239                     pParam->pFn_NotifyAction = pFn_NotifyAction;
240                     pThread = AfxBeginThread(DirectoryWatch, (LPVOID)pParam, 0, CREATE_SUSPENDED, NULL);
241                     if(NULL == pThread)
242                     {
243                         goto __CLEANUP__;
244                     }
245                     pThread->m_bAutoDelete = FALSE;
246                     pThread->ResumeThread();
247                 }                
248                 SetEvent(hEvent);
249             }
250             break;
251 
252         case MSG_STOPWATCH:
253             {
254                 ResetEvent(hEvent);
255             }
256             break;
257 
258         case MSG_EXITTHREAD:
259             {
260                 SetEvent(hEvent);
261                 pParam->bExit = FALSE;
262                 
263                 if((NULL != pThread) && (NULL != pThread->m_hThread))
264                 {
265                     WaitForSingleObject(pThread->m_hThread, INFINITE);
266                     delete pThread;
267                     pThread = NULL;
268                 }
269                 goto __CLEANUP__;
270             }
271             
272         default:
273             break;
274         }
275         TranslateMessage(&msg);
276         DispatchMessage(&msg);
277     }
278 
279 __CLEANUP__:
280     if(NULL != hWatchEvent)
281     {
282         CloseHandle(hWatchEvent);
283         hWatchEvent = NULL;
284     }
285     if(NULL != pBuffer)
286     {
287         delete[] pBuffer;
288         pBuffer = NULL;
289     }
290     if(NULL != pParam)
291     {
292         delete pParam;
293         pParam = NULL;
294     }
295     TRACE0("ThreadProc Thread Exit ...\n");
296     return 0;
297 }

 1 // 测试代码
 2 
 3 #include "stdafx.h"
 4 
 5 #include "DirectoryWatch.h"
 6 
 7 void NotifyAction(DWORD dwAction, LPWSTR szFile, DWORD dwLength)
 8 {
 9     switch(dwAction)
10     {
11     case FILE_ACTION_ADDED:
12         wprintf(L"FILE_ACTION_ADDED: \n\t");
13         break;
14 
15     case FILE_ACTION_REMOVED:
16         wprintf(L"FILE_ACTION_REMOVED: \n\t");
17         break;
18 
19     case FILE_ACTION_MODIFIED:
20         wprintf(L"FILE_ACTION_MODIFIED: \n\t");
21         break;
22 
23     case FILE_ACTION_RENAMED_OLD_NAME:
24         wprintf(L"FILE_ACTION_RENAMED_OLD_NAME: \n\t");
25         break;
26 
27     case FILE_ACTION_RENAMED_NEW_NAME:
28         wprintf(L"FILE_ACTION_RENAMED_NEW_NAME: \n\t");
29         break;
30 
31     default:
32         break;
33     }
34     WCHAR szPath[MAX_PATH] = {0};
35     wmemcpy(szPath, szFile, min(dwLength, MAX_PATH));
36     wprintf(L"%s\n", szPath);
37 }
38 
39 int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
40 {
41     CDirectoryWatch watch;
42     wprintf(L"Start Directory Watch ...\n");
43     watch.StartDirectoryWatch(_T("F:\\11"), NotifyAction);
44     Sleep(30 * 1000);    
45     watch.StopDirectoryWatch();
46     wprintf(L"Stop Directory Watch ...\n");
47 
48     Sleep(10 * 1000);
49 
50     wprintf(L"Start Directory Watch ...\n");
51     watch.StartDirectoryWatch(_T("F:\\11"), NotifyAction);
52     Sleep(30 * 1000);    
53     watch.StopDirectoryWatch();
54     wprintf(L"Stop Directory Watch ...\n");
55     Sleep(30 * 1000);
56     wprintf(L"Process Exit ...\n");
57     return 0;
58 }