Surveillance d'un répertoire pour une nouvelle création de fichier sans fichiersSystemwatcher

au démarrage du programme, utilisez Directory.getFiles (Chemin) pour obtenir la liste des fichiers.

Créez ensuite une minuterie et dans son appel d'événement écoulé, appelez-vous: p>

    static IEnumerable<string> hasNewFiles(string path, List<string> lastKnownFiles)
    {
        return from f in Directory.GetFiles(path) 
               where !lastKnownFiles.Contains(f) 
               select f;
    }

    List<string> newFiles = hasNewFiles(path, lastKnownFiles); 
    if (newFiles.Count() > 0) 
    { 
        processFiles(newFiles); 
        lastKnownFiles = newFiles; 
    } 

Oui, vous pouvez créer une minuterie et brancher un gestionnaire dans l'événement écoulé qui instancera une classe DIRITERIFO pour le répertoire que vous observez et appelle des getfiles () ou énuméraires (). GetFiles () renvoie un tableau FILEInfo [], tandis que EnumateFiles () renvoie un "streaming" ienumerable. EnuméèrentFiles () sera plus efficace si vous vous attendez à ce que beaucoup de fichiers soient dans ce dossier lorsque vous regardez; Vous pouvez commencer à travailler avec l'iEnumerable avant que la méthode ait récupéré tous les fichiersInfos, tandis que GetFiles vous fera attendre.

Pourquoi cela peut en réalité être meilleur que FileWatcher, cela dépend de l'architecture des coulisses. Prenons, par exemple, un extrait de base / transformer / valider / charger le flux de travail. Premièrement, un tel flux de travail peut avoir à créer des instances coûteuses d'objets (connexions DB, des instances d'un moteur de règles, etc.). Cette surcharge ponctuelle est considérablement atténuée si le flux de travail est structuré de gérer tout ce qui est disponible en une seule fois. Deuxièmement, FileWatcher nécessiterait tout appelé par les gestionnaires d'événements, tels que ce flux de travail, pour être thread-coffre-fort, car de nombreux événements peuvent être en cours d'exécution à la fois si les fichiers s'écoulent constamment. Si cela n'est pas réalisable, une minuterie peut être très facilement configurée. Pour limiter le système à un flux de travail en cours d'exécution, en passant par les manutentionnaires d'événements, examinez un drapeau «processus de fonctionnement du processus» de thread-coffre-fort et vous terminez simplement si un autre fil de gestionnaire a défini et non encore terminé. Les fichiers du dossier à cette époque seront choisis la prochaine fois que la minuterie incendie, contrairement à FileWatcher, où si vous terminez le gestionnaire, les informations sur l'existence de ce fichier sont perdues.

Utilisation de la réponse de @ Petoj J'ai inclus un service Windows complet qui interroge toutes les cinq minutes pour les nouveaux fichiers. Son contraind n'est donc que seul un scrutin de thread, représente le temps de traitement et les supports de pause et une interruption en temps voulu. Il prend également en charge la fixation facile d'un debbugger sur System.Start

 public partial class Service : ServiceBase{


    List<string> fileList = new List<string>();

    System.Timers.Timer timer;


    public Service()
    {
        timer = new System.Timers.Timer();
        //When autoreset is True there are reentrancy problems.
        timer.AutoReset = false;

        timer.Elapsed += new System.Timers.ElapsedEventHandler(DoStuff);
    }


    private void DoStuff(object sender, System.Timers.ElapsedEventArgs e)
    {
       LastChecked = DateTime.Now;

       string[] files = System.IO.Directory.GetFiles("c:\\", "*", System.IO.SearchOption.AllDirectories);

       foreach (string file in files)
       {
           if (!fileList.Contains(file))
           {
               fileList.Add(file);

               do_some_processing();
           }
       }


       TimeSpan ts = DateTime.Now.Subtract(LastChecked);
       TimeSpan MaxWaitTime = TimeSpan.FromMinutes(5);

       if (MaxWaitTime.Subtract(ts).CompareTo(TimeSpan.Zero) > -1)
           timer.Interval = MaxWaitTime.Subtract(ts).TotalMilliseconds;
       else
           timer.Interval = 1;

       timer.Start();
    }

    protected override void OnPause()
    {
        base.OnPause();
        this.timer.Stop();
    }

    protected override void OnContinue()
    {
        base.OnContinue();
        this.timer.Interval = 1;
        this.timer.Start();
    }

    protected override void OnStop()
    {
        base.OnStop();
        this.timer.Stop();
    }

    protected override void OnStart(string[] args)
    {
       foreach (string arg in args)
       {
           if (arg == "DEBUG_SERVICE")
                   DebugMode();

       }

        #if DEBUG
            DebugMode();
        #endif

        timer.Interval = 1;
        timer.Start();
   }

   private static void DebugMode()
   {
       Debugger.Break();
   }

 }