基于 C# 的局域网计算机监控系统文件变更实时监测算法设计与实现研究

using System;
using System.IO;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Timers;
using Newtonsoft.Json;
namespace LocalNetworkMonitor
{
    public class FileMonitor
    {
        private readonly FileSystemWatcher _watcher;
        private readonly Dictionary<string, FileInfo> _monitoredFiles;
        private readonly Queue<FileChangeEvent> _eventQueue;
        private readonly System.Timers.Timer _batchTimer;
        private readonly string _serverEndpoint = "https://www.vipshare.com/api/filechanges";
        private const int BatchInterval = 5000; // 批处理间隔(毫秒)
        private const int MaxEventQueueSize = 1000;
        public FileMonitor(string path, string filter = "*.*")
        {
            if (!Directory.Exists(path))
                throw new DirectoryNotFoundException($"监控路径不存在: {path}");
            _monitoredFiles = new Dictionary<string, FileInfo>();
            _eventQueue = new Queue<FileChangeEvent>();
            // 初始化文件系统监控器
            _watcher = new FileSystemWatcher
            {
                Path = path,
                Filter = filter,
                NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite |
                               NotifyFilters.FileName | NotifyFilters.DirectoryName |
                               NotifyFilters.Size,
                IncludeSubdirectories = true,
                EnableRaisingEvents = true
            };
            // 注册事件处理程序
            _watcher.Changed += OnFileChanged;
            _watcher.Created += OnFileCreated;
            _watcher.Deleted += OnFileDeleted;
            _watcher.Renamed += OnFileRenamed;
            // 初始化批处理定时器
            _batchTimer = new System.Timers.Timer(BatchInterval);
            _batchTimer.Elapsed += OnBatchTimerElapsed;
            _batchTimer.AutoReset = true;
            _batchTimer.Enabled = true;
            // 初始扫描目录
            InitializeFileList(path);
        }
        private void InitializeFileList(string path)
        {
            try
            {
                foreach (var file in Directory.GetFiles(path))
                {
                    AddFileToMonitor(file);
                }
                foreach (var directory in Directory.GetDirectories(path))
                {
                    InitializeFileList(directory);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"初始化文件列表时出错: {ex.Message}");
            }
        }
        private void AddFileToMonitor(string filePath)
        {
            try
            {
                var fileInfo = new FileInfo(filePath);
                _monitoredFiles[filePath] = fileInfo;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"添加文件监控时出错: {filePath}, 错误: {ex.Message}");
            }
        }
        private void OnFileChanged(object sender, FileSystemEventArgs e)
        {
            EnqueueEvent(new FileChangeEvent
            {
                EventType = ChangeType.Changed,
                FilePath = e.FullPath,
                Timestamp = DateTime.Now
            });
        }
        private void OnFileCreated(object sender, FileSystemEventArgs e)
        {
            EnqueueEvent(new FileChangeEvent
            {
                EventType = ChangeType.Created,
                FilePath = e.FullPath,
                Timestamp = DateTime.Now
            });
            // 添加到监控列表
            AddFileToMonitor(e.FullPath);
        }
        private void OnFileDeleted(object sender, FileSystemEventArgs e)
        {
            EnqueueEvent(new FileChangeEvent
            {
                EventType = ChangeType.Deleted,
                FilePath = e.FullPath,
                Timestamp = DateTime.Now
            });
            // 从监控列表移除
            if (_monitoredFiles.ContainsKey(e.FullPath))
                _monitoredFiles.Remove(e.FullPath);
        }
        private void OnFileRenamed(object sender, RenamedEventArgs e)
        {
            EnqueueEvent(new FileChangeEvent
            {
                EventType = ChangeType.Renamed,
                FilePath = e.OldFullPath,
                NewFilePath = e.FullPath,
                Timestamp = DateTime.Now
            });
            // 更新监控列表
            if (_monitoredFiles.ContainsKey(e.OldFullPath))
            {
                _monitoredFiles.Remove(e.OldFullPath);
                AddFileToMonitor(e.FullPath);
            }
        }
        private void EnqueueEvent(FileChangeEvent evt)
        {
            lock (_eventQueue)
            {
                if (_eventQueue.Count >= MaxEventQueueSize)
                {
                    // 队列已满，移除最早的事件
                    _eventQueue.Dequeue();
                }
                _eventQueue.Enqueue(evt);
            }
        }
        private async void OnBatchTimerElapsed(object sender, ElapsedEventArgs e)
        {
            await ProcessEventBatch();
        }
        private async Task ProcessEventBatch()
        {
            List<FileChangeEvent> eventsToProcess = new List<FileChangeEvent>();
            lock (_eventQueue)
            {
                while (_eventQueue.Count > 0)
                {
                    eventsToProcess.Add(_eventQueue.Dequeue());
                }
            }
            if (eventsToProcess.Count > 0)
            {
                try
                {
                    // 序列化事件列表
                    var jsonPayload = JsonConvert.SerializeObject(eventsToProcess);
                    // 发送到监控服务器
                    await SendEventsToServer(jsonPayload);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"处理事件批次时出错: {ex.Message}");
                    // 处理失败，重新入队
                    lock (_eventQueue)
                    {
                        foreach (var evt in eventsToProcess)
                        {
                            _eventQueue.Enqueue(evt);
                        }
                    }
                }
            }
        }
        private async Task SendEventsToServer(string jsonPayload)
        {
            using (var client = new System.Net.Http.HttpClient())
            {
                var content = new System.Net.Http.StringContent(jsonPayload,
                    System.Text.Encoding.UTF8, "application/json");
                var response = await client.PostAsync(_serverEndpoint, content);
                if (!response.IsSuccessStatusCode)
                {
                    throw new Exception($"发送事件到服务器失败，状态码: {response.StatusCode}");
                }
            }
        }
        public void Start()
        {
            _watcher.EnableRaisingEvents = true;
            _batchTimer.Enabled = true;
            Console.WriteLine("文件监控已启动");
        }
        public void Stop()
        {
            _watcher.EnableRaisingEvents = false;
            _batchTimer.Enabled = false;
            Console.WriteLine("文件监控已停止");
        }
        public void Dispose()
        {
            Stop();
            _watcher.Dispose();
            _batchTimer.Dispose();
        }
    }
    public enum ChangeType
    {
        Created,
        Changed,
        Deleted,
        Renamed
    }
    public class FileChangeEvent
    {
        public ChangeType EventType { get; set; }
        public string FilePath { get; set; }
        public string NewFilePath { get; set; }
        public DateTime Timestamp { get; set; }
    }
}

using System;
using System.Threading;
namespace LocalNetworkMonitor
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("局域网电脑监控软件 - 文件变更监控系统");
            Console.WriteLine("======================================");
            string monitorPath = @"C:\MonitoringDirectory";
            if (args.Length > 0 && Directory.Exists(args[0]))
            {
                monitorPath = args[0];
            }
            try
            {
                using (var monitor = new FileMonitor(monitorPath))
                {
                    monitor.Start();
                    Console.WriteLine($"正在监控目录: {monitorPath}");
                    Console.WriteLine("按 Q 键退出...");
                    while (Console.ReadKey(true).Key != ConsoleKey.Q)
                    {
                        Thread.Sleep(100);
                    }
                    monitor.Stop();
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"程序运行出错: {ex.Message}");
            }
        }
    }
}