Cursuri Paw

Programarea Aplicațiilor
Windows – curs 1
Prof. univ. dr. Cristian CIUREA

Departamentul de Informatică și Cibernetică Economică
Academia de Studii Economice București
cristian.ciurea@ie.ase.ro
1
Agenda
1. Structură evaluare
2. Platforma .NET
3. Diferențe C++ vs. C#
4. Tipuri de date în C#
5. Boxing / unboxing
6. Transferul parametrilor
7. Masive în C#
8. Colecții în C#
2
Evaluare
• seminar = 40%
• lucrare calculator = 30%
• prezentare proiect = 10%
• curs = 60%
• examen la calculator = 60%
Detalii la http://acs.ase.ro/paw
3
Platforma .NET
VB.NET Managed C++ C# Alte limbaje C#
CLS - Common Language Specifications
Web Services/Web Forms Windows Forms
Data si XML
Base Class Library
CLR - Common Language Runtime

(debug, exception, type checking, JIT
compiler, garbage collector)
4
Platforma .NET
Sursa
C# / J# / Managed C++, VB
.NET
Compilare – csc.exe, vbc.exe, cl.exe
IL – Interpreted Language
Procedura de asamblare – csc.exe,

vbc.exe, cl.exe
PE – Portable Executable
(EXE sau DLL)
Assembly
Interpretat de CLR
5
Mixed Programming
namespace Math{
public class BasicOp{
public static double Add(double op1, double
C# csc /t:library math.cs
op2){
return op1 + op2;
math.dll
}
public static double Multiply(double op1,
double op2){
return op1 * op2;
} Imports Math
}
} Imports System
VB
Module MathTest
Sub Main()
Dim vb1 As Double = 20
vbc /r:math.dll mathtest.vb
Dim vb2 As Double = 30
Console.WriteLine("Suma celor 2 variabile este {0}, iar

mathtest.exe produsul este {1}.", BasicOp.Add(vb1, vb2),
BasicOp.Multiply(vb1, vb2))
End Sub
End Module
6
Diferențe C++ vs. C#
1. În C++ se definesc metode și variabile la

nivel global, iar în C# se definesc metode și
variabile doar în clase și structuri.
2. În C++ se utilizează referințe și pointeri,

în C# se utilizează referințe, iar pointerii se
utilizează doar în modul de lucru “unsafe”.
7
unsafe
{
int* ptr1, ptr2;
ptr1 = &var1;
ptr2 = ptr1;
*ptr2 = 20;
}
csc.exe C:\pointeri.cs /unsafe
8
3. În C++ tipul șir de caractere nu este

implementat ca tip fundamental. În C#
tipul șir de caractere este introdus prin
clasa String, care este derivată din clasa
Object și are următoarele caracteristici:
- este o clasă sealed, adică din ea nu mai
poate deriva o altă clasă;
- este immutable, adică un obiect odată
creat nu mai poate fi modificat.
9
4. În C++ este permisă moștenirea

multiplă (clasa Pegas era derivată din clasa
Pasăre și clasa Cal). În C# nu este permisă
moștenirea multiplă la nivel de clasă
concretă, dar este permisă derivarea dintr-
o clasă și mai multe interfețe.
class Urs: Animal, ICloneable,

IComparable //clasa Urs este derivata
din clasa Animal si interfetele
ICloneable si IComparable
10
C++ vs. C#
• obiecte gestionate prin • obiecte gestionate doar
valoare și referințe; prin referințe;
• o clasă poate conține • pointerii din C++ definiți cu
atribute dinamice * sunt considerați unsafe si
gestionate de pointeri; sunt indicați doar pentru
• destructorul are rol de a lucru cu COM-uri;
dezaloca spațiul ocupat și • dezalocarea memoriei se
pentru a evita memory face de către GC din CLR;
leak-uri; • operatorul = nu se mai
• necesitate definire supraincarca;
operator = și constructor • operatorul = implicit
copiere pentru a evita realizeaza shallow copy;
copierea implicită; • constructorul de copiere
• string gestionat prin char*; necesar pentru a face deep
copy;
• un nou tip valoric – string;
11
Tipuri de date în C#
a) tipuri valorice, care sunt manipulate

direct prin numele lor; tipurile valorice
includ tipurile de bază și cele introduse prin
“struct” și “enum”.
b) tipuri referențiale, care sunt

manipulate prin referințe; tipurile
referențiale includ tipurile introduse prin
“class”, “interface” și “delegate”.
12
Tipuri de date în C#
• struct example:
struct Student
{
public int cod;
private string nume;
public bool integralist;
};
• enum example:
enum Importance
{
None, Regular, Important, Critical
};
13
Boxing / unboxing
Trecerea din tip valoric în tip referențial și

invers se face prin împachetare (boxing) și
despachetare (unboxing).
int i = 123;
object o = i; //boxing
int j = (int)o; //unboxing
14
Boxing / unboxing
class BoxUnbox
{ STIVA HEAP
static void Main()
{ 4 octeti : 123
int i = 123;
object obj= i; referinta 4 octeti: 123
int j = (int)obj;
4 octeti : 123
}
}
15
Pointeri/Referințe – Transfer parametrii
• subprogramale pot primi parametrii prin

valoare sau prin referință;
• prin valoare => copierea valorii
parametrului pe stiva funcției;
• prin referință => copierea adresei
parametrului pe stiva funcției;
• transferul parametrilor prin pointeri este
considerat unsafe de către compilator.
16
Masive în C#
În C#, masivele sunt tipuri referenţiale

derivate din clasa abstractă
System.Array.
Elementele masivelor pot fi de orice tip
suportat (tipuri referenţiale, tipuri valorice,
alte masive) şi sunt accesate prin
intermediul indicilor.
Dimensiunea masivelor este stabilită la
crearea acestora (la rulare) şi nu poate fi
modificată pe parcurs. Limbajul suportă
atât masive unidimensionale, cât şi
multidimensionale. 17
Masive în C#
SINTAXA: tip_date [ ] nume_masiv;

• reprezintă colecții indexate de obiecte;
• diferit de masivul din C/C++;
• un obiect derivat din clasa Array;
• moștenește o serie de metode:
• BinarySearch()
• Clear()
• CopyTo()
• Sort()
• Clone()
• moștenește o serie de proprietăți:
• Length 18
Masive în C#
Vectorii de tipuri valorice – numele

vectorului este o referință, iar la capătul
referinței sunt valori.
int [] v;
v=new int[4];
v=new int[4] {1,2,3,4};
v={1,2,3,4};
19
Masive în C#
Vectorii de obiecte – numele vectorului este

o referință, iar la capătul referinței sunt
alte referințe la zone de memorie statică în
care au fost alocate și instanțiate obiecte.
Persoana [] p;
p=new Persoana[4];
p=new Persoana[4] {p1,p2,p3,p4};
20
Masive în C#
STIVA HEAP
int [ ] vect; referinta null

vect = new int[4]; referinta 16 octeti: 0,0,0,0
int [ ] vect2 = {1,2,3,4}; referinta 16 octeti: 1,2,3,4
int [ ] vect3 = new int[4] {1,2,3,4}; referinta 16 octeti: 1,2,3,4
Pers p1; referinta null
Pers [ ] vPers; referinta null

vPers = new Pers[4]; referinta 16 octeti: null, null, null, null
referinta 16 octeti: @ @ @ @
vPers = new Pers[4] {p1,p2,p3,p4};
Pers p1
Pers p2
Pers p3
Pers p4 21
Masive în C#
Masivele bidimensionale:
int [,] mb1 = new int[2,3];

int [,] mb2 = {{1,2},{3,4},{5,6}};
La declararea unui masiv bidimensional,

dimensiunile se specifică la alocarea cu
operatorul “new” sau se deduc din lista de
inițializatori.
22
Masive în C#
Masiv în scară (jagged sau în zig-zag)
int [][] ms = new int[3][];
Masivul în scară necesită la alocare doar

precizarea numărului de linii, efectuând
alocări doar pentru liniile respective.
Ulterior se fac alocări pentru fiecare linie în
parte, acestea putând avea dimensiuni
diferite.
23
Colecții în C#
Vectorii au dezavantajul că au dimensiune

fixă; chiar dacă dimensiunea se specifică la
execuție și nu la compilare, ea tot fixă
rămâne.
Student[] vs = new Student[3] {s1, s2, s3};
Colecțiile sunt redimensionabile dinamic,

ele alocându-se element cu element.
ArrayList lista = new ArrayList();

24
Colecții în C#
Elementele unui vector sunt de un anumit

tip, în timp ce elementele unei colecții sunt
de tip generic “object”; rezultă că o colecție
poate conține elemente de orice tip, cu
condiția ca toate elementele colecției să fie
de același tip.
lista.Add(s1);
lista.Add(s2);
lista.Add(s3);
lista.Add(s4);
25
Colecții în C#
Cele mai utilizate colecții sunt: ArrayList

