[C#]Logging in C#

[pkouwer]

In de spaarzame tijd die ik heb, probeer ik me de C# -taal aan te leren, na jaren lang in VB6 te hebben gewerkt, en nog steeds.

Ik heb op Internet een leuke site ontdekt waarin middels korte filmpjes wat zaken wordt uitgelegd. Helaas is dit in VB.Net. Nu is de stap niet zo groot van VB6 naar VB.Net, maar aangezien basic op z'n weg terug schijnt te zijn (hierover a.u.b. geen discussie aangezien dit offtopic is), ga ik persoonlijk toch voor C#.

Nu was ik altijd van gedachten dat de verschillen tussen C# en VB.Net niet zo heel erg groot zou zijn. Voorbeeld: 1 van de filmpjes gaat over logging in VB.Net middels application.log.writeentry. Er wordt dan een logfile aangemaakt (niet een event). Nu wil ik dit b.v. ook in C#, maar kan application.log.writeentry niet aanroepen.

Zie ik de zaken verkeerd, liggen de verschillen toch zover uit elkaar ?

[TeeDee]

Zoeken op google naar 'c# writeentry' geeft deze link op MSDN.

Het zou ook schelen als je de link naar die 'leuke' site geeft, maar zo met deze informatie kom ik alleen op bovenstaande link uit.

[ Voor 28% gewijzigd door TeeDee op 23-09-2008 22:12 ]

[pkouwer]

dit schrijft een entry weg naar de event-log, niet naar een tekstbestand. Dat zou eigenlijk wel de bedoeling moeten zijn, aangezien het wel eens makkelijk kan zijn voor eindgebruikers dit te mailen.

sorry, dat had ik in de openingspost even moeten vermelden, excuus.

[pkouwer]

De link naar de site is: http://windowsclient.net/

[Daspeed]

Kijk eens naar tracing & TextWriterTraceListener

[TeeDee]

Ach komop, een klein eventje naar een simpel tekstbestandje schrijven is toch niet zo ingewikkeld?

Begin eens met de basics: StreamReaders, StreamWriters.

Eventueel, weet niet of dat mogelijk is (kan het hier even niet testen), kan je wel iets met de Microsoft.VisualBasic namespace/reference.

My.Application.Log.WriteEntry is afaik typisch een VB.net iets.

[pkouwer]

het gaat mij niet zozeer om het wegschrijven naar een tekstfile, dat gaat me zeker wel lukken, maar VB.Net kent een standaard iets en C# dus blijkbaar niet, dat is mijn issue

[whoami]

Dat 'standaard' iets wat VB.NET kent, zal intern ook wel gewoon gebruik maken van de tracing & logging classes die het .NET framework aanbiedt.
Zoals eerder reeds gezegd: je kan eens kijken naar TraceListeners, BooleanSwitches, TraceSwitches, en de Debug & Trace classes.

Verder kan je ook eens naar 3rd party loggers kijken, zoals bv Log4Net

[TeeDee]

whoami schreef op dinsdag 23 september 2008 @ 23:17:
Verder kan je ook eens naar 3rd party loggers kijken, zoals bv Log4Net

Of ELMAH, of basaal iets zelf schrijven dus.

Zelf nadenken en/of research doen mag best.

[Verwijderd]

pkouwer schreef op dinsdag 23 september 2008 @ 22:37:
het gaat mij niet zozeer om het wegschrijven naar een tekstfile, dat gaat me zeker wel lukken, maar VB.Net kent een standaard iets en C# dus blijkbaar niet, dat is mijn issue

VB.NET heeft van nature een hoop meer ondersteuning voor assemblies die bedoeld zijn voor VB6 overstappers.
C# heeft dat niet nodig, omdat de meeste overstappers uit C/C++, Delphi, etc. komen en dus nog nooit die VB6 functies nodig hebben gehad.

[Verwijderd]

Ik denk dat de stap van VB6 naar VB.NET behoorlijk groot is.
Misschien dat van VB6 naar C# overstappen wel makkelijker gaat.

De syntax tussen VB6 en VB.net is niet zo verschillend, maar de achterliggende techniek, bibliotheken en het gebruik wel. Ik denk dat je nog steeds in VB6 oplossingen gaat denken, terwijl je juist in .NET oplossingen moet denken(dus niet kijken naar.

De juiste keus heb je al gemaakt zo te lezen, alleen moet je VB wat meer van je afzetten .
Als je het echt wil leren raad ik je het Microsoft .NET foundation boek aan (uhh, voor exam 70-536 geloof ik). Daar leggen ze het complete framework uit met de gedachtengang erachter met een aantal opdrachten.

het gaat mij niet zozeer om het wegschrijven naar een tekstfile, dat gaat me zeker wel lukken, maar VB.Net kent een standaard iets en C# dus blijkbaar niet, dat is mijn issue

VB.NET kent de standaard juist niet , die logfunctie van VB.NET waar jij het over hebt wordt waarschijnlijk gewoon omgezet naar een generiek .NET iets. (ik zal het even voor je uitzoeken).

edit:

Application.Log.WriteEntry() maakt gebruik van (System.Diagnostics.)TraceSource.TraceEvent.
In deze functie wordt gewoon gebruik gemaakt van de TraceListener klasse.
De TraceListener kun je zien als de 'standaard'

Trouwens, ik denk dat je die VB functies ook kan gebruiken in .NET. Maar dan moet je een referentie maken naar de Microsoft.VisualBasic assembly

code:

using Microsoft.VisualBasic.Logging;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            new Microsoft.VisualBasic.Logging.Log().WriteEntry("Testbericht");
        }
    }
}

