Bonjour,

J'ai un problème avec les timers sur une application console en C#.

J'ai un timer qui regarde tout les 20 secondes si un fichier est arrivé dans une liste, et si un fichier est arrivé alors on le copie dans un nouveau dossier.

Tout ce passe bien si la liste est vide, la fonction du timer m'affiche juste 'qu'il n'y a aucun fichier à traiter.

Par contre si un ou plusieurs fichiers sont présent dans la liste, le traitement des fichiers fonctionne, et tout de suite après l'application ce ferme...

Avez-vous une idée du problème ?

Voici mon code:

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

namespace test_code_service
{
    class Program
    {

        static void Main(string[] args)
        {
            GestionFichier gestionfichier = new GestionFichier();

            //début de la surveillance des fichiers
            gestionfichier.observateur();

            while(Console.ReadLine() != "q");
        }


    }
}

GestionFichiers.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Threading;
using System.Configuration;


namespace test_code_service
{
    class GestionFichier
    {
        private List<Fichier> ListFichier;
        private Timer processusCopie;
        private string newDossier;
        private string oldDossier;
        private string path;
        private bool ftpActive;
        private string ftpRegex;


        /// <summary>
        /// Constructeur
        /// </summary>
        public GestionFichier()
        {
            this.ListFichier = new List<Fichier>();
            this.newDossier = ConfigurationSettings.AppSettings["newDossier"];
            this.oldDossier = ConfigurationSettings.AppSettings["oldDossier"];
            this.path = ConfigurationSettings.AppSettings["cheminSurveille"];
            this.ftpActive = Convert.ToBoolean(ConfigurationSettings.AppSettings["ftpActive"]);
            this.ftpRegex = ConfigurationSettings.AppSettings["ftpRegex"];
        }

        /// <summary>
        /// Fonction permettant de surveiller l'arrivé de fichier dans l'arborescence du dossier
        /// </summary>
        public void observateur()
        {
            //définition du watcher
            FileSystemWatcher watcher = new FileSystemWatcher();

            if (Directory.Exists(this.path))
            {
                watcher.Path = this.path;//définition du chemin du dossier à surveiller
                watcher.IncludeSubdirectories = true;//on inclu les sous repertoires à la detection
                watcher.EnableRaisingEvents = true;//On active la detection d'évenements
                watcher.Created += new FileSystemEventHandler(watcher_Created);//ajout de l'event handler


                //définition du timer de traitement de la copie
                TimerCallback TimerDelegate = new TimerCallback(traitement_copie);
                processusCopie = new Timer(TimerDelegate, null, 1000, 20000);
                

            }
            else
            {
                Console.WriteLine("Le chemin à surveiller n'est pas valide");
            }

            
        }


        /// <summary>
        /// Détection de l'évenement de création dans le dossier Temp
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public void watcher_Created(object sender, FileSystemEventArgs e)
        {

                //Récupération du chemin du fichiers détécté
                Fichier unfichier = new Fichier(e.FullPath);

                //Ajout du fichier à la liste d'arrivé
                this.ListFichier.Add(unfichier);
                Console.WriteLine("Ajout du fichier: " + unfichier.Filename + " a la liste des fichier à traiter");
            
            
        }



        /// <summary>
        /// Fonction utiliser par le Timer pour vérifier la liste des fichiers à copiés
        /// </summary>
        /// <param name="state"></param>
        public void traitement_copie(object state)
        {
            Timer t = (Timer)state;
            
            Console.WriteLine("Debut du thread: "+ DateTime.Now);

            //si il y a des fichiers dans la liste, alors on les copies
            if (this.ListFichier.Count > 0)
            {

                foreach (Fichier unfichier in ListFichier)
                {
                        Console.WriteLine("Fichier: " + unfichier.Filename);

                        try
                        {
                            //Copie du fichier
                            unfichier.Copie(this.newDossier, this.oldDossier);

                            //Si FTP activé, alors on ajoute le fichier à la liste FTP
                            if (this.ftpActive)
                            {

                            }
                            else
                            {
                                try
                                {
                                    //suppression du fichier de la liste à copier
                                    this.ListFichier.Remove(unfichier);

                                    //sinon on supprime le fichier dans le dossier SAS
                                    unfichier.Suppression();
                                }
                                catch (Exception err)
                                {
                                    Console.WriteLine("Erreur Suppression: " + err.Message);
                                }
                            }
                        }
                        catch (Exception err)
                        {
                            Console.WriteLine("Erreur Copie: " + err.Message);
                        
                        }

                    
                }
            }

            Console.WriteLine("Fin du processus du thread: " + DateTime.Now);
        }


    }
}

Merci d'avance pour votre aide

Bonsoir,

Pourquoi utiliser un timer alors que le watcher signale quand un fichier arrive? Faites un thread de copie qui tourne en boucle et se débloque sur un mutex/mécanisme de synchro activé par le watcher?

Faudrait peut être désactiver le timer pendant la copie, au cas ou cela prends plus de 20 secondes!

Sinon on ne peut pas remove dans un foreach: Il faut utiliser une boucle for(int i = 0 i< listfichier.count; i++) et penser à faire i-- après suppression(pour ne pas sauter un fichier!). D'ailleurs votre application est censée se fermer sur une exception...

Bonjour,

Merci pour ta réponse. Je vais refaire un essai avec les éléments que tu me donne. Merci