.Net Framework contine spatiul de nume System.Diagnostics, care permite interactiunea cu event log din Windows, monitorizeaza proceselor sistem din retea, monitorizeaza proceselor locale, monitorizarea performantei sistemului.

   Administratorii de sistem folosesc foarte mult Windows event log, un centralizator cu informatii despre sistemul de operare, activitatile aplicatiilor si erori. Un exemplu: sistemul de operare Windows creeaza event logs la pornire si inchidere.

   Exista 3 tipuri de event log foarte des intalnite: system (stocheaza evenimente care nu sunt legate de securitatea sistemului), securitate (stocheaza evenimente care legate de sesiunile utilizatorilor, accesul la fisiere si registri), application (stocheaza evenimente de la toate aplicatiile care nu au deja creat un event log specific).

   Evenimentele au nevoie de o sursa, iar ca sa adaugam una, va trebui sa avem drepturi de adminstrare asupra sistemului.

   Din clasa EventLog apelam metoda statica CreateEventSource.

    string sursa = "AplicatieTest";
    EventLog elog = new EventLog();
    //verifica daca exista sursa
    if (!EventLog.SourceExists(sursa))
    { 
        //daca nu, o creem
        EventLog.CreateEventSource(sursa, sursa);
    }

   Dupa ce am reusit inregistrarea aplicatiei AplicatieTest. ca o sursa, putem adauga un eveniment folosind o instanta a clasei:

    //adaugam un eveniment la event log pentru AplicatieTest
    EventLog elog = new EventLog();
    elog.Source = sursa;
    elog.WriteEntry("Eroare", EventLogEntryType.Error, 1001, 15);

   Un mesaj detaliat al erorilor este recomandat doar in masura in care nu se afiseaza parole, detalii despre utilizatori, conexiuni, etc.

   Pentru citirea evenimentelor, accesam colectia EventLog.Entries:

    foreach (EventLogEntry intrare in elog.Entries)
    {
        Console.WriteLine(intrare.Message);
    }

   Mai multe detalii despre clasa EventLog se gasesc pe msdn.

   O alta parte importanta pe care o trateaza spatiul de nume System.Diagnostics este performanta. Aceasta este masurata cu ajutorul unor contoare, astfel, administratorul sistemului sau dezvoltatorul aplicatiei poate monitoriza orice aspect al performantei aplicatiei.

   Se pot monitoriza componente ca: procesoare, memorie, retea.

   Sistemul de operare Windows detine o multime de indicatori de performanta care permit monitorizarea activitatilor sistemului in timp real. Numarul indicatorilor difera de la sistem la sistem, in functie de hardware-ul si software-ul instalat.

   Indicatorii sunt impartiti in categorii. Vom folosi PerformanceCounterCategory pentru a afisa lista categoriilor de indicatori din sistem:

    //GetCategories va returna lista indicatorilor
    //salvam toti indicatorii intr-un vector
    PerformanceCounterCategory[] listaIndicatori = PerformanceCounterCategory.GetCategories();

    //parcurgem vectorul cu indicatori
    foreach (var ind in listaIndicatori)
    {
        Console.WriteLine(ind.CategoryName);
    }

   Pentru a monitoriza performanta cu ajutorul unui program in C#, folosim clasa PerformanceCounter. In acest exemplu, vom afisa un indicator din categoria Processor.

    //construim un obiect PerformanceCounter
    //care va monitoriza procesorul
    PerformanceCounter ip = new
    PerformanceCounter("Processor", "% Processor Time", "_Total");
    // primul apel al metodei reseteaza indicatorul
    ip.NextValue();
    Thread.Sleep(1000);
    // afisam uzura procesorului in secunda trecuta         
    Console.WriteLine(ip.NextValue());

   Un alt exemplu: afisam indicatorul pentru afisarea memoriei Ram disponibila:

    PerformanceCounter indicatorRam = new PerformanceCounter("Memory", "Available MBytes");

    Console.WriteLine(indicatorRam.NextValue());

   Mai multe informatii despre clasa PerformanceCounter, pe msdn.com.

   Aplicatiile au nevoie sa “cunoasca” aspecte ale computerului. De exemplu, procesele care ruleaza la un moment dat, unitati de stocare, reactia la schimbari in sistem. Pentru toate acestea, .Net Framework foloseste clasa Process si Windows Management Instrumentation.

