Skip to content
TheChatArchiveThe Chat Archive
gpt-4-1106-preview· openaiHugging Face Suzhen/CodeChat

fais une classe c# qui prend en paramètre un string d'un chemin vers un dossier/fichier…

  1. User

    fais une classe c# qui prend en paramètre un string d'un chemin vers un dossier/fichier et qui étends Thread pour se lancer en parallèle et qui affiche un message dans la console à chaque fois qu'il y a des modifications dans le dossier/fichier en question

  2. Assistant

    Pour créer une classe en C# qui s'exécute sur un fil d'exécution séparé en surveillant les modifications dans un chemin de fichier ou de dossier donné, nous n'étendons pas la classe Thread mais utilisons plutôt la classe FileSystemWatcher avec la synchronisation de Threads via par exemple la classe Task. Voici un exemple de code qui montre comment vous pourriez faire cela :

    using System;
    using System.IO;
    using System.Threading.Tasks;
    
    public class DirectoryWatcher
    {
        private readonly string _path;
        private FileSystemWatcher _watcher;
        
        public DirectoryWatcher(string path)
        {
            _path = path;
        }
        
        public void StartWatching()
        {
            // Création d'une nouvelle tâche pour surveiller dans un fil séparé
            Task.Factory.StartNew(() =>
            {
                // Création du surveillance de système de fichier
                _watcher = new FileSystemWatcher(_path)
                {
                    NotifyFilter = NotifyFilters.LastAccess
                                 | NotifyFilters.LastWrite
                                 | NotifyFilters.FileName
                                 | NotifyFilters.DirectoryName
                };
                
                // Abonnement aux événements du FileSystemWatcher
                _watcher.Changed += OnChanged;
                _watcher.Created += OnChanged;
                _watcher.Deleted += OnChanged;
                _watcher.Renamed += OnRenamed;
                _watcher.Error += OnError;
                
                // Activer le surveillance
                _watcher.EnableRaisingEvents = true;
                
                // Pour garder la tâche active
                try
                {
                    // Ceci bloque le thread jusqu'à ce que le watcher soit disposé.
                    Task.Delay(-1).Wait();
                }
                catch (TaskCanceledException)
                {
                    // La tâche a été annulée, donc on termine le fil d'exécution
                }
            });
        }
        
        private void OnChanged(object sender, FileSystemEventArgs e)
        {
            Console.WriteLine($"File: {e.FullPath} {e.ChangeType}");
        }
    
        private void OnRenamed(object sender, RenamedEventArgs e)
        {
            Console.WriteLine($"File: {e.OldFullPath} renamed to {e.FullPath}");
        }
    
        private void OnError(object sender, ErrorEventArgs e)
        {
            Console.Error.WriteLine($"Watcher error: {e.GetException()}");
        }
    
        public void StopWatching()
        {
            _watcher?.Dispose();
        }
    }
    
    // Utilisation de la classe
    public class Program
    {
        public static void Main(string[] args)
        {
            string path = @"C:\path\to\directory"; // remplacer par le chemin souhaité
            
            DirectoryWatcher watcher = new DirectoryWatcher(path);
            watcher.StartWatching();
            
            Console.WriteLine("Press enter to exit...");
            Console.ReadLine();
            
            watcher.StopWatching();
        }
    }
    

    Dans cet exemple :

    • DirectoryWatcher est une classe qui encapsule le FileSystemWatcher.
    • Lorsque vous créez une instance de DirectoryWatcher et appelez StartWatching(), elle lance un FileSystemWatcher dans une nouvelle tâche qui surveille les changements du dossier ou fichier spécifié.
    • Les événements Changed, Created, Deleted, et Renamed du FileSystemWatcher sont attachés à des gestionnaires qui impriment des informations sur la console.
    • La méthode StopWatching() peut être appelée pour arrêter la surveillance.

    La classe Program montre un exemple simplifié de la façon dont vous pourriez utiliser DirectoryWatcher. Vous devez ajuster le chemin dans la variable path pour qu'il pointe vers le dossier ou fichier que vous voulez surveiller.

    Remarque : Utilisez la méthode StopWatching pour libérer le FileSystemWatcher et les ressources du fil d'exécution associé lorsque vous avez terminé.