Ecriture dans un fichier partagé

Bonjour à tous,

J'ai un petit problème lors de l'écriture dans un fichier de log. Plusieurs Thread accèdent au même fichier via une variable statique maintenue dans une Th principal (Core) chargé de lancé les autres threads.

Code:

1
2
 
public static LogFile Log;

La classe LogFile possède la méthode suivante

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
/// <summary>
        /// Ecrit une ligne de texte précédée de la date et heure correspondant 
        /// au format définit dans le fichier de configuration.
        /// </summary>
        /// <param name="textLine">Ligne de texte a écrire dans le fichier log</param>
        public void WriteLog(String textLine)
        {
            try
            {
                Monitor.TryEnter(_lock);
                //Si le jour a changé, alors on change de fichier
                if (_currDate != GetDateFormat())
                {
                    //Fermeture du flux précédent (ouvert)
                    _sw.Close();
 
                    //Création du chemin du fichier
                    _currDate = GetDateFormat();
                    _fi = new FileInfo(String.Format(@"{0}\{1}{2}", _basedir.FullName, _currDate, _config["FileExtension"].ToString()));
 
                    //Ouverture du fichier
                    _sw = new StreamWriter(new FileStream(_fi.FullName, FileMode.Append, FileAccess.Write, FileShare.ReadWrite));                   
 
                    //Avertissement console d'un changement de fichier
                    Console.WriteLine("\tLogfile: Changement de fichier log: {0}", _fi.FullName);
                }
                String buffer = String.Format("{0} - {1}", DateTime.Now.ToString(_config["LineTimeFormat"].ToString()), textLine);
 
                //Ecriture dans le fichier
                _sw.WriteLine(buffer);
                _sw.Flush();
 
                Monitor.Exit(_lock);
            }
            catch (IOException e)
            {
                Console.WriteLine("\tLogFile: Erreur d'écriture {0}",e.Message);
            }
            catch (Exception e)
            {
                Console.WriteLine("\tLogFile: Erreur d'écriture critique {0}",e.Message);
            }
        }
 
        /// <summary>
        /// Retourne la date au format Spécifié dans le fichier de config (FileTimeFormat)
        /// </summary>
        /// <returns></returns>
        private String GetDateFormat()
        {
            return DateTime.Now.ToString(_config["FileTimeFormat"].ToString());
        }

Chaque soir à minuit, la date change donc le code passe dans le if, et je me prend systématiquement un passage dans Catch(Exception e) avec pour message d'erreur

Citation:

Impossible d'écrire dans un TextWriter fermé.

Cela semble dire que malgrés le monitor, deux theads accèdent au code placé entre le TryEnter() et le Exit().

Plusieurs points à rectifier déjà :
* Un appel à Dispose après le Close
* Mettre le Monitor.Release dans un bloc finally, car là sur exception, adieu les accès concurrents (ou alors utiliser lock())

Après, avoir le type de l'exception, et la ligne qui la provoque (on suppose là que c'est le WriteLine) serait utile :)

Bonjour,

Merci de prendre le temps de me répondre.

Bien vu pour le deadlock...
J'ai déjà placé le Monitor.Exit(_lock) dans la clause finally, j'ai également rajouter la ligne Monitor.Pulse(_lock) juste après le Exit.
Désolé, mais je n'ai pas trouvé la Méthode Release dans la class Monitor. Peut-être veux tu parler de la méthode Monitor.Wait(object) ??

La ou les ligne(s) suceptible(s) de provoquer cette Exception est
Code:

1 2 Core.Log.WriteLog("blablablalbla");
On retrouve ce type de ligne partout dans le code où une trace doit être ajoutée

Pour le type de l'exception il faudra attendre demain et j'ai fait
Code:

1 2 Console.WriteLine("\tLogFile: Erreur critique: {0} - {1}", e.GetType().Name, e.Message);
Edit:
L'exception lancée est ObjectDisposedException