Clasa Process

   Afisam toate procesele active la momentul respectiv, apeland functia statica GetProcesses (procesele rulate de alti utilizatori nu sunt vizibile intotdeauna). Pentru fiecare proces, ii vom afisa numele prin proprietatea ProcessName:

    foreach (Process p in Process.GetProcesses())
    {
        Console.WriteLine(p.ProcessName);
    }

Pentru ca proprietatile unui proces sa ramana actuale si valide, apelam metoda Refresh.

    p.Refresh();

   Alte cateva proprietati des folosite ale clasei Process sunt:

MachineName (“.” inseamna computerul local)

    //afiseaza numele computerului pe care ruleaza procesul
    Console.WriteLine(p.ProcessName+" "+p.MachineName);

BasePriority

    //afiseaza numele si prioritatea procesului
    Console.WriteLine(p.ProcessName + " " + p.BasePriority);

   Clasa Process pune la dispozitie metoda statica Start, pentru a porni un nou process. Nu trebuie decat sa ii specificam numele fisierului executabil:

    Process notepad = new Process();
    notepad.StartInfo.FileName = "notepad.exe";

    notepad.Start();

   Pentru o privire detaliata asupra clasei Process vizitati siteul Microsoft.

   Sistemul de operare Windows expune foarte multe informatii despre computer si despre el insusi prin intermediul WMI. Asemenea informatii sunt utile in instalarea/configurarea aplicatiei.

Ca un rezumat al articolului, in cadrul spatiului de nume System.Diagnostics, am ales sa discutam despre:

   Event logging – este o modalitate centralizata pentru a inregistra evenimente software si hardware importante pentru aplicatie. Windows furnizeaza o interfata utilizator pentru vizualizarea log-urilor, Event Viewer.

   Performanta – se refera la viteza executiei unui program. Ea este influentata direct de calitatea codului scris pentru aplicatie. Astfel, se pot face modificari majore sau minore asupra codului pentru a mari viteza de executie. O recomandare este stabilirea unor puncte de performanta si monitorizarea ei in cursul dezvoltarii aplicatiei.

   Proces – in termeni generali, se poate defini ca o aplicatie care ruleaza. Un thread (fir de executie) este unitatea de baza pe care sistemul de operare o aloca  procesului.

   Despre toti membrii spatiului de nume System.Diagnostics, puteti afla pe siteul msdn.com.

   Pentru incheiere am pastrat ceva special: System.Diagnostics.Stopwatch – din puctul meu de vedere cea mai folosita clasa a acestui namespace la nivel de practica: oricine are nevoie, la un moemnt data, sa stie cat timp dureaza executia unui anumit bloc de aplicatie. Ca sa scurtez povestea: Stopwatch e o clasa care permite masurarea timpului scurs intre doua puncte ale aplicatiei. Modul de folosireeste simplu:

    using System.Diagnostics;

//.......
    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();
        //blocul de cod a carui timp de executie vrem sa il masuram
    stopWatch.Stop();
    Console.WriteLine("Executia a durat: " + stopWatch.ElapsedMilliseconds + "milisecunde")
//.......

   Utilitatea acestui tip de masuratoare depinde de la aplicatie la aplicatie. Eu, in practica, am folosit ceva asemanator pentru a verifica timpul necesar unei aplicatii care imi genereaza documente pdf online pentru un document; alt loc unde am folosit este pentru o aplicatie care genereaza niste grafice pe baza unor date care vin dintr-un webservice si trebuie sa generez la fiecare incarcare a unei pagini web un numar nedefinit de grafice – intre zero si cateva zeci. Mai important decat masurarea duratei unei operatii este insa masurarea diferentei de timp intre executarea codului o data si de 100 de ori. Sau cu alte cuvinte, sa generez un grafic imi ia 80 milisecunde. Cat timp imi trebuie pentru a genera 40 de grafice? Daca e 80 milisecunde x 40 ar trebui sa mai lucrez la algoritm!

   Un alt exemplu de folosire a acestei clase este penru optimizarea (sau el putin cunoasterea) problemelor de conectare la o baza de date sau la un webservice. E important sa stii, cand scrii o aplicatie, daca iti ia 1 secunda sa citesti ceva din baza de date sau daca iti ia o milisecunda. La fel si pentru webservice.

Informatiile obtinute despre timpul de executie al anumitor portiuni – blocuri – de cod sunt, in cazul meu cel putin, informatii care ajung in logurile aplicatiei. Daca scriu loguri, atunci scriu si informatii despre timpul de executie.

   In articolul urmator vom discuta despre spatiul de nume System.Text.