[ Voor 22% gewijzigd door Verwijderd op 24-09-2008 09:10 ]

[Verwijderd]

Zelf geschreven en simpel, misschien heb je er wat aan:

C#:

using System;
using System.IO;
using System.Windows.Forms;

namespace App
{
    static class Log
    {
        public static bool _logEnabled = true;
        //XP uses Environment.CurrentDirectory for default path.
        //This will result in problems when using a filedialog.
        //Explicitly use Application.StartupPath, not relative path.
        public static string _fileName = Path.Combine(Application.StartupPath, "Log.txt");
        
        public static void WriteLogHeader()
        {
            if (_logEnabled == true)
            {
                using (StreamWriter streamWriter = new StreamWriter(_fileName, true))
                {
                    streamWriter.WriteLine("");
                    streamWriter.WriteLine("%Session Start at {0} {1}", DateTime.Now.ToLongTimeString(),
                        DateTime.Now.ToLongDateString());
                }
            }
        }
        
        public static void WriteStatement(string statement)
        {
            if (_logEnabled == true)
            {
                using (StreamWriter streamWriter = new StreamWriter(_fileName, true))
                {
                    streamWriter.Write("%{0} {1} ", DateTime.Now.ToLongTimeString(),
                        DateTime.Now.ToLongDateString());
                    streamWriter.WriteLine(statement);
                }
            }
        }
        public static void WriteStatement(string statement, object arg0)
        {
            if (_logEnabled == true)
            {
                using (StreamWriter streamWriter = new StreamWriter(_fileName, true))
                {
                    streamWriter.Write("%{0} {1} ", DateTime.Now.ToLongTimeString(),
                        DateTime.Now.ToLongDateString());
                    streamWriter.WriteLine(statement, arg0);
                }
            }
        }
        public static void WriteStatement(string statement, object arg0, object arg1)
        {
            if (_logEnabled == true)
            {
                using (StreamWriter streamWriter = new StreamWriter(_fileName, true))
                {
                    streamWriter.Write("%{0} {1} ", DateTime.Now.ToLongTimeString(),
                        DateTime.Now.ToLongDateString());
                    streamWriter.WriteLine(statement, arg0, arg1);
                }
            }
        }
        public static void WriteStatement(string statement, object arg0, object arg1, object arg2)
        {
            if (_logEnabled == true)
            {
                using (StreamWriter streamWriter = new StreamWriter(_fileName, true))
                {
                    streamWriter.Write("%{0} {1} ", DateTime.Now.ToLongTimeString(),
                        DateTime.Now.ToLongDateString());
                    streamWriter.WriteLine(statement, arg0, arg1, arg2);
                }
            }
        }
        
        public static void WriteException(Exception ex)
        {
            if (_logEnabled == true)
            {
                using (StreamWriter streamWriter = new StreamWriter(_fileName, true))
                {
                    streamWriter.Write("%{0} {1} ", DateTime.Now.ToLongTimeString(),
                        DateTime.Now.ToLongDateString());
                    streamWriter.WriteLine(" Exception");
                    streamWriter.WriteLine(" Exception message: " + ex.Message);
                    streamWriter.Write(" Inner exception message: ");
                    streamWriter.WriteLine(ex.InnerException != null ? ex.InnerException.Message : "");
                    streamWriter.WriteLine(" Stacktrace: " + ex.StackTrace);
                }
            }
        } 
    }
}

[Haan]

code:

if (_logEnabled == true)

Die kan ook anders hè

Overigens doet jouw WriteException methode volgens mij precies wat de ToString() methode van een exception ook al gewoon doet (minus de datum/tijd natuurlijk)

[ Voor 7% gewijzigd door Haan op 24-09-2008 11:37 ]

[TeeDee]

Haan schreef op woensdag 24 september 2008 @ 11:36:
Overigens doet jouw WriteException methode volgens mij precies wat de ToString() methode van een exception ook al gewoon doet

Uhm, de ToString() van een Exception schrijft het afaik niet meteen naar een Logfile.

[Haan]

TeeDee schreef op woensdag 24 september 2008 @ 11:37:
[...]

Uhm, de ToString() van een Exception schrijft het afaik niet meteen naar een Logfile.

Nee hèhè , maar je kan wel

C#:

