9

 Un Event Log este un “jurnal” mentinut de Windows,

in care orice aplicatie poate sa scrie text.
 Event Log-urile ofera
 un mecanism usor prin care o aplicatie poate inregistra
date despre executie.
 o modalitate usor de folosit prin care dezvoltatorii pot
inregistra evenimente neobisnuite
 un mecanism prin care utilizatorii pot verifica starea
aplicatiilor pe care le ruleaza
 Cand folositi EventLog-uri trebuie sa luati in consideratie
urmatoarele:
 Crearea, scrierea si citirea din un EventLog pot constituii
vulnerabilitati mari in cod. Obiectele de tip
EventLogEntryCollection sau EventLogEntry nu trebuie
niciodata trimise unui cod cu incredere mai mica.
 Orice cod care scrie EventLog-uri are nevoie de permisia
EventLogPermission.
 Operatiile cu EventLog-uri sunt foarte costisitoare in termeni de
utilizare disc, timp de procesor si alte resurse. Totodata un
EventLog se poate umple dupa care orice incercare de scriere el
se va solda cu o exceptie. Din acest motiv este recomandat sa nu
abuzati de EventLog-uri.
 Orice operatie cu EventLog-uri foloseste clasa EventLog.
 EventLog-urile au surse. De la o sursa pot provenii mai multe
entry-uri.
 Pentru a crea o intrare in un EventLog trebuie specificat jurnalul
in constructor, sursa si apoi se va folosii metoda WriteEntry:

EventLog eventlog = new EventLog(“jurnal”); //nume log

eventlog.Source = “jurnal” //sursa
eventlog.WriteEntry(“Intrare in jurnal”, EventLogEntryType.Information);

 Stergerea unui EventLog se face folosind metoda delete

EventLog.Delete(“jurnal”);
 Vom folosii metoda WriteEntry impreuna cu cele
10  supraincarcari aferente.
 Exemple:
eventlog.WriteEntry(“Intrare in jurnal”,
EventLogEntryType.Information);
eventlog.WriteEntry(“Intrare in jurnal”,
EventLogEntryType.Information, 100);
 Windows include cateva log-uri: Application,
Security si System.
 EventLog-urile sunt reprezentate in .NET framework de clasa
EventLogEntry si organizate in EventLogEntryCollection.
 Colectia poate fi enumerata:
EventLog eventlog = new EventLog();
eventlog.Log = “jurnal”;
foreach (EventLogEntry entry in eventlog)
{
Console.WriteLine(entry.Source + “ “ + entry.Message);
}
 Puteti folosii metoda Clear pentru a sterge toate intrarile din un
EventLog:
eventlog.Clear();
 Puteti folosii clasele Debug, Debugger, Trace pentru
a verifica daca liniile de cod scrise de voi fac exact ce
ati vrut.
 Clasa Debugger are cateva metode:
 Break: Opreste executia aplicatiei
 IsAttached: Indica daca un debugger este atasat aplicatiei
 IsLogging: Indica daca un debugger logheaza datele de
debug
 Launch: Lanseaza un debugger.
 Log: Scrie date in debuggerul selectat
 Metoda break este similara cu parcurgerea codului cu brakepoint-uri
puse manual. Acum in schimb putem face brakepoint-uri conditionate.
Ex:
string myString = “”;
if (myString != “”)
Debugger.Break();
 Metoda Log trimite datele catre un Listner. Daca nu astfel de Listner
nu este atasat nu se va intampla nimic.
 Presupunand ca un Listner ar fi atasat (vom detalia imediat) apelul
metodei este:
Debugger.Log( 2, ”test”, ”acesta este un test”);
{nivel} {categorie} {mesaj}
 Clasa Debug adauga unele metode foarte
folositoare:
 Assert
 Write
 WriteIf
 WriteLine
 WriteLineIf
 Print
 Flush
 Assert este folosit pentru a verifica daca mesaje sunt adevarate sau fals.
 Este recomandat sa il folosim oriunde un mesaj este tot timpul adevarat sau fals.
 Atunci cand compilati aplicatia in mod Release toate apelurile la metode de debug vor