(lista), SortedList (map), Queue (coada) și
Stack (stiva).
Atât vectorii, cât și colecțiile pot fi parcurse
cu “foreach”, cât și cu “for”, dimensiunea
vectorului fiind dată de proprietatea
Length, iar a colecției de proprietatea
Count.
26
Colecții în C#
for (int i = 0; i < v.Length; i++)

{
Console.WriteLine("Lungimea liniei {0}
este {1}", i, v[i].Length);
}
foreach (Animal a in z1.AnimalList)

{
Console.WriteLine(a.Name.ToString());
}
27
Bibliografie
[1] I. Smeureanu, M. Dârdală, A. Reveiu – Visual

C# .NET, Editura CISON, București, 2004.
[2] C. Petzold – Programming Microsoft Windows
with C#, Microsoft Press, 2002.
[3] L. O’Brien, B. Eckel – Thinking in C#, Prentice
Hall.
[4] J. Richter – Applied Microsoft .NET Framework
Programming, Microsoft Press, 2002.
[5] http://acs.ase.ro/paw
28
Windows – curs 2
Prof. dr. Cristian CIUREA

1
Agenda
1. Clase în C# (derivare/moștenire)
2. Supraîncărcare operatori
3. Proprietăți
4. Interfețe (ICloneable/IComparable)
5. Clase abstracte
2
Clase
Sintaxă definire:
[tip_acces] [atribute] class

Nume_Clasa [:clasa_baza, interfata_1,
…, interfata_n]
{
tip_acces atribut1;
tip_acces atribut2;
…
tip_acces functie_membra1;
};
3
Clase
tip_acces:
• public – accesibile;
• private – inaccesibile;
• protected – accesibile claselor derivate;
• internal – accesibile claselor din același
assembly;
• protected internal – accesibile
claselor derivate din același assembly;
4
Clase
Atribute constante:
• definite prin const sau readonly;
• NU este permisă modificarea valorii
odată ce au fost inițializate;
• sintaxa:
class Test
{
public const int atribut_1 = 10;
public readonly int atribut_2;
}
5
Clase
Atribute constante definite prin const:

• sunt inițializate doar la definire;
• sunt considerate variabile definite la
nivelul clasei și nu atribute ale unui
obiect (static);
• pot fi accesate prin numele clasei.
6
Clase
Atribute constante definite prin readonly:

• sunt inițializate la definire sau în
constructor;
• reprezintă forma echivalentă a
variabilelor const din C++.
7
Clase
Atribute statice definite prin static:

• definesc atribute ce nu aparțin unui
obiect și pot fi readonly;
• inițializarea se face la definire sau prin
constructor static;
• sunt considerate variabile definite la
nivelul clasei și nu atribute ale unui
obiect (static);
• sunt accesate prin numele clasei.
8
Clase
Atribute statice – sintaxă:
class Test
{
public static int atribut_1 = 10;
public static readonly int atribut_2;
}
9
Clase
Funcții constructor:
• sintaxa:
class Nume_clasa {
public Nume_clasa( ){…}
};
• apel: deoarece obiectele sunt gestionate prin
referințe, crearea unui obiect se face cu
operatorul new:
public static void Main () {
Nume_clasa obiect_1 = new Nume_clasa();
Nume_clasa obiect_2 = new Nume_clasa
(parametrii constructor)
}
10
Clase
Funcții destructor:
• sintaxa:
class Nume_clasa {
~Nume_clasa( ) {…}
};
• rol principal: eliberarea resurselor gestionate
de un obiect (ex: închidere conexiune bază de
date, închidere fișier, etc);
• sunt apelate implicit de către GC;
• NU pot fi apelate explicit;
• pot fi înlocuite cu metoda Dispose() (se
poate apela explicit). 11
Operatori
Supraîncărcare operatori:
• sunt implementați prin funcții statice;
• sunt funcții care se numesc:
operator [simbol]
12
Operatori
operator =
• rol principal: copiază bit cu bit valoarea
zonei de memorie sursă în zona de
memorie a destinației (cele două zone
sunt identice ca structură și tip);
• în cazul obiectelor C#, copiază valoarea
referinței obiectului sursă în referința
obiectului destinație.
13
Operatori
Apel explicit operator =

class Nume_clasa {
…
};
public static void Main () {

Nume_clasa obiect_1 = new
Nume_clasa();
Nume_clasa obiect_2(…) = new
Nume_clasa();
obiect_2 = obiect_1;
}
14
Operatori
Restricții supraîncărcare operatori:

• NU schimbă precedența operatorilor;
• NU schimbă asociativitatea;
• conservă cardinalitatea (numărul
parametrilor);
• NU creează operatori noi;
• formele supraîncărcate nu se compun
automat;
• NU se supraîncarcă = . ?: -> new is
sizeof typeof [ ] ( ) += -=
• += este evaluat prin operatorul +
15
Operatori
Supraîncărcare operatori unari ++ și --:

• 2 forme: prefixată și postfixată;
• prin funcție membră statică;
• cele 2 forme (post si pre) sunt tratate
unitar de către compilatorul de C#
pentru că lucrăm cu referințe.
16
Operatori
Supraîncărcare operatori binari +, -, *, /:

• au întotdeauna 2 parametri;
• comutativitatea operației matematice nu
are sens în C# (trebuie definită explicit);
• prin funcție statică publică.
17
Operatori
Supraîncărcare operator cast:

• are întotdeauna 1 parametru;
• numele cast-ului reprezintă tipul
returnat;
• NU are tip returnat explicit;
• prin funcție statică;
• folosit la conversia între diferite tipuri de
date;
• în C# operatorul are 2 forme de
supraîncărcat: explicit sau implicit;
18
Operatori
Supraîncărcare operator [ ] (indexer):

• este o proprietate (se foloseste “get”);
• pentru că nu are nume se notează cu
this;
• este folosit pentru a permite acces în
citire/scriere pe elementele unui șir de
valori din zona privată a obiectului;
• indexul nu este obligatoriu de tip
numeric.
19
Proprietăți
• Proprietățile combină un câmp cu

metodele lui de acces, separând accesul
în citire de cel de scriere.
• Proprietățile sunt întotdeauna publice și
simplifică adresarea câmpurilor private.
20
Proprietăți
• O proprietate se comportă ca o variabilă

care ascunde apeluri de accesori “get” și
“set”.
• O clasă poate conține numai unul sau
ambii accesori pentru un câmp.
• Accesorul “set” primește implicit un
argument “value” care conține valoarea
folosită pentru modificarea câmpului
privat.
21
Proprietăți
• sintaxa:
public tip_atribut nume_proprietate {
get { return … }
set { }
}
• utilizare:
ob1.nume_proprietate = valoare;
valoare = ob1.nume_proprietate;
22
Proprietăți
private int stoc;
public int Stoc

{
get { return stoc; }
set { if (value>=0) stoc=value; }
}
23
Interfețe
• Interfețele separă implementarea unui

obiect de funcționalitatea lui, adică
separă structura unui obiect de modul în
care acesta este folosit.
• Interfețele sunt un fel de clase, care
conțin doar prototipuri de funcții.
Convențional, numele lor începe cu “I”.
24
Interfețe
• Interfețele NU pot fi instanțiate,

deoarece conțin doar prototipuri de
metode.
• Interfețele NU conțin câmpuri, ci doar
metode și, eventual, proprietăți.
• Interfețele NU dispun de constructori și
destructor, nefiind niciodată instanțiate.
25
Interfețe
• clase ce conțin numai funcții abstracte;

• rol de interfață pentru clase care trebuie
să definească o serie de metode
comune;
• un contract între proprietarii mai multor
clase prin care se impune definirea unor
serii de metode comune;
• contractul se încheie prin derivarea din
interfață;
• se definesc prin interface (înlocuiește
class).
26
Interfețe
interface IOperatii {
void Operatie1( );
void Operatie2( );
};
class Baza : IOperatii {

public void Operatie1() {…}
public void Operatie2() {…}
}
27
Interfața ICloneable
• suportă copierea/clonarea obiectelor

unei clase prin crearea unei noi instanțe
a respectivei clase, cu aceeași valoare ca
o instanță existentă;
• este inclusă în namespace-ul System;
• conține un singur membru, respectiv
metoda Clone(), care creează un obiect
nou, reprezentând copia instanței
curente.
28
Interfața ICloneable
public Animal Clone()

{
return (Animal)((ICloneable)this).Clone();
//creeaza o copie a obiectului curent de tip
Animal
}
//metoda Clone() standard/implicita

object ICloneable.Clone()
{
return this.MemberwiseClone(); //creaza o
copie superficiala a obiectului curent
}
29
Shallow copy vs. Deep copy
Shallow copy:
• copiere de adrese între 2 obiecte
• realizată implicit prin operatorul =
Deep copy:
• copiere de conținut între 2 obiecte
• realizată explicit prin metode specializate
(constructor copiere, Clone(), etc.)
30
Shallow copy vs. Deep copy
STIVA HEAP
Auto a1; referinta null

Auto a2 = new Auto(); referinta X octeti: valori
Shallow copy
referinta
a1 = a2
referinta X octeti: valori

a1 = new Auto(a2)
Deep copy
a1 = (Auto)a2.Clone()
31
Interfața IComparable
• definește o metodă generalizată de

comparare, pe care o clasă o
implementează pentru a-și ordona sau sorta
obiectele;
• este inclusă în namespace-ul System;
• conține metoda CompareTo(), care
compară instanța curentă cu un alt obiect
de același tip și returnează un întreg care
indică dacă instanța curentă precede,
urmează sau se află pe aceeași poziție cu
celălalt obiect.
32
Interfața IComparable
A.CompareTo(B) poate fi:

• < 0 => A precede B;
• > 0 => A urmează B;
• = 0 => A și B se află pe aceeași poziție.
33
Clase abstracte
• Clasele abstracte se definesc doar în

scopul de a deriva din ele alte clase.
• O clasă abstractă nu poate fi instanțiată.
• Clasele abstracte pot să conțină metode
abstracte, care nu au implementare în
clasa abstractă, ci în clasa derivată.
• O clasă abstractă presupune că un obiect
al clasei nu poate fi instanțiat, dar se pot
realiza derivări ale acestuia.
34
Clase sealed
Clase sealed (închise):

• NU este permisă derivarea claselor
sealed;
sealed class Baza {

int atribut1;
…
};
class Derivata : Baza { }
35
Clase abstracte vs. Interfețe
Clase abstracte:
• conțin metode abstracte + atribute +
metode non-abstracte;
• o clasă poate deriva doar o clasă de bază
(abstractă sau nu);
• poate fi utilizată ca reference type.
Interfețe:
• conțin doar metode abstracte;
• o clasă poate deriva mai multe interfețe;
• poate fi utilizată ca reference type.
36
Bibliografie

Hall.
37
Windows – curs 3
Prof. dr. Cristian CIUREA

1
Agenda
1. Conceptul de delegate
2. Evenimente
3. Introducere în Windows Forms
4. Exemplificare aplicație Windows
2
Delegate
Delegate este tipul asociat unui obiect

care încapsulează o referință la o metodă și
este echivalentul conceptului de pointer de
funcție în C++.
3
Delegate
DELEGATE:
• un nou tip de referință în C#
delegate tip_return nume_referinta(lista
parametri);
public delegate void FireAlarmDelegate(object
sender, EventArgs e);
• echivalent pointerului la funcție din C++

tip_return (*nume_pointer) (lista parametri);
• facilitează definirea pointerilor la functii
nume_referinta pFunctie;
4
Delegate
Referința poate fi modificată dinamic,

delegatul permițând apelul mai multor
implementări ale unor metode care au
același prototip.
private void btn1_Click(object sender, EventArgs e)
{
MessageBox.Show("S-a facut click pe buton!");
}
private void MetodaMea(object sender, EventArgs e)

{
MessageBox.Show("Click prin MetodaMea()");
} 5
Delegate
Delegatul permite legarea întârziată (late

binding), adică amânarea precizării
funcției de apelat până la momentul
execuției.
btn1.Click += new EventHandler(btn1_Click);
btn1.Click -= new EventHandler(btn1_Click);
btn1.Click += new EventHandler(MetodaMea);
6
Evenimente
O clasă eveniment înglobează:

• o instanță de delegate, căreia i se pune
în față “event”;
public event FireAlarmDelegate FireAlarmEvent;
• o funcție care activează delegatul, adică

apelează o listă de funcții.
public void SunaAlarma(EventArgs e)
{
FireAlarmEvent(this, e);
}
7
Evenimente
EVENIMENT:
• reprezintă un vector/listă de delegați
(pointeri de funcții)
event tip_delegate nume_event;
• facilitează execuția tuturor funcțiilor printr-
un singur apel
nume_event([parametrii]);
• suportă operatorii aritmetici += și -=
pentru adăugare/ștergere de delegați din
eveniment
nume_event += new TipDelegate(metoda);
8
Evenimente
Fără folosirea delegatului, evenimentul ar fi

fost legat de o clasă și de numele unei
singure metode pe care trebuie să o
apeleze.
Prin utilizarea delegatului, mai multe clase
pot subscrie la același eveniment și pot
folosi metode denumite diferit, deoarece
apelul lor se realizează prin
pointer/referință.
9
Evenimente
• un eveniment reprezintă un mesaj trimis de

un obiect pentru a anunța o acțiune (user
interaction - mouse click, button click sau
program logic – funcție din program).
• în modelul de tratare a evenimentului din
.NET, obiectul care lansează evenimentul nu
știe ce obiect sau ce metodă va primi și va
gestiona (handle); din acest motiv este
nevoie de un element intermediar între
sursă și destinație – delegat (pointer la
funcție).
10
Evenimente
Pentru a lansa un eveniment este nevoie de

3 componente:
• obiectul ce lansează event-ul;
• tip delegat ce definește event-ul;
• obiectul ce definește conținutul
mesajului.
11
Evenimente
12
Evenimente
Tratarea unui eveniment se poate face:
• prin atașarea unei metode la delegatul
specific evenimentului:
MouseDown += new
MouseEventHandler(MetodaMea);
• prin suprascrierea unei metode protected

moștenită din clasa de bază:
protected override void
OnMouseDown(MouseEventArgs e)
{
base.OnMouseDown(e);
//...
13
}
Evenimente
Pentru a oferi soluții personalizate de

tratare a evenimentului se definește o clasă
de argumente derivată din EventArgs:
public class FireAlarmEventArgs : EventArgs

{ … }
14
Evenimente
Funcția care activează delegatul devine:
public void SunaAlarma(FireAlarmEventArgs e)

{
FireAlarmEvent(this, e);
}
15
Evenimente
Metoda pentru abonare la eveniment din
clasa care oferă soluții pentru evenimentul
FireAlarm devine:
public void DoSomething(object sender,
FireAlarmEventArgs e)
{
if (e.risc < 5)
{
Console.WriteLine("Alarma incendiu
in camera " + e.camera + " Contactati telefonic
camera!" + "Posibil tigara aprinsa!");
}
else Console.WriteLine("Alarma incendiu in
camera " + e.camera + " Contactati departamentul
pompieri. " + "Evacuati cladirea!");
}
16
Introducere în Windows Forms
Sub biblioteca de clase Microsoft Foundation

Classes se întâlnesc aplicații Windows cu
următoarele tipuri de vizualizări:
• Forms (formular), specializată pentru
introducere date într-o machetă;
• TreeView (arborescentă), specializată în
afișarea structurilor expandabile de date;
• EditView (editare), specializată în lucrul cu
texte;
• View (vizualizare generică), specializată în
reprezentări grafice.
17
Atât formularul, cât și controalele aferente

au o serie de proprietăți și evenimente.
Cele mai importante proprietăți ale
obiectului Form sunt:
• Name,
• Text,
• BackgroundImage,
• BackColor,
• Font.
18
Cele mai importante evenimente ale

obiectului Form sunt:
• Load,
• Paint,
• MouseDown,
• MouseUp,
• MouseMove,
• DragEnter,
• DragDrop,
• KeyPress.
19
Clasa Form, fiind derivată din

System.Windows.Forms.ContainerControl,
se comportă ca un container care poate
susține diferite controale (TextBox, Label,
Button, etc.).
20
Pentru adăugarea unui control pe formular:

• declararea în clasa Form a unei referințe:
private Button btn;
• instanțierea controlului:
btn = new Button();

btn.Text = "Click aici";
btn.Size = new Size(60,40);
btn.Location = new Point(80,100);
21
Pentru adăugarea unui control pe formular:

• adăugarea controlului la colecția de
controale a formularului:
Controls.Add(btn);
• atașare metode tratare evenimente:
btn.Click += new EventHandler(btn_Click);
22
Compilare linie de comandă:
csc /t:winexe form1.cs
csc /t:winexe /r:System.dll

/r:System.Windows.Forms.dll
/r:System.Drawing.dll form1.cs
23
24
Bibliografie

Hall.
25
Windows – curs 6
Conf. dr. Cristian CIUREA

1
Agenda
1. Lucrul cu fișiere text

2. Serializare/Deserializare
3. Parsare/Generare XML
2
Citire fișiere text
În C# se folosește clasa Stream din care a

fost derivată clasa FileStream pentru a-i
adăuga clasei Stream funcțiile necesare
citirii și scrierii din/în fisiere text.
Citirea dintr-un fișier text se realizează
astfel:
• se include biblioteca corespunzătoare:
using System.IO;
3
• se creează o instanță a clasei FileStream:

FileStream fisier = new
FileStream("fisier.txt", FileMode.Open,
FileAccess.Read);
FileMode specifică ce trebuie să facă

FileStream-ul cu fișierul atunci când îl
accesează și are următoarele opțiuni: Append,
Create, CreateNew, Open, OpenOrCreate,
Truncate.
FileAccess specifică privilegiile respectivului
fișier și are opțiunile: Read, ReadWrite, Write. 4
• se creează o instanță a clasei

StreamReader, derivată din TextReader:
StreamReader sr = new StreamReader(fisier);
Există patru posibilități de citire dintr-un fișier:

Read(), ReadBlock(), ReadLine(),
ReadToEnd().
string s = sr.ReadToEnd();
• se închid stream-ul și fișierul:

sr.Close();
fisier.Close(); 5
Scriere fișiere text
Scrierea într-un fișier text se realizează

astfel:
• se include biblioteca corespunzătoare:
using System.IO;
• se creează o instanță a clasei FileStream:
FileStream fisier = new
FileStream("fisier.txt", FileMode.Create,
FileAccess.Write);
• se creează o instanță a clasei
StreamWriter, derivată din TextWriter:
StreamWriter sw = new
StreamWriter(fisier); 6
Scriere fișiere text
Exista două posibilități de scriere într-un fișier

text: Write(), WriteLine().
sw.Write(“Hello”);
• se închid stream-ul și fișierul:

sw.Close();
fisier.Close();
7
Serializare/Deserializare
Salvarea datelor într-un fișier binar se face

prin serializare.
Serializarea este o metodă ce permite
transformarea unui obiect într-o secvență de
octeți din care să poată fi refăcut ulterior
obiectul original.
Serializarea permite unui obiect să fie
convertit într-un flux de date, care apoi este
salvat într-un fișier binar.
8
Operația de serializare presupune

parcurgerea etapelor:
• declararea unei clase ca fiind serializabilă,
prin adăugarea înaintea definiției clasei a
atributului [Serializable]
• adăugarea bibliotecilor corespunzătoare:
using System.IO;
using System.Runtime.Serialization.
Formatters.Binary;
9
• instanțierea unui obiect din clasa

FileStream:
FileStream fileStream = new
FileStream("stud.dat", FileMode.Create,
FileAccess.Write);
BinaryFormatter:
BinaryFormatter bf = new BinaryFormatter();
10
• apelul metodei Serialize() din clasa

BinaryFormatter:
bf.Serialize(fileStream, lista);
• închiderea stream-ului:
fileStream.Close();
11
Procesul invers de citire a unui obiect serializat

pentru a-i reface starea originală se numește
deserializare.
Operația de deserializare presupune
parcurgerea etapelor:
FileStream:
FileStream fileStream = new
FileStream("stud.dat", FileMode.Open,
FileAccess.Read);
12

BinaryFormatter:
BinaryFormatter bf = new BinaryFormatter();
• apelul metodei Deserialize() din clasa

BinaryFormatter:
ArrayList lista =
(ArrayList)bf.Deserialize(fileStream);
• închiderea stream-ului:
fileStream.Close();
13
Parsare/Generare XML
Citirea dintr-un fișier XML se poate face

utilizând metoda Read() din clasa abstractă
XmlReader din namespace-ul System.Xml.
Pașii pentru citire și parsare fișier XML:
StreamReader:
StreamReader sr = new
StreamReader("nbrfxrates.xml");
• citirea conținutului fișierului:
string str = sr.ReadToEnd();
14
• obținerea unui obiect din clasa XmlReader

prin apelul metodei Create():
XmlReader reader = XmlReader.Create(new
StringReader(str));
• prelucrarea obiectului din clasa XmlReader:

while (reader.Read()) {...}
15
Pentru generarea unui fișier XML se parcurg

următorii pași:
MemoryStream:
MemoryStream memStream = new
MemoryStream();

XmlTextWriter:
XmlTextWriter writer = new
XmlTextWriter(memStream, Encoding.UTF8);
16
• apelul metodelor WriteStartElement(),

WriteEndElement(), WriteValue(),
WriteAttributeString() din clasa
XmlTextWriter:
writer.WriteStartElement("xml:CursEUR");
writer.WriteAttributeString("valuta",
"EUR");
writer.WriteValue(tbEUR.Text);
writer.WriteEndElement();
17
• extragerea într-un string a conținutului

obiectului din clasa MemoryStream și scrierea
într-un fișier:
string xmlString = Encoding.UTF8.
GetString(memStream.ToArray());
File.WriteAllText("fis.xml", xmlString);
• apelul metodei Close() pentru obiectele

XmlTextWriter și MemoryStream:
writer.Close();
memStream.Close();
18
Bibliografie

Hall.
19
Windows – curs 5

1
Agenda
1. Gestiune evenimente generate de mouse

2. Evenimente generate de tastatură
3. Acces la câmpuri prin acceleratori
4. Gestiunea unitară a controalelor
5. Transfer date între formulare
2
Evenimente generate de mouse
Controalele aflate pe un formular

interceptează activitatea mouse-ului dacă
au proprietățile “Enabled” și “Visible” setate
pe “true”.
this.Enabled = true;
this.Visible = true;
3
• MouseDown, corespunzându-i funcția

de tratare “OnMouseDown”, moștenită
din clasa “Control”;
protected override void OnMouseDown

(MouseEventArgs e)
{
base.OnMouseDown(e);
}
4
• MouseUp, corespunzându-i funcția de

tratare “OnMouseUp”;
protected override void OnMouseUp

(MouseEventArgs e)
{
base.OnMouseUp(e);
}
5
• MouseMove, corespunzându-i funcția

de tratare “OnMouseMove”;
protected override void OnMouseMove

(MouseEventArgs e)
{
base.OnMouseMove(e);
}
6
• MouseWheel, corespunzându-i funcția

de tratare “OnMouseWheel”.
protected override void OnMouseWheel

(MouseEventArgs e)
{
base.OnMouseWheel(e);
}
7
Fiecare funcție de tratare a unui eveniment

generat de mouse conține un parametru de
tip “MouseEventArgs” ce furnizează
informații despre evenimentul produs:
• X și Y, coordonatele mouse-ului la
momentul producerii evenimentului;
• MouseButtons, indică ce butoane ale
mouse-ului au fost acționate;
• Clicks, indică dacă s-a efectuat single
sau double click ;
• Delta, indică sensul și dimensiunea
deplasării rotiței mouse-ului. 8
Aplicație de tip Paint – desenare cu mouse-
ul pe formular
9
Evenimente generate de tastatură
Există trei evenimente legate de folosirea

tastaturii:
• KeyDown
• KeyPress
• KeyUp
Evenimentele KeyDown si KeyUp se
declanșează la apăsarea, respectiv relaxarea
unei taste, iar evenimentul KeyPress se
produce la apăsarea unei taste, dar după
KeyDown și numai dacă apăsarea tastei
generează o valoare de tip caracter (nu și în
cazul apăsării tastelor funcționale).
10
Blocul de argumente al funcției de tratare

este de tip “KeyPressEventArgs”, care are
următoarele proprietăți:
• Handled, care precizează dacă
evenimentul se consideră deja tratat
(true/false);
• KeyChar, care specifică caracterul
aferent tastei apăsate ce a produs
evenimentul.
11
Aplicație TextBox numeric – validare

introducere date
12
Acces la câmpuri prin acceleratori
Acceleratorii reprezintă shortcut-uri

aferente diverselor butoane sau opțiuni din
meniurile unei aplicații Windows, astfel
încât funcțiile aferente evenimentelor Click
asociate controalelor pentru care s-au
definit acceleratorii să se apeleze prin
apăsarea tastei corespunzătoare.
13
Acces la câmpuri prin acceleratori
Definirea unui accelerator se face prin

introducerea semnului „&” în cadrul
proprietății Text pentru setarea denumirii
aferente controlului respectiv.
De exemplu, pe opțiunea File din cadrul
unui meniu, pentru a permite apelul
respectivei opțiuni prin apăsarea tastelor
Alt și apoi F, proprietatea Text va avea
valoarea &File.
14
Gestiunea unitară a controalelor
Pentru tratarea unitară a anumitor

controale de pe formular (ex. TextBox), se
recomandă utilizarea masivelor de referințe
sau a colecțiilor.
ArrayList listTextBox = new ArrayList();

listTextBox.Add(tbDenumire);
listTextBox.Add(tbPret);
listTextBox.Add(tbCantitate);
listTextBox.Add(tbTotal);
15
Transfer date între formulare
Form1:
ArrayList listProd = new ArrayList();
Form2 frm = new Form2(listProd);
frm.ShowDialog();
Form2:
ArrayList lista2;
public Form2(ArrayList lista1)
{
InitializeComponent();
lista2 = lista1;
} 16
Bibliografie

Hall.
17
Windows – curs 6

1
Agenda
1. Lucrul cu meniuri
2. Validarea datelor
3. Gestiunea excepțiilor
2
Meniuri
În C# există două tipuri de meniuri:

• principale, inserabile prin controlul
MenuStrip (sau MainMenu în funcție de
versiunea de Visual Studio);
• contextuale, inserabile prin controlul
ContextMenuStrip (sau ContextMenu în
funcție de versiunea de Visual Studio).
3
Meniuri
Elementele componente ale unui meniu

(principal sau contextual) sunt:
• MenuItem
• ComboBox
• Separator
• TextBox
4
Meniuri
• Meniurile contextuale se activează după

execuția programului, la click dreapta pe
mouse.
• Meniurile contextuale pot fi atașate
unuia sau mai multor controale.
• În general, un meniu contextual se
atașeaza simultan mai multor controale
pentru ca fiecare control să beneficieze
de opțiunile oferite de meniu.
5
Meniuri
Atașarea meniului la un control se face prin

punerea numelui meniului contextual dorit
în proprietatea “ContextMenuStrip” a
controlului la care se dorește atașarea
meniului.
În cazul atașării meniului la mai multe
controale, se verifică proprietatea
“SourceControl” pentru a identifica
controlul care a activat meniul.
6
Meniuri
ToolStrip este clasa de bază abstractă

pentru clasele MenuStrip, StatusStrip și
ContextMenuStrip.
7
Meniuri
În cadrul unui control ToolStrip se pot

adăuga următoarele componente:
• ToolStripButton
• ToolStripSeparator
• ToolStripLabel
• ToolStripDropDownButton
• ToolStripSplitButton
• ToolStripTextBox
• ToolStripComboBox
8
Meniuri
Controlul StatusStrip înlocuiește controlul

StatusBar și aduce în plus opțiuni de
design, precum și proprietatea “Spring”
care permite unui ToolStripStatusLabel să
ocupe tot spațiul disponibil.
statusStrip1.LayoutStyle =
ToolStripLayoutStyle.Table;
9
Meniuri
În cadrul unui control StatusStrip se pot

adăuga următoarele componente:
• ToolStripStatusLabel
• ToolStripDropDownButton
• ToolStripSplitButton
• ToolStripProgressBar
10
Validarea datelor
Validarea datelor este:

• simplă, prin punerea pe true a
proprietății CausesValidation a unui
control se solicită ca în momentul sosirii
pe control să se declanșeze funcția de
validare asociată controlului respectiv.
• încrucișată, folosită în cazul validării
simultane a mai multor controale, în
situația în care fiecare control cere și
așteaptă să fie validat controlul
precedent. 11
Validarea datelor
Validarea simplă presupune execuția

funcțiilor declarate pentru tratarea
evenimentelor Validating și Validated.
Evenimentul Validating se produce la
încercarea de părăsire a unui control
pentru a trece pe un alt control care are
proprietatea CausesValidation pe true.
12
Validarea datelor
Evenimentul Validated se declanșează după

Validating, dar nu înainte de părăsirea
controlului și numai dacă nu a fost revocat
evenimentul Validating.
Validarea simplă este utilă doar pentru
testarea izolată a unui singur control.
13
Validarea datelor
În cazul validării încrucișate, toate

controalele și formularul trebuie să aibă
proprietatea CausesValidation pe false
pentru a nu declanșa validări individuale.
Gestiunea validării mai multor controale
simultan se realizează cu ajutorul unui
control de tip ErrorProvider.
14
Gestiunea excepțiilor
Gestiunea situațiilor neprevăzute care apar

în momentul execuției unui program este
implementată în C# prin intermediul
excepțiilor.
15
• Excepție – situație în care prelucrarea

anumitor date de intrare nu este
gestionată sau nu este posibilă (ex:
împărțire la 0, citire în afara unui masiv)
• Permite gestiunea situațiilor excepționale
care conduc la terminarea imediată a
programului
• Necesară pentru a realiza programe
robuste și fiabile
• Implementată prin try, catch și throw
• Permite gestiunea erorilor de sistem si a
erorilor definite de programator 16
Din punctul de vedere al bibliotecii de

clase, erorile sunt împărțite, pe cel mai
înalt nivel, în două categorii:
• excepții de aplicație (Application
Exception), generate de aplicațiile
utilizator;
• excepții de sistem (System Exception),
generate de către mașina virtuală CLR.
Ambele sunt derivate din clasa generică
Exception.
17
Cea mai simplă modalitate de a gestiona o

eroare constă în gruparea instrucțiunilor
suspectate că ar produce respectiva eroare
într-un bloc “try”. Tratarea acestei erori se
face într-un bloc “catch”, asociat blocului
“try”.
Exceptiile necesită tratamente diferite în
funcție de tipul lor. Este important să
identificăm tipul erorii și să oferim mai
multe blocuri “catch”, conținând cod de
tratare distinct pentru fiecare tip de eroare
în parte. 18
try
{ //secventa prelucrari }
catch(exceptie_tip_1)
{ //secventa prelucrari specifice }
catch(exceptie_tip_2)
{ //secventa prelucrari specifice }
catch(Exception)
{ //secventa prelucrari generale }
finally
{ //secventa prelucrari obligatorii } 19
blocul try{…}
• contine secvența de prelucrări care
generează excepții;
• are asociat minim un bloc “catch”;
• între blocul “try” și blocurile “catch”
asociate nu există alte instrucțiuni;
• un bloc “try” trebuie să aibă asociat cel
puțin un bloc “catch” sau măcar un bloc
“finally”.
20
blocul catch(tip_exceptie exc)

• gestionează o excepție de tipul anunțat;
• tip_exceptie reprezintă instanța unei clase
derivate din Exception (ArithmeticException,
DivideByZeroException, etc.)
blocul catch(Exception exc)
• gestionează toate tipurile de excepții
21
blocul finally{…}
• conține secvența de prelucrări care se
execută indiferent dacă blocul “try” a
generat sau nu excepții și dacă acestea
au fost sau nu tratate în blocurile “catch”
• blocul “finally” este unic, executându-se
întotdeauna, indiferent care din blocurile
“try” sau “catch” s-a executat. El
urmărește aducerea la o stare coerentă
și consistentă a aplicației.
22
Blocurile “catch” sunt definite în ordine

crescătoare a generalității excepțiilor
tratate
try { … }
catch(exceptie_tip_1) {…}
catch(exceptie_tip_2) {…}
…
catch(Exception e) {…}
23
Rezolvarea unei excepții se realizează prin

căutarea unui bloc “catch” specific erorii
produse și, numai dacă acesta nu există, se
caută blocuri “catch” asociate excepțiilor
plasate din ce în ce mai sus în ierarhia de
derivare.
Se recomandă plasarea blocurilor “catch” în
ordinea de la erori specifice către erori din
ce în ce mai generale.
24
Instrucțiunea “throw” este folosită pentru a

declanșa în mod explicit o anumită excepție
definită de programator.
Nu este indicat un apel “throw” din
interiorul unui bloc “finally”, deoarece în
acel moment există deja încă o excepție
care așteaptă să fie tratată.
25
• Blocurile try-catch-finally pot fi incluse în

alte blocuri try
• Programatorul poate defini propriile
excepții prin clase derivate din Exception
• Instrucțiunea throw generează orice tip
de excepție
26
Aplicație preluare informații studenți –
meniuri și validări
27
Bibliografie

Hall.
28
Windows – curs 7

1
Agenda
1. Lucrul cu ferestre multiple (MDI)

2. Controale vizuale complexe (ListView,
TreeView)
2
Lucrul cu ferestre multiple (MDI)
Arhitecturi de aplicații:
• SDI – Single Document Interface
• MDI – Multiple Document Interface
Arhitectura MDI permite utilizatorilor să
lucreze simultan cu mai multe formulare
fără să deschidă o nouă instanță a
aplicației.
3
Aplicație MDI (Multiple Document

Interface):
• mai multe ferestre copil;
• o fereastră cadru părinte, container
pentru ferestrele copil.
4
Pentru a stabili formularul cadru părinte, se

setează proprietatea:
this.IsMDIContainer = true;
În cadrul formularul părinte, se stabilesc

formularele copil:
Form2 copil1 = new Form2();
copil1.MdiParent = this;
Form3 copil2 = new Form3();
copil2.MdiParent = this;
5
Formularele copil pot fi aranjate:

• în cascadă:
this.LayoutMdi(MdiLayout.Cascade);
• orizontal:
this.LayoutMdi(MdiLayout.TileHorizontal);
• vertical:
this.LayoutMdi(MdiLayout.TileVertical);
6
Controale vizuale complexe
Vizualizarea informațiilor de pe un formular

se realizează sub diverse formate:
• liniar (controlul ListView);
• arborescent (controlul TreeView);
• sub formă de raport;
• listă de icon-uri.
7
Vizualizarea liniară – controlul ListView
Controlul ListView are următoarele formate

de vizualizare:
• Details;
• LargeIcon;
• SmallIcon;
• List.
8
Pentru adăugarea coloanelor în cadrul

controlului ListView se accesează
proprietatea Columns -> Collection sau
direct din cod:
listView1.Columns.Add("Observatii");
Denumirile coloanelor sunt vizibile doar în

formatul de vizualizare Details.
9
Elementele unui ListView se numesc item-

uri și sunt obiecte din clasa ListViewItem.
Controlul ListView deține o colecție de
item-uri accesibilă prin proprietatea Items,
care la rândul ei conține o colecție de
subitem-uri accesibilă prin proprietatea
SubItems.
10
Popularea elementelor unui ListView se

realizează:
• static, la momentul proiectării aplicației
– Properties -> Items -> Collections ->
Add – pentru fiecare linie adăugată se
stabilește textul de afișat (colecțiile
Items și SubItems);
• dinamic, la momentul execuției,
preluând datele dintr-o structură de
date.
11
Dacă obiectul ListView are proprietatea

MultiSelect pe true, se permite selecția
mai multor item-uri în vederea prelucrării
multiple a acestora.
Se poate trata evenimentul ItemActivate
pentru prelucrarea unuia sau mai multor
item-uri selectate.
12
Pentru a putea edita un item direct în

ListView, la momentul execuției, se setează
proprietatea LabelEdit pe true.
Pentru a selecta toată linia, nu doar primul

subitem, se setează proprietatea
FullRowSelect pe true.
13
Pentru a menține sortată colecția de item-

uri a ListView-ului, se setează proprietatea
Sorting astfel:
listView1.Sorting = SortOrder.Ascending;
Pentru a permite rearanjarea coloanelor

prin drag&drop se setează proprietatea
AllowColumnReorder pe true.
14
Vizualizarea arborescentă – TreeView
Controlul TreeView este utilizat pentru

afișarea unei colecții în formă arborescentă,
cu posibilitatea expandării sau comprimării
unor nivele din arbore.
Fiecare nod din TreeView este un obiect din
clasa TreeNode. Fiecare TreeNode
stochează o colecție Nodes de noduri fii
aferenți unui nivel al arborelui. Proprietatea
Nodes păstrează colecția de noduri aflată
pe nivelul 0 al arborelui.
15
Principalele proprietăți ale TreeView:

• Nodes – colecția de noduri (obiecte
TreeNode);
• LabelEdit – indică dacă etichetele
nodurilor pot fi editate;
• SelectedNode – indică nodul curent
selectat;
• CheckBoxes – indică dacă fiecare nod va
fi precedat de câte un checkbox.
16
Principalele evenimente ale TreeView:

• AfterSelect – evenimentul implicit al
clasei TreeView care se declanșează
imediat după selecția unui nod;
• AfterLabelEdit – imediat după editarea
etichetei unui nod (pentru validarea
datelor introduse);
• AfterExpand – imediat după expandarea
unui nod.
17
Bibliografie

Hall.
18
Windows – curs 8

1
Agenda
1. Elemente de grafică
2. Previzualizare document
2
Elemente de grafică
Suportul pentru reprezentările grafice este
oferit în C# prin clasa Graphics, având
proprietatea de clasă “sealed”.
Clasa Graphics nu are constructor, obiectele ei
fiind obținute prin:
• utilizarea evenimentului Paint;
protected override void OnPaint(PaintEventArgs e)
{
base.OnPaint(e);
Graphics gr = e.Graphics;
}
• apelul funcției CreateGraphics() specifice
unui control;
Graphics gr = panel1.CreateGraphics();
3
• apelul metodei
Graphics.FromHwnd(this.Handle);
Graphics gr = Graphics.FromHwnd(panel1.Handle);
• apelul metodei statice

Graphics.FromImage(bmp), care pornind
de la o imagine, declarată sub forma
Bitmap bmp, returnează un obiect grafic
asociat acesteia.
Bitmap bmp = new Bitmap(this.Width, this.Height);
Graphics gr = Graphics.FromImage(bmp);
4
Controlul Panel are două funcții importante:

• oferă suportul pentru desenare (canvas),
dispunând de un context grafic și
recunoscând evenimentul Paint;
• acționează drept container, adică este un
control care ține alte controale.
5
După ce este creat, obiectul Graphics poate fi

utilizat pentru desenarea de linii și forme, text,
sau afișarea și manipularea de imagini.
Principalele obiecte utilizate împreună cu
obiectul Graphics sunt:
• Pen – pentru desenarea de linii, forme,
reprezentări geometrice;
• Brush – pentru umplerea formelor,
imaginilor sau textelor;
• Font – pentru stabilirea formelor utilizate la
desenarea de texte;
• Color – pentru stabilirea culorii. 6
Cele mai uzuale metode ale clasei Graphics
sunt:
• DrawArc(Pen pen, Rectangle rect,
float startAngle, float sweepAngle);
• DrawEllipse(Pen pen, Rectangle rect);
• DrawImage(Image image, Rectangle
rect);
• DrawLine(Pen pen, Point pt1, Point
pt2);
• DrawPie(Pen pen, Rectangle rect,
float startAngle, float sweepAngle);
• DrawRectangle(Pen pen, Rectangle
rect);
• DrawString(string s, Font font, Brush
brush, float x, float y); 7
Cele mai uzuale metode ale clasei Graphics
sunt:
• FillEllipse(Brush brush, Rectangle
rect);
• FillPie(Brush brush, Rectangle
rect, float startAngle, float
sweepAngle);
• FillRectangle(Brush brush,
Rectangle rect);
8
Pen pen = new Pen(Color.Red, 3);

Rectangle rec = new Rectangle(40, 40,
200, 200);
g.DrawEllipse(pen, rec);
g.DrawRectangle(pen, rec);
g.DrawLine(pen, 0, 0, 10, 10);
Brush br = new SolidBrush(Color.Aqua);
g.FillEllipse(br, rec);
g.FillRectangle(br, rec);
g.DrawString("Elipsa",
Form1.DefaultFont, new
SolidBrush(Color.Black), new Point(40,
40)); 9
Previzualizare document
Definițiile pentru clasele și metodele de

imprimare se găsesc în namespace-urile:
• System.Drawing.Printing;
• System.IO;
Clasa PrintDocument gestionează procesul
de imprimare, fiind văzută ca o conexiune
între aplicație și imprimantă. Clasa conține
metoda Print() pentru startarea
procesului de imprimare.
10
Pentru partea de previzualizare este nevoie

de un obiect PrintPreviewDialog, care fie
se aduce din ToolBox, fie se declară prin
program în clasa formei.
Se definește un obiect de tip
PrintDocument:
PrintDocument pd = new PrintDocument();
11
Se face atribuirea:
PrintPreviewDialog1.Document = pd;
În urma acestei atribuiri se consideră că
suportul de afișare nu mai este
imprimanta, ci chiar dialogul de
previzualizare.
La vizualizarea dialogului se declanșează
automat și metoda Print() a
documentului, care declanșează, la rândul
ei, evenimentul PrintPage.
12
PrintDocument pd = new PrintDocument();

pd.PrintPage += new
PrintPageEventHandler(this.pd_print);
PrintPreviewDialog dlg = new
PrintPreviewDialog();
dlg.Document = pd;
dlg.ShowDialog();
13
Bibliografie

Hall.
14
Windows – curs 9

1
Agenda
1. Lucrul cu Clipboard-ul
2. Operația de Drag and Drop
3. Data Binding
2
Lucrul cu Clipboard-ul
Punerea și scoaterea unui obiect în/din

Clipboard presupune ca obiectul să știe să
se transforme în mai multe formate pentru
a se adapta la capacitățile de înțelegere ale
aplicației care îl va prelua din Clipboard.
3
Obiectele se pun în Clipboard printr-un apel

al metodei:
Clipboard.SetDataObject( );
Transferul de date în Windows Forms este
permis pentru clasele care implementează
interfața IDataObject.
Aplicația care folosește obiectele puse în
Clipboard cere mai întâi o referință la
subobiectul IDataObject, invocând
metoda: Clipboard.GetDataObject( );
4
Se definește:
IDataObject o =
Clipboard.GetDataObject();
Având la dispoziție referința la interfața
IDataObject, aplicația se interesează dacă
ceea ce există în Clipboard este de un
anumit tip de obiect sau se poate converti
într-un anumit tip. Astfel, se invocă metoda
GetDataPresent(), având ca parametru
tipul căutat:
bool vb =
o.GetDataPresent(typeof(Bitmap)); 5
Daca se răspunde afirmativ în urma acestui

apel, adică “vb” are valoare “true”, atunci
se poate lansa o cerere de extragere a
obiectului din Clipboard, folosind metoda
GetData():
if (o.GetDataPresent(typeof(Bitmap)))
{
Bitmap img =
(Bitmap)o.GetData(typeof(Bitmap));
g.DrawImage(img,panel1.ClientRectangle);
}
6
Etape lucru cu Clipboard:

• pentru a pune obiecte în Clipboard:
Clipboard.SetDataObject(object);
• pentru a realiza transferul de date între
formulare, clasele trebuie să implementeze
interfața IDataObject;
• pentru a lua obiecte din Clipboard se utilizează
Clipboard.GetDataObject();
• se extrage conținutul prin metoda
IDataObject.GetData();
• înainte de a extrage date din Clipboard le
verificăm dacă sunt de tipul celor cu care
aplicația știe să lucreze
Object.GetDataPresent(format_verificat); 7
Operatia de Drag and Drop
Inițierea operației de Drag and Drop se

face printr-un apel al metodei
DoDragDrop() și se sincronizează cu
evenimentul MouseDown, care oferă
informații detaliate despre poziția mouse-
ului. În urma apelului DoDragDrop() se
stabilesc datele ce fac obiectul drag-ării,
precum și drepturile acordate acestora:
copiere sau mutare.
8
Următorul eveniment care intervine în

operația de Drag and Drop este DragEnter,
declanșat la intrarea în regiunea unui
control care permite droping (are
proprietatea AllowDrop pe “true”). Cel de-
al treilea eveniment este DragDrop și se
generează în momentul relaxării mouse-
ului în timpul derulării operației de dragare.
9
Astfel, prin apelul DoDragDrop() se

stabilește sursa de date ce face obiectul
drag-ării, precum și efectele permise
pentru destinație (Copy sau Move). La
intrarea mouse-ului pe suprafața
controlului destinație (evenimentul
DragEnter) se testează compatibilitatea
formatului datelor dragate cu formatul
destinației posibile.
10
Data Binding
Legarea datelor de interfata utilizator (Data

Binding) poate fi:
• simplă (simple data binding);
• complexă (complex data binding).
Legarea datelor se consideră simplă, dacă
de proprietatea unui control se leagă un
singur element dintr-o colecție, și
complexă, dacă controlul este capabil să
afișeze toată colecția de date.
11
Data Binding
Controalele au o colecție DataBindings, de

tip ControlBindingsCollection. Această
colecție conține obiecte de tip Binding,
reprezentând legături ale diverselor
proprietăți ale controlului cu valori ale unor
variabile.
12
Data Binding
Simple Binding conectează un singur

element dintr-un vector de o singură
proprietate a unui control.
Complex Binding conectează un control
cu întreaga colecție de date. De exemplu,
un GridView afișează o întreagă tabelă
dintr-o bază de date, cu toate câmpurile ei.
De legarea complexă beneficiază doar
controalele orientate pe colecții, precum
ComboBox, ListBox, GridView.
13
Data Binding
Se face diferența dintre:

• legare unidirecțională, când
modificările din sursa de date sunt
operate și în controale, dar modificările
din controale nu au efect asupra datelor
din sursă;
• legare bidirecțională, când modificările
din sursa de date sunt vizibile și în
controale, iar modificările operate în
controale se observă și asupra datelor
din sursa de date. 14
Bibliografie

Hall.
15
Windows – curs 10

1
Agenda
1. Lucrul cu baze de date (partea I)
2
Lucrul cu baze de date
ADO.NET (Active Data Object):

• este o tehnologie de acces la date care
disponibilizează clase, interfețe, structuri
și enumerări pentru accesul la baze de
date sub platforma .NET Framework.
• este parte din biblioteca de clase de bază
incluse în platforma .NET Framework.
3
ADO.NET (Active Data Object):
• este divizată în mod conceptual în
consumatori și furnizori de date;
consumatorii sunt aplicațiile care au
nevoie de acces la date, iar furnizorii
sunt componentele software care
implementează interfața pentru
furnizarea datelor către consumatori.
4
Accesul la comenzi SQL din C# se face
prin:
• interfața ODBC (Open Data Base
Connectivity); este relativ rapidă și
compatibilă cu o mulțime de baze de
date diferite;
• setul de date OLEDB (Object Linking
and Embedding Data Base); pentru
conectare la baze de date SQL Server
este relativ lent;
5
Accesul la comenzi SQL din C# se face
prin:
• SQL Native Client – doar dacă se
accesează baze de date SQL Server
începând cu versiunea 2005 și este
nevoie de noile caracteristici, precum
MARS (Multiple Active Result Sets),
criptare, tip de date XML, etc. În caz
contrar, se recomandă utilizarea
OLEDB/ODBC, cu mențiunea că OLEDB și
ODBC nu acceptă unele dintre noile
caracteristici ale SQL Server.
6
Obiectele prin care se implementează

accesul la o bază de date sunt:
• conexiunea;
• adaptorul;
• setul de date.
Stările unei conexiuni sunt:
• Connecting – în curs de conectare;
• Open – conexiune deschisă;
• Executing – în derularea unei tranzacții;
• Fetching – în timpul unei căutări în baza
de date.
7
Cei mai frecvenți furnizori de date sunt:

• SQL Server .NET Data Provider, folosește
pentru realizarea conexiunii un obiect de
tip SqlConnection definit în
namespace-ul System.Data.SqlClient;
• OLE DB .NET Data Provider, care
folosește un obiect de tip
OleDbConnection definit în
System.Data.OleDb;
• ODBC .NET Data Provider, folosește un
obiect OdbcConnection definit în
System.Data.Odbc. 8
Exemple de “connection strings”:

• BD SQL Server:
"Data Source = server; Initial Catalog
= baza; User ID = cristianciurea;
Password = ********";
• BD Access:
"Provider = Microsoft.ACE.OLEDB.12.0;
Data Source = student.accdb";
9
DataSet – container de date, care poate

conține mai multe obiecte DataTable, câte
unul pentru fiecare tabelă din baza de date.
DataSet dataSet = new DataSet();

DataTable tabela =
dataSet.Tables["student"];
10
DataAdapter – mediază schimburile de date

dintre un DataSet și baza de date, iar
principala metodă, Fill(dataSet, tabela),
încarcă cu date o tabelă dintr-un DataSet.
OleDbDataAdapter adaptor = new

OleDbDataAdapter("SELECT * FROM student",
conexiune);
adaptor.Fill(dataSet, "student");
11
Fiecare DataAdapter mediază transferul

de date între un singur obiect DataTable
din DataSet și rezultatul unei singure
interogări printr-o comandă SQL.
12
DataView – oferă un mod de vizualizare a

unui obiect DataSet, oferind posibilitatea
filtrării datelor dintr-o tabelă. Aceleași
tabele ale unui DataSet pot avea mai multe
vizualizări asociate, reprezentând puncte de
vedere diferite ale unor utilizatori.
DataTable tabela =
DataView dv = new DataView(tabela);
dv.Sort = "nume";
dv.RowFilter = "forma='ZI'"; 13
DataReader – extrage un stream read-

only de date dintr-o sursă. Rezultatele
preluate în urma conectării la baza de date
sunt, fie procesate direct, utilizând o
componentă DataReader, fie sunt plasate
într-un DataSet pentru a fi combinate cu
alte informaţii şi pentru a fi prelucrate
ulterior.
14
Clasele de tip Command (SqlCommand și

OleDbCommand) sunt folosite pentru a
executa o comandă SQL sau proceduri
stocate. Exemple de constructori ale
acestor clase:
OleDbCommand cmd1 = new
OleDbCommand(“SELECT * from student”,
conexiune);
SqlCommand cmd2 = new SqlCommand();
cmd2.CommandText = “SELECT * from
student”;
cmd2.Connection = conexiune; 15
Obiectele de tip Command prezintă o lista

de parametri (Parameters) și pot emite o
tranzacție (Transaction) în cadrul unei
conexiuni (Connection).
16
conexiune.Open();
comanda.Transaction =
conexiune.BeginTransaction();
comanda.CommandText = "INSERT into student
values(?,?,?,?,?,?,?)";
comanda.Parameters.Add("cod",
OleDbType.Integer).Value = codstudent + 1;
comanda.Parameters.Add("nume",
OleDbType.Char, 10).Value = nume;
comanda.ExecuteNonQuery();
comanda.Transaction.Commit();
conexiune.Close(); 17
Comenzile de acces direct la baza de date

sunt de 3 tipuri:
• ExecuteReader, care întoarce o colecție
de linii de date, accesibile linie cu linie;
• ExecuteScalar, care returnează o
singură valoare, de tip generic object;
• ExecuteNonQuery, care nu returnează
nimic, dar execută actualizările asupra
bazei de date.
18
Exemple:
OleDbCommand comanda = new
OleDbCommand(sql, conexiune);
comanda.ExecuteNonQuery();
OleDbDataReader reader =
comanda.ExecuteReader();
cod = Convert.ToInt32(
comanda.ExecuteScalar());
19
Bibliografie

Hall.
20
Windows – curs 11

1
Agenda
1. Lucrul cu baze de date (partea a II-a)

2. Reporting
2
DataSet – container de date, care poate

conține mai multe obiecte DataTable, câte
unul pentru fiecare tabelă din baza de date.

DataTable tabela =
3
DataAdapter – mediază schimburile de date

dintre un DataSet și baza de date, iar
principala metodă, Fill(dataSet, tabela),
încarcă cu date o tabelă dintr-un DataSet.
OleDbDataAdapter adaptor = new

OleDbDataAdapter("SELECT * FROM student",
conexiune);
adaptor.Fill(dataSet, "student");
4
Fiecare DataAdapter mediază transferul

de date între un singur obiect DataTable
din DataSet și rezultatul unei singure
interogări printr-o comandă SQL.
5
DataView – oferă un mod de vizualizare a

unui obiect DataSet, oferind posibilitatea
filtrării datelor dintr-o tabelă. Aceleași
tabele ale unui DataSet pot avea mai multe
vizualizări asociate, reprezentând puncte de
vedere diferite ale unor utilizatori.
DataTable tabela =
DataView dv = new DataView(tabela);
dv.Sort = "nume";
dv.RowFilter = "forma='ZI'"; 6
Entity Framework
Entity Framework (EF) este un

framework open-source de mapare obiect-
relațională (ORM) pentru ADO.NET.
EF a fost parte a .NET Framework, dar
începând cu versiunea 6 (Oct. 2013) s-a
separat de .NET Framework.
Entity Framework este un set de tehnologii
în ADO.NET care sprijină dezvoltarea de
aplicații software orientate spre date.
7
Entity Framework
O instantă a clasei DbContext reprezintă o
combinație de modele și unități de lucru,
care să poată fi utilizată pentru a interoga
dintr-o bază de date și pentru a grupa
modificările care vor fi scrise din nou în
baza de date ca o unitate de lucru.
Clasa DbContext este utilizată de regulă
cu un tip derivat care conține proprietățile
DbSet<TEntity> pentru entitățile rădăcină
ale modelului. Aceste seturi sunt inițializate
automat atunci când instanța clasei
derivate este creată.
8
Entity Framework
Prin convenție, clasa DbContext creează o
bază de date pe baza următoarelor criterii:
• dacă este disponibilă o instanță locală de
SQL Express, atunci baza de date va fi
creată pe acea instanță;
• dacă instanța SQL Express nu este
disponibilă, atunci LocalDb va fi utilizată
dacă aceasta este disponibilă;
• dacă ambele sunt disponibile, atunci se va
utiliza SQL Express;
• baza de date este denumită pe baza
namespace-ului, la care se adaugă
denumirea clasei derivate din DbContext.
9
Entity Framework
10
Reporting
Pentru realizarea de rapoarte în aplicațiile

Windows se poate utiliza controlul
ReportViewer, disponibil începând cu
versiunea .NET Framework 4.0.
11
Reporting
12
Bibliografie

Hall.
13
Windows – curs 12

1
Agenda
1. Controale de utilizator
2
Controale de utilizator
Controalele din Windows Forms sunt
componente reutilizabile care încapsulează
funcționalitățile interfeței cu utilizatorul din
cadrul aplicațiilor Windows.
Windows Forms oferă nu numai o mulțime
de controale gata de utilizare, ci oferă și
infrastructura pentru dezvoltarea propriilor
controale.
Se pot combina controale existente, se pot
extinde controalele existente sau se pot
crea propriile controale personalizate.
3
Controalele din .NET Framework sunt
moștenite dintr-o clasă de bază comună
denumită UserControl.
Această clasă oferă toate funcționalitățile
de bază pentru un control grafic care să fie
utilizat într-un formular Windows.
4
Toate controalele încorporate în platforma
.NET moștenesc aceeași clasă de bază
(UserControl), ceea ce permite crearea de
controale de utilizator personalizate prin
moștenirea din clasa de bază UserControl,
care va furniza automat o serie de
proprietăți și evenimente.
5
Există aproximativ 30 de proprietăți care se
moștenesc din clasa de bază UserControl.
Aceste proprietăți includ toate proprietățile
comune controalelor de bază, cum ar fi
proprietățile de accesibilitate, BackColor,
ForeColor, proprietățile de ancorare și cele
de Dock-ing.
Aceste proprietăți se pot supradefini, dar
cel mai probabil majoritatea vor fi utilizate
așa cum sunt.
6
Un control de utilizator moștenește
aproximativ 40 de evenimente din clasa de
bază UserControl. Aceste evenimente le
includ pe cele mai frecvente, cum ar fi
Load, Resize și Layout. Controlul de
utilizator va include, de asemenea, unele
dintre evenimentele legate de mouse și
tastatură, la un nivel mai scăzut, cum ar fi
Click, DoubleClick, MouseUp și MouseDown.
7
Se pot supradefini aceste evenimente
moștenite, dacă este necesar, dar se
recomandă să fie supradefinită doar
metoda moștenită On<EventName> în loc
să fie supradefinit direct evenimentul de
bază, astfel încât controalele viitoare să
poată beneficia de utilizarea evenimentelor
standard.
8
Prin extinderea clasei de bază
ContainerControl, clasa UserControl
moștenește toate elementele standard de
poziționare și manipulare necesare pentru
un nou control de utilizator.
9
Clasa UserControl oferă posibilitatea de a
crea controale care pot fi utilizate în mai
multe aplicații sau mai multe componente
dintr-o aplicație.
O utilizare eficientă a unui control de
utilizator este preîncărcarea unui
ComboBox sau a unui ListBox cu elemente
statice folosite în mod obișnuit în aproape
orice aplicație (listă de țări, regiuni, orașe,
etc.).
10
Avantajele utilizării unui control de
utilizator:
• reutilizabilitatea codului sursă;
• economie de timp;
• efort mai mic;
• ușurință în identificarea erorilor și fixarea
acestora;
• utilizare eficientă a memoriei.
11
12
Bibliografie

Hall.
13

Cursuri Paw

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Cursuri Paw

Încărcat de

Drepturi de autor:

Formate disponibile

Programarea Aplicațiilor

Prof. univ. dr. Cristian CIUREA

CLS - Common Language Specifications

Web Services/Web Forms Windows Forms

Base Class Library

CLR - Common Language Runtime

Procedura de asamblare – csc.exe,

Console.WriteLine("Suma celor 2 variabile este {0}, iar

1. În C++ se definesc metode și variabile la

2. În C++ se utilizează referințe și pointeri,

3. În C++ tipul șir de caractere nu este

4. În C++ este permisă moștenirea

class Urs: Animal, ICloneable,

a) tipuri valorice, care sunt manipulate

b) tipuri referențiale, care sunt

Trecerea din tip valoric în tip referențial și

• subprogramale pot primi parametrii prin

În C#, masivele sunt tipuri referenţiale

SINTAXA: tip_date [ ] nume_masiv;

Vectorii de tipuri valorice – numele

Vectorii de obiecte – numele vectorului este

int [ ] vect; referinta null

Pers p1; referinta null

Pers [ ] vPers; referinta null

int [,] mb1 = new int[2,3];

La declararea unui masiv bidimensional,

Masiv în scară (jagged sau în zig-zag)

int [][] ms = new int[3][];

Masivul în scară necesită la alocare doar

Vectorii au dezavantajul că au dimensiune

Student[] vs = new Student[3] {s1, s2, s3};

Colecțiile sunt redimensionabile dinamic,

ArrayList lista = new ArrayList();

Elementele unui vector sunt de un anumit

Cele mai utilizate colecții sunt: ArrayList

for (int i = 0; i < v.Length; i++)

foreach (Animal a in z1.AnimalList)

[1] I. Smeureanu, M. Dârdală, A. Reveiu – Visual

Prof. dr. Cristian CIUREA

[tip_acces] [atribute] class

Atribute constante definite prin const:

Atribute constante definite prin readonly:

Atribute statice definite prin static:

Atribute statice – sintaxă:

Apel explicit operator =

public static void Main () {

Restricții supraîncărcare operatori:

Supraîncărcare operatori unari ++ și --:

Supraîncărcare operatori binari +, -, *, /:

Supraîncărcare operator cast:

Supraîncărcare operator [ ] (indexer):

• Proprietățile combină un câmp cu

• O proprietate se comportă ca o variabilă

private int stoc;

public int Stoc

• Interfețele separă implementarea unui

• Interfețele NU pot fi instanțiate,

• clase ce conțin numai funcții abstracte;

class Baza : IOperatii {

• suportă copierea/clonarea obiectelor

public Animal Clone()

//metoda Clone() standard/implicita

Auto a1; referinta null

referinta X octeti: valori