classe de log ?

quel genre de mécanisme cherches tu ?
tu peux utiliser un Listner sur la console de Debug, et balancer du xml
dedans en utilisant un XmlWriter.
au niveau du code, il n'y a pas grand chose à faire : une methode qui écrit
le contenu de l'exception, et ensuite placer le mécanisme qui la recupere
aux endroits interessants.

y'a probablement mieux, mais bon...

Ambassadeur Kosh wrote:

quel genre de mécanisme cherches tu ?
tu peux utiliser un Listner sur la console de Debug, et balancer du xml
dedans en utilisant un XmlWriter.

=> Ca c'est intéressant et comme je débute en Csharp, j'aurai besoin de
détails : qu'est-ce que la console de débug ?
celle de visual Sudio ?
Une entité comme le stderr en C ?
Un objet que je cree moi-même dans ma fenetre ?

au niveau du code, il n'y a pas grand chose à faire : une methode qui écrit
le contenu de l'exception, et ensuite placer le mécanisme qui la recupere
aux endroits interessants.

C'est bien ce que je cherche, mais une déjà faite :)
Le xml me permettrait une réutilisation aisée, peut-être (à creuser)

Merci pour la réponse cpdt !

ok. donc on va faire simple, histoire de toucher à tout au fur et à mesure :

namespace MonsieurBricolo
{
using System.Xml ;
using System.Text ;

public class XmlExceptionWriter : object , IDisposable
{
public readonly static XmlExceptionWriter Instance = new
XmlExceptionWriter() ;

private XmlExceptionWriter()
{
XmlTextWriter writer = new
XmlTextWriter(@"c:tracestrace.xml",Encoding.Default) ;
writer.Formatting = Formatting.Indented ;
writer.WriteStartDocument() ;
writer.WriteStartElement("exceptions-log") ;

this.writer = writer ;
}

private XmlWriter writer ;

public void WriteException(Exception e)
{
writer.WriteStartElement("exception") ;

writer.WriteElementString("type",e.GetType().ToString()) ;
writer.WriteElementString("message",e.Message) ;
writer.WriteElementString("source",e.Source) ;
writer.WriteElementString("stack-trace",e.StackTrace) ;

writer.WriteEndElement() ;
}

public void Close() { writer.Close() ; }
public void Flush() { writer.Flush() ; }

void IDisposable.Dispose()
{
if(writer.WriteState != WriteState.Closed)
{
writer.WriteFullEndElement() ;
writer.WriteEndDocument() ;
writer.Close() ;
}
}
}
}

note l'emplois du XmlWriter. pas de danger d'oublier les < > & et autres
embrouilles, le writer fait tout pour toi.
si tu souhaites ecrire autre chose que des string, la classe XmlConvert
s'impose. surtout pas de ToString sur des double ou autre, tu perdrais la
propriété interessante du Xml.
bon, c'est fonctionel, mais la classe veut tout faire, et finalement, ça
manque de réutilisabilité. on peut faire bien mieux en faisant faire le
boulot aux autres :
voici donc la deuxieme version

namespace MonsieurBricolo
{
using System.Xml ;
using System.Text ;

public class XmlExceptionWriter
{
public XmlExceptionWriter(XmlWriter writer)
{
this.writer = writer ;
}

private XmlWriter writer ;

public void WriteException(Exception e)
{
writer.WriteStartElement("exception") ;

writer.WriteElementString("type",e.GetType().ToString()) ;
writer.WriteElementString("message",e.Message) ;
writer.WriteElementString("source",e.Source) ;
writer.WriteElementString("stack-trace",e.StackTrace) ;

writer.WriteEndElement() ;
}

public void Close() { writer.Close() ; }
public void Flush() { writer.Flush() ; }
}
}

l'application cree elle même son fichier de trace, et à la sortie, elle fait
le ménage elle même. la classe devient réutilisable, on peut faire plusieurs
fichiers de logs en meme temps etc etc. c'est tout de suite plus sympa.
version suivante, utiliser la serialisation. c'est un mécanisme qu'on avait
pas en C++, ça permet d'envoyer un objet vers un fichier, ou l'inverse, sans
se poser de questions ou d'implanter quoi que ce soit. on peut serialiser
dans le langage qu'on veut. xml, binaire... ou son langage pourvu qu'on
l'implante. la encore, royal. ce n'est pas une extension de l'approche
précédente, c'est autre chose.

namespace MonsieurBricolo
{
using System.Xml ;
using System.Xml.Serialization ;
using System.Text ;

public class XmlExceptionWriter
{
public XmlExceptionWriter(XmlWriter writer)
{
this.writer = writer ;
}

private XmlWriter writer ;
private XmlSerializer serialiser = new XmlSerializer(typeof(Exception)) ;

public void WriteException(Exception e)
{
serialiser.Serialize(writer,e) ;
}

public void Close() { writer.Close() ; }
public void Flush() { writer.Flush() ; }
}
}

évidement, j'ai centré sur Xml. apres, tu fais comme tu as envie.

maintenant, l'idée de la console de debug, c'est de pouvoir balancer des
infos au fur et à mesure que le programme avance dans la fenetre en bas du
Visual Studio. il y'a une classe qui s'occupe de ça. alors pourquoi pas les
exceptions en fait ? ça elargi le champ d'action. par exemple.

using System.Diagnostics ;
...
Debug.WriteLineIf(x<0,"on a x<0 !") ;
Debug.WriteLine("je suis passé ici !") ;

on y trouve d'autres choses encore, mais l'idée, c'est d'écrire dans cette
sortie. et cette "sortie", on peut la brancher sur N tuyaux (c'est mieux
qu'un seul).
du point de vue de ton objet xml, c'est une trés mauvaise idée apres
reflexion. pourquoi ? parceque tout le monde peut ecrire dans la console de
Debug. et donc on peut ecrire du xml malgré soit (exemple plus haut avec
x<0), et surtout mal formé. morale de l'histoire, laisser tomber cette
approche.

par contre s'insiperer de la console de Debug pour faire une classe
ExceptionLoger, c'est pas une mauvaise idée du tout.

ça va jusque la ? on continue ?

Impeccable merci bcp !
j'aime bien la sérialisation mais j'aime bien la précédente aussi !

un grand coup de copier coller s'impose :)

merci encore et bonne soirée !