streamWriter.WriteLine(" Exception"); 
streamWriter.WriteLine(" Exception message: " + ex.Message); 
streamWriter.Write(" Inner exception message: "); 
streamWriter.WriteLine(ex.InnerException != null ? ex.InnerException.Message : ""); 
streamWriter.WriteLine(" Stacktrace: " + ex.StackTrace); 

vervangen door

C#:

streamWriter.WriteLine(ex.ToString()); 

[pkouwer]

Verwijderd schreef op woensdag 24 september 2008 @ 08:59:
I

Trouwens, ik denk dat je die VB functies ook kan gebruiken in .NET. Maar dan moet je een referentie maken naar de Microsoft.VisualBasic assembly

code:

using Microsoft.VisualBasic.Logging;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            new Microsoft.VisualBasic.Logging.Log().WriteEntry("Testbericht");
        }
    }
}

Ik zal vanavond eens kijken naar de replies met bijbehorende adviezen. Is het gebruik van de referentie niet "dirty", iets wat eigenlijk niet in C# hoort, want als ik toch moet schakelen/mezelf heropvoeden, dan doe ik het net zo lief in één keer goed !

[bigbeng]

Ik zou een referentie naar de VisualBasic assembly niet willen hebben in mijn c# code. Bij code-omzetting van VB naar C# kan het soms tijdbesparend werken, omdat methodes als Left, Mid etc dan in 1x hetzelfde werken, maar dan hou je dus wel je VB legacy.

Persoonlijk ben ik wel gecharmeerd van Log4Net, o.a. omdat het loggen (bijna) niet kan crashen (iets wat ik in de gegeven codevoorbeelden niet terugzie.). Denk bijvoorbeeld aan gelockte logfiles, meerdere threads die naar hetzelfde log schrijven etc. Persoonlijk ben ik van mening dat de flow van je programma niet mag worden beinvloed door het schrijven van het log.

[Verwijderd]

Neenee, de Visual Basic assemblies moet je ook niet gebruiken
Ik wilde alleen maar aangeven dat het wel allemaal één pot nat is dat .NET.

In ieder geval geen VB .NET tuts volgens als je C# wilt doen .
Ook al is het hetzelfde, het is toch niet hetzelfde.

[CabezaDelZorro]

bigbeng schreef op woensdag 24 september 2008 @ 13:18:
Ik zou een referentie naar de VisualBasic assembly niet willen hebben in mijn c# code. Bij code-omzetting van VB naar C# kan het soms tijdbesparend werken, omdat methodes als Left, Mid etc dan in 1x hetzelfde werken, maar dan hou je dus wel je VB legacy.

Persoonlijk ben ik wel gecharmeerd van Log4Net, o.a. omdat het loggen (bijna) niet kan crashen (iets wat ik in de gegeven codevoorbeelden niet terugzie.). Denk bijvoorbeeld aan gelockte logfiles, meerdere threads die naar hetzelfde log schrijven etc. Persoonlijk ben ik van mening dat de flow van je programma niet mag worden beinvloed door het schrijven van het log.

Ik gebruik zelf de EnterpriseLibrary van MS zelf (http://msdn.microsoft.com/en-us/library/cc467894.aspx) bevat naast een logging component ook een aantal andere gemakkelijke componenten voor bijvoorbeeld Exception handling, Caching etc.

Maar Log4Net zal qua logging waarschijnlijk ongeveer hetzelfde doen.

[PolarBear]

bigbeng schreef op woensdag 24 september 2008 @ 13:18:
Ik zou een referentie naar de VisualBasic assembly niet willen hebben in mijn c# code. Bij code-omzetting van VB naar C# kan het soms tijdbesparend werken, omdat methodes als Left, Mid etc dan in 1x hetzelfde werken, maar dan hou je dus wel je VB legacy.

VB legacy? VB.Net heeft niets met VB classic te maken. De assembly waarna je refereert is 100% .Net. Dus als je een Left functie gebruikt ipv zelf met substring te lopen klooien is de kans erg groot dat de CLR hetzelfde doet.

[bigbeng]

De TS schrijft c# code, dus VB legacy zijn code constructs die daarmee samenhangen. Lijkt me op zich toch valide?

Bovendien zijn Global Functions evil! Maar goed, laat ik me inhouden

[ Voor 26% gewijzigd door bigbeng op 26-09-2008 22:49 ]

[Data-base]

PolarBear schreef op woensdag 24 september 2008 @ 19:19:
[...]
VB legacy? VB.Net heeft niets met VB classic te maken.

Doe eens voor de gein een string compare in VB.Net en C# en kijk naar de gegenereerde IL.

Als je in vb een string compare doet met =, wordt de legacy vb libary gebruikt en worden datatypen gemarshalled...

Ik heb niks tegen vb.net, werk er zelf af en toe ook mee, maar mensen die roepen dat vb.net niks met vb te maken heeft zitten er gewoon naast.

[pkouwer]

bigbeng schreef op vrijdag 26 september 2008 @ 22:43:

Bovendien zijn Global Functions evil! Maar goed, laat ik me inhouden

leef je uit !