fi automat scoase din cod.
ex:
try
{
data = ReadFileToString(“numeFisier.txt”);
}
catch {}
Debug.Assert(data!=null,”parse incorect”);
int nr = int.Parse(data);

Daca data a fost citita corect nu vor fi probleme la executie. Daca data a fost citita
incorect executia se va oprii la linia de assert.
Similar exista metoda Fail. Aceasta doar afiseaza un rezultat, nu verifica si conditia.
 Abort: Opreste executia programului
 Retry: Incearca sa execute din nou codul care a dat
eroare
 Ignore: Incearca sa continue executia
 Write trimite un text spre fereastra Output.
 WriteIf trimite un text spre fereastra Output daca
o conditie este activa.
 WriteLine, WriteLineIf: ca mai sus, doar ca
afisarea se face pe linie noua.
 Print afiseaza un mesaj spre orice listner atasat.
 Poate verifica o conditie
string s = null;
Debug.Print(s==null,”s e null”);
 Flush trimit orice output spre listen-ul atasat.
Dupa apelul lui flush orice mesaj ramas in buffer-
ul listen-rului va fi scris in listner.
 Modifica functionarea debuggerului atasat
 Atributele pentru debug sunt:
 DebuggerBrowsableAttribute
 DebuggerDisplayAttribute
 DebuggerHiddenAtribute
 DebuggerNonUserCodeAttribute
 DebuggerStepperBoundryAttribute
 DebuggerStepTroughAttribute
 DebuggerTypeProxyAttribute
 DebuggerVisualizerAttribute
 Daca decoram _companyCity, _companyName si _companyState cu
DebuggerBrowsable(DebuggerBrowsableState.Never nu mai erau
afisate la debug.
 Enumerarea DebuggerBrowsableState.Never poate lua valorile:
 Nevel: campul nu este afisat la debug
 Collapsed: Arata elementul dar collapsed.
 RootHidden: Nu arata elementul parinte, dar arata elementele copiii. (in o
colectie sau un array)
 [DebuggerDisplay
(“CompanyName = {_companyName},
CompanyState = {_companyState},
CompanyCity = {_companyCity}”)]
class SoftwareComapany{…
 Daca in clasa, metoda sau proprietatea decorata
de acest atribut contine un brakepoint, in
momentul in care executia ajunge la acel
brakepoint el este ignorat.
 DebuggerNonUserCodeAttribute: decoreaza cod
generat automat de designer si care deci este inutil sa fie
debug-at.
 Este folosit in cod decorat cu un
DebuggerNonUserCodeAttribute.
 Marcheaza o zona ce va fi debug-ata.
 DebuggerStepTroughAttribute: este folosit
pentru a marca portiuni de cod ce vor fi sarite de
catre debugger atunci cand se executa o
parcurgere pas cu pas a codului.
 Trace: clasa este foarte asemanatoare cu Debug: codul ce
foloseste clasa Trace este inclus atat in codul obtinul la
compilarea in mod Release cat si in Debug, in timp ce codul
ce foloseste Debug nu este inclus decat in codul obtinul la
compilarea in mod Debug.
 TraceSource: clasa ce permite asocierea mesajelor de debug
cu sursa lor:
TraceSource demosource = new
TraceSource(“applicatiaMea”);
demosource.TraceInformation(“Informatie de debug”);
 TraceSwitch:este folosita pentru modificare dinamica a
comportarii clasei Trace (ce fel de mesaje logheaza, etc.)
 Clasa Debug si clasa Trace pot trimite mesaje spre
obiecte de tip Listner.
 Atasarea unui listener se face folosind metoda Add din
clasa colectia Trace.Listeners:
Trace.Listeners.Add(<listner>);
 Obiectele Listner din .NET framework sunt:
 DefaultTraceListner
 TextWriterListener
 XmlWriterTraceListener
 EventLogTraceListener
 DelimitedListTraceListener
 DefaultTraceListner: Toate mesajele vor fi afisate in fereastra
Output.
Trace.Listeners.Add(new DefaultTraceListener());
 TextWriterListener: Toate mesajele vor fi scrise in un fisier text.
TextWriterListener ascultator = new
TextWriterListener(“output.txt”);
Trace.Listeners.Add(ascultator);
 EventLogTraceListener: Mesajele sunt scrise in un EventLog.
EventLogTraceListener log = new EventLogTraceListener(“jurnal”);
Trace.Listeners.Add(log);
 DelimitedListTraceListener : Toate mesajele vor fi afisate in un
fisier text, dat for fi separate de un caracter. (“,” de ex).
 XmlWriterTraceListener: mesajele sunt scrise in
un fisier xml.
 Oricat de buna ar avea o aplicatie arhitectura pot
sa apara probleme de performanta
 Pe utilizatorul normal nu il intereseaza daca am
folosit un design pattern sau altul, daca am
folosit o clasa sau alta, atat timp cat aplicatia are
comportarea platita la o viteza multumitoare.
 .NET framework contine cateva clase pentru a
monitoriza o multitudine de indicatori de
performanta (ex: cantitatea de memorie folosita)
 In momentul in care este lansat in executie un program sistemul de operare creaza
un proces.
 Procesul este, deci, o instanta a unui program sau mai bine zis un program in
executie.
 Procesele au o zona proprie de memorie (4GB la procesoarele pe 32 de biti)
 Managerul de memorie virtuala imparte RAM-ul in bucati de 4k (pagini de ram)
 Sistemele de operare multitaskig pot rula simultan mai multe procese.
 Un proces, in general, are urmatoarele componente:
 O imagine a codului executabil asociat unui program
 Memoria asociata procesului, ce contine cod executabil asociat procesului si alte date
specifice acestuia.
 Descriptori de resurse ai sistemului de operare. ex: descriptori de fisier (terminologie
Unix) sau handles (terminologie Windows).
 Atribute de securitate, ca de ex posesorul (owner) procesului sau setul de permisii al
procesului.
 Starea procesorului (contextul) format din datele din registrii etc. Starea procesului este
in general stocata in registrii cat procesul se executa si in memoria externa procesorului
cand procesul nu se executa.
 Pentru a lucra cu procese folosim clasa Process
 Pentru a crea o instanta a clasei Process putem
folosii 4 metode statice (din clasa Process):
 GetCurrentProcess
 GetProcessesById
 GetProcessesByName
 GetProcesses
 GetCurrentProcess: creaza o referinta la procesul
actual (procesul aplicatiei .net)
Process p = Process.GetCurrentProcess();
 GetProcessesById: creaza o referinta a unui proces
ce ruleaza in sistem, dupa Id-ul lui (id alocat de
Windows)
Process p = Process.GetProcessById(2);
 Metoda va arunca exceptie daca nu este gasit
procesul
 Metoda GetProcessesByName intoarce referinte
la toate procesele cu un anumit nume.
Process[] procese =
Process.GetProcessesByName(“nume”,”numemasina
”);
 Metoda GetProcesses intoarce referinte la toate
procesele ce ruleaza pe o masina
Process[] allProcess =
Process.GetProcessed(“numemasina”);
 Pornirea proceselor se poate face in 2 feluri:
 cu argumente in linia de comanda
 fara argumente in linia de comanda
 Pornirea fara argumente se face folosind metode Start.
 Metoda Start are 5 supraincarcari, intre care:
 Prima primeste ca parametru un obiect de tip ProcessStartInfo.
Acesta are o proprietate FileName, ce va contine numele
executabilului.
 A doua primeste ca parametru un string, FileName
 A treia primeste ca paremetrii username, password
(securestring), domeniu si nume fisier. Aceasta poate lansa un
proces in contextul altui utilizator. (Run As la right click  )
 Pornirea cu argumente necesita punerea
argumentelor in proprietatea Arguments, din
clasa ProcessStartInfo:
ProcessStartInfo info = new ProcessStartInfo();
info.FileName=“hdkill.exe”; 
info.Arguments=“c: d:”;
Process.Start(inf0);
 Performance Counters va ajuta sa masurati diferiti factori de
performanta.
 Cand primiti plangeri de la utilizatori asupra performantei
produsului puteti urma urmatorii pasi pentru a corecta
problema:
 Verificati daca problema chiar exista
 Creati un model ideal al aplicatiei (in care performanta este cea dorita
de voi)
 Comparati acest model cu datele din aplicatia reala
 Retineti fiecare loc in care apar diferente intre ceea ce ar trebuii sa fie si
ceea ce este.
 Examinati codul unde apar diferentele
 Modificati codul 
 In .NET framework cuantificatorii de performanta sunt
reprezentati de clasa PerformanceCounters.
 Pentru a adauga un performance counter la aplicatie trageti
componenta din toolbox in form-ul vostru (windows forms) 
sau instantiati clasa PerformanceCounter.
 Ei sunt organizati similar cu fisierele pe disc: proprietatile ce
identifica unic un anumit counter sunt:
 Computer Name
 Category Name (numele categoriei) (// discul computerului)
 Category Instance (instanta categoriei) (//directorul pe disc)
 Counter Name (numele counter-ului) (//fisierul din director)
 In clasa CounterCreationData putem inmagazina
toate proprietatile necesare crearii unui obiect
PerformanceCounter:
 CounterName
 CounterType
 CounterHelp
 Clasa PerformanceCounterCategory are rolul de a
gestiona obiectele de tip PerformanceCounter.
 Contine metodele:
 Create //creaza categorie noua
 Delete //sterge categorie existenta
 Exists //verifica daca exista categoria
 GetCategories //intoarce toate categoriile de pe o anumita
masina
 ReadCategory //intoarce toate PerformantCounter-ele din o
categorie. Metoda creaza un InstanceDataCollectionCollection,
colectie formata din InstanceDataCollection
 StackTrace permite vizualizarea stivei de apel de
metoda in .net runtime
 De fiecare data cand este apelata o metoda
parametrii ei sunt pusi in stiva, prin adaugarea
unui obiect de tip StackFrame.
 Windows contine un set de utilitare ce au ca scop
monitorizarea si management-ul sistemului, device-urilor si
aplicatiilor.
 Obiecte importante de management din
System.Management sunt:
 ManagemenyQuery: clasa de baza pentru cereri WMI
 EventQuery: obiect folosit pentru a face cereri in WMI, folosit in
conjunctie cu ManagementEventWatcher
 ObjectQuery: Obiect folosit pentru facut cereri la instante si la clase
in WMI
 ManagementObjectSearcher: Clasa folosita pentru a executa
ObjectQuery-uri in WMI
 Obiectul principal pe care il veti folosii in cand lucrati cu WMI este
DirectoryObjectSearcher.
 Sintaxa comenzilor la WMI este foarte asemanatoare cu cea a SQL.
 Pentru a executa o cerere la WMI folosind DirectoryObjectSearcher
trebuie urmati urmatorii pasi:
 Declarati o instanta a clasei ConnectionOption, setati campurile Username si
password.
 Declarati un obiect ManagementScope, setati PathName si ConnectionOption
 Declarati o instanta a clasei DirectoryObjectSearcher
 Creati un obiect ObjectQuery, si specificati o cerere de executat.
 Creati un ManagementObjectCollection si scrieri in ea valoarea returnata de
metoda Get a obiectului DirectoryObjectSearcher.
 In System.Management exista clasa
ManagementEventWatcher ce permite conectarea la
evenimente ce au loc in WMI (un serviciu este oprit, in
hard disk este scos, etc. )
 Pentru a folosii ManagementEventWatcher trebuie
urmati urmatorii pasi:
 Creati un obiect nou de tip ManagementEventWatcher
 Asociati un EventQuery obiectului creat anterior
 Apelati metoda WaitForNextEvent. Aceasta metoda intoarce un
obiect de tip ManagementBaseObject.
 Puteti oprii asteptarea de notificari apeland metoda Stop
din ManagementEventWatcher
__InstanceCreationEvent
__InstanceDeletionEvent
__InstanceModificationEvent