Programare orientată pe obiecte Curs 8

Biblioteca de clase din cadrul de lucru .NET

Biblioteca de clase din cadrul de lucru .NET este o bibliotecă de clase orientate spre
obiecte care asigură toate instrumentele necesare scrierii programelor. Clasele din această
bibliotecă pot fi folosite din orice limbaj .NET deoarece funcţionează la nivelul limbajului IL.
Acest fapt asigură un nivel de interoperabilitate între limbaje. Această bibliotecă este formată
dintr-un set de clase, interfeţe, structuri şi enumerări, conţinute în peste 100 de spaţii de nume.

Exemple de spaţii de nume:

System;
System.Collections;
System.Collections.ArrayList;
System.Threading;

Numele spaţiilor de nume din .NET sunt formate din unul sau mai multe cuvinte, acestea
fiind separate prin “.” .

Exemplu pentru declararea şi utilizarea spaţiilor de nume:

namespace SN1{
class A{
public static void scrie(){
Console.WriteLine("Clasa A din spatiul de nume SN1");
}
};
namespace SN2{
class A{
public static void scrie(){
Console.WriteLine("Clasa A din spatiul de nume SN2");
}
};
namespace SN3{
class A{
public static void scrie(){
Console.WriteLine("Clasa A din spatiul de nume SN3");
}
};
}
}
}

class Program
{
static void Main(string[] args)
{
//SN2.A.scrie();//error C2653: 'SN2' : is not a class or namespace name
SN1.A.scrie();
SN1.SN2.A.scrie();
SN1.SN2.SN3.A.scrie();
}
}
1
Programare orientată pe obiecte Curs 8

Clasa A din spatiul de nume SN1

Clasa A din spatiul de nume SN2
Clasa A din spatiul de nume SN3

Observaţie: un spaţiu de nume se utilizează folosind directiva using.

Dintre principalele spaţii de nume putem enumera:

Spaţiul de nume System

Spaţiul de nume System, definit în biblioteca mscorlib.dll, conţine un număr mare de clase
fundamentale, printre care:
o Clase de bază pentru tipuri de valori şi de referinţe;
o Clase pentru evenimente şi proceduri de tratare a evenimentelor;
o Clase pentru excepţii;
o Clase matematice;
o Colectarea gunoiului;
o Conversii pentru tipuri de date

Spaţiul de nume Forms

Spaţiul de nume System.Windows.Forms pune la dispoziţie mijloace de dezvoltare
bazate pe forme. Acest spaţiu conţine peste 300 de clase, structuri şi enumerări.

Spaţiile de nume Collections

Conţin clase pentru colecţii: ArrayList, List, Queue, SortedList, Stack etc.

Spaţiul de nume Diagnostics

Spaţiul de nume System.Diagnostics pune la dispoziţie clase pentru urmărirea execuţiei
programului, interacţiunea cu depanatorul, lansarea proceselor de sistem etc.

Spaţiul de nume IO
Spaţiul de nume System.IO pune la dispoziţie clase pentru lucrul cu fluxuri de
intrare/ieşire. Printre acestea se află: File, FileInfo, FileStream, Stream etc.

Spaţiul de nume Drawing

Pune la dispoziţie clase pentru funcţionalitatea grafică a cadrului de lucru .NET.

Spaţiul de nume Net

Pune la dispoziţie o interfaţă către protocoalele folosite (manipularea adreselor IP, căutările
DNS, comunicarea cu serverele HTTP şi FTP etc).

Spaţiile de nume XML

Asigură suportul pentru crearea şi manipularea documentelor XML.

2
Programare orientată pe obiecte Curs 8

Spaţiile de nume Data

Conţine clasele care implementează tehnologia ADO.NET, care permite gestionarea datelor
provenite din mai multe surse de date.

Spaţiile de nume Web

Asigură clasele pentru producerea aplicaţiilor Web.

Utilizarea consolei
Pentru utilizarea consolei în cadrul proiectelor de tip CLR vom utiliza clasa Console din
spațiul de nume System. Aceasta reprezintă fluxul standard pentru intrări, ieșiri al aplicațiilor în
modul consolă. Această clasă nu poate fi moștenită.
Clasa Console are mai multe proprietăți și metode, dintre acestea amintind:

Proprietăți:

Nume Descriere
BackgroundColor Dă sau setează culoarea de fundal a consolei.

BufferHeight Dă sau setează înălțimea zonei tampon (buffer area).

BufferWidth Dă sau setează lățimea zonei tampon (buffer area).

ForegroundColor Dă sau setează culoarea de fontului pentru consolă.

Title Dă sau setează titlul de afișat în bara de titlu a consolei.

WindowHeight Dă sau setează înălțimea consolei.

WindowLeft Dă sau setează poziția "zonei vizibile" (poziția pe orizontală).

WindowTop Dă sau setează poziția "zonei vizibile" (poziția pe verticală).

WindowWidth Dă sau setează lățimea consolei.

Observație:
WindowWidth+WindowLeft<= BufferWidth
WindowHeight+WindowTop<= BufferHeight

3
Programare orientată pe obiecte Curs 8

Metode:

Nume Descriere
Beep() Redă semnal sonor la difuzorul consolei.

Clear Șterge zona tampon (buffer area) și fereastra consolei.

Read Citește următorul caracter.

ReadLine Citește linia următoare.

SetCursorPosition Setează poziția cursorului.

Write(expresie) Scrie expresie care poate fi de tipul: Boolean, Char,

array<tipChar>, Decimal, Double, Int32, Int64, Object, Single,
String, UInt32, UInt64.

WriteLine() Scrie sfârșitul liniei.

WriteLine(expresie) Scrie expresie apoi scrie sfârșitul liniei. Expresie poate fi de tipulȘ
Boolean, Char, array<tipChar>, Decimal, Double, Int32, Int64,
Object, Single, String, UInt32, UInt64.

Observație: Metodele Write și WriteLine acceptă și scrierea cu format. În exemplul următor

este prezentat modul de utilizare al consolei.

Exemplu:
Console.BackgroundColor=ConsoleColor.Blue;//ConsoleColor (este de tip enum) -
contine culorile disponibile pentru consola
Console.ForegroundColor=ConsoleColor.Red;
Console.Title="Exemplu pentru utilizarea consolei.";
Console.Clear();
Console.WriteLine("Care este numele tau?");
String nume=Console.ReadLine();
Console.WriteLine("Salut {0}, datele consolei sunt:",nume);
Console.WriteLine(" Buffer: {0} x {1}", Console.BufferHeight,Console.BufferWidth);
Console.WriteLine(" Window: {0} x {1}", Console.WindowHeight,
Console.WindowWidth);

//Exemple de utilizare a metodei WriteLine cu formatari

Console.WriteLine();//spatiu suplimentar
Console.WriteLine("Specificatori standard pentru tipul Numeric");
Console.WriteLine(
"(C) Currency: . . . . . . . . {0:C}\n" +
"(D) Decimal:. . . . . . . . . {0:D}\n" +
"(E) Scientific: . . . . . . . {1:E}\n" +
"(F) Fixed point:. . . . . . . {1:F}\n" +
"(G) General:. . . . . . . . . {0:G}\n" +
" (default):. . . . . . . . {0} (default = 'G')\n" +

4
Programare orientată pe obiecte Curs 8

"(N) Number: . . . . . . . . . {0:N}\n" +

"(P) Percent:. . . . . . . . . {1:P}\n" +
"(R) Round-trip: . . . . . . . {1:R}\n" +
"(X) Hexadecimal:. . . . . . . {0:X}\n",
-123, -123.45f);
Console.WriteLine();
DateTime acum = DateTime.Now;//data si ora curenta
Console.WriteLine("Specificatori standard pentru tipul DateTime");
Console.WriteLine(
"(d) Short date: . . . . . . . {0:d}\n" +
"(D) Long date:. . . . . . . . {0:D}\n" +
"(t) Short time: . . . . . . . {0:t}\n" +
"(T) Long time:. . . . . . . . {0:T}\n" +
"(f) Full date/short time: . . {0:f}\n" +
"(F) Full date/long time:. . . {0:F}\n" +
"(g) General date/short time:. {0:g}\n" +
"(G) General date/long time: . {0:G}\n" +
" (default):. . . . . . . . {0} (default = 'G')\n" +
"(M) Month:. . . . . . . . . . {0:M}\n" +
"(R) RFC1123:. . . . . . . . . {0:R}\n" +
"(s) Sortable: . . . . . . . . {0:s}\n" +
"(u) Universal sortable: . . . {0:u} (invariant)\n" +
"(U) Universal full date/time: {0:U}\n" +
"(Y) Year: . . . . . . . . . . {0:Y}\n",
acum);

Observație: În exemplul anterior am folosit operatorul "+" pentru concatenarea șirurilor de

caractere.

5
Programare orientată pe obiecte Curs 8

Tratarea excepţiilor
Excepţiile reprezintă un mecanism de tratare a erorilor, care, faţă de tratarea erorilor prin
valori returnate oferă trei avantaje:
o Excepţiile nu pot fi ignorate: dacă o excepţie nu este tratată într-un punct al programului,
acesta îşi termină forţat execuţia;
o Nu este obligatoriu să fie tratate în punctul în care apar: erorile pot fi tratate în orice loc al
stivei de apeluri. Procedura de tratare (handler) a unei excepţii poate fi implementată în
rutina din care a fost lansată excepţia sau în orice rutină aflată deasupra acesteia în stiva de
apeluri. În timpul execuţiei, fiecare rutină este verificată pentru a vedea dacă
implementează o procedură corespunzătoare de tratare. Dacă nu este gasită nicio procedură
de tratare până în partea cea mai de sus a stivei de apeluri, programul se termină forţat.
o Excepţiile pun la dispoziţie o modalitate de semnalare a erorilor acolo unde nu pot fi
folosite valori returnate (ex. constructorii).

Atunci când apare o condiţie de eroare, programatorul poate genera o excepţie folosind
cuvântul cheie throw, excepţia fiind etichetată cu un set de informaţii care arată cu exactitate ce s-a
întâmplat.
Observaţie: La generarea unei erori execuţia normală se opreşte şi codul de tratare a
excepţiilor încorporat în program începe să caute o procedură de tratare. Dacă procedura curentă
nu conţine o procedură de tratare, codul de tratare a erorilor urcă un nivel în stiva de apeluri şi
caută o procedură de tratare potrivită.

Exemplu de excepţie lăsată netratată:

#include "stdafx.h"

using namespace System;

void main(){
int x=3;
int y=0;

int rezultat=x/y;
Console.Write("Rezultat={0}",rezultat);
}

6
Programare orientată pe obiecte
Împărţirea la zero a generat automat o excepţie. Deoarece aceasta nu a fost tratată în cod,
programul se termină şi ultima operaţie de afişare nu se mai face. Unei excepţii i se poate ataşa
orice tip (int, double, structuri sau obiecte etc.). În spaţiul de nume System sunt definite mai multe
clase de excepţii, derivate din clasa System.Exception. Printre acestea avem:
Clasă de excepţii
System.ApplicationException
System.ArgumentException
System.ArithmeticException
System.Exception
System.IndexOutOfRangeException
System.InvalidCastException
System.MemberAccessException
System.NotSupportedException
System.NullReferenceException
System.OutOfMemoryException
System.SystemException
System.TypeLoadException
Curs 8
Descriere
Lansată atunci când apare o eroare nefatală.
Lansată atunci când unul dintre argumentele unei funcţii
este invalid. Printre subclasele acesteia se află
System.ArgumentNullException şi
System.ArgumentOutOfRangeException.
Lansată atunci când apare o eroare aritmetică, de
conversie forţată sau de conversie. Printre subclasele
acesteia se numără System.DivideByZeroException şi
System.OverflowException.
Clasă de bază pentru toate tipurile de excepţii.
Lansată atunci când indexul unei matrice depăşeşte
limita maximă.
Lansată atunci când se încearcă o operaţie invalidă de
conversie.
Lansată atunci când se face o încercare de acces
dinamic la un membru care nu există. Printre subclasele
acesteia e numără System.MissingFieldException şi
System.MissingMethodException.
Lansată atunci când se încearcă apelarea unei metode
care nu este acceptată.
Lansată atunci când se încearcă dereferirea unei
referinţe nule.
Lansată atunci când nu mai poate fi alocată memoria
necesară.
Clasă de bază pentru excepţiile a căror tratare este lăsată
în seama utilizatorilor. Printre subclasele ei se află
ArgumentException şi
ArithmeticException.
Lansată atunci când mecanismul (CLR) nu poate găsi
un ansamblu sau un tip în cadrul unui ansamblu sau nu
poate încărca tipul respectiv. Printre subclasele acesteia
se numără
System.DllNotFoundException.
7
Programare orientată pe obiecte Curs 8

Excepţiile sunt interceptate şi prelucrate folosind construcţia try şi catch, care are sintaxa:
try{
//codul care ar putea genera erori
}
catch(Tip1 p1){
//tratare exceptie
}
...
catch(Tipn pn){
//tratare exceptie
}

Fiecare bloc catch are între paranteze rotunde tipul de excepţie care va fi interceptat şi
prelucrat de blocul de instrucţiuni.

Observaţie: Blocurile try şi catch formează o singură construcţie (nu se poate folosi un bloc
try fără cel puţin un bloc catch şi nu se poate folosi un bloc catch fără un bloc try). Între cele două
blocuri nu pot exista alte secvenţe de instrucţiuni. Se pot înlănţui oricâte blocuri catch, câte unul
pentru fiecare tip de excepţie ce se doreşte a fi tratată.

Clasele de excepţii formează o ierarhie bazată pe clasa System.Exception. Această ierarhie poate fi
folosită pentru simplificarea tratării erorilor.

Exemplu

Fie funcţia:

static int factorial(int n)

{
if (n < 0)//aruncam o exceptie
throw new ArgumentException("Argumentul trebuie sa fie pozitiv");
if (n == 0) return 1;
return n * factorial(n - 1);
}

Dacă nu tratăm excepţia în funcţia main:

static void Main(string[] args)
{
Console.WriteLine("Start test exceptii");
Console.WriteLine("n!={0}",factorial(-5));
Console.WriteLine("Sfarsit test exceptii");

}
atunci rezultatul execuţiei va fi:

Start test exceptii

Unhandled Exception: System.ArgumentException: Argumentul trebuie sa fie pozitiv

at . . .

8
Programare orientată pe obiecte Curs 8

Se observă că mesajul Sfarsit test exceptii nu mai apare. Execuţia s-a întrerupt în
momentul apariţiei excepţiei.

Dacă tratăm excepţia:

Console.WriteLine("Start test exceptii");

try{
Console.WriteLine("n!={0}",factorial(-5));
}
catch(ArgumentException p){
Console.WriteLine(p.Message);//preluam si afisam mesajul exceptiei
}
Console.WriteLine("Sfarsit test exceptii");

atunci rezultatul execuţiei va fi:

Start test exceptii
Argumentul trebuie sa fie pozitiv
Sfarsit test exceptii
Press any key to continue
Se observă apariţia mesajului Sfarsit test exceptii.

Observaţie: Excepţiile pot fi utilizate în constructori.

Exemplu:
class Test{
String pv;
public Test(String p)
{
if (p == null || p == "")//Nu permitem ca pval sa fie null sau sirul vid.
throw new System.ArgumentException("Argumentul este null sau blank");
else
p = pv;
}
}

Important: Dacă dorim să captăm orice excepție putem folosi tipul Exception, care va capta
orice excepţie.

Exemplu:

try
{
int a=5,b;
Console.Write("Dati o valoare intreaga:");
b=Convert.ToInt32(Console.ReadLine());
Console.WriteLine("Restul impartirii lui {0} la {1} este {2}.",a,b,a%b);
}
catch(ArithmeticException){
Console.WriteLine("Eroare aritmetica");
}
catch(Exception){
Console.WriteLine("Eroare.");
}
9
Programare orientată pe obiecte Curs 8

Dacă ultimul bloc catch ar fi lipsit atunci în locul rezultatului

Dati o valoare intreaga:2a

Eroare.
Press any key to continue . . .

am fi obținut:

Observație: Clasa Convert din spațiul de nume System pune la dispoziție metode pentru
conversii intre tipuri de date. În programul anterior am folosit metoda ToInt32 din pentru a
converti un String la un int.

Alături de blocul catch mai putem întâlni și blocul finally care se execută întotdeauna şi poate fi
folosit pentru a face " curăţenie " după apariţia unei excepţii.

Exemplu:

Console.WriteLine("Test finally");
try{
Console.WriteLine("Apelam functia factorial cu n=3");
factorial(3);
}
catch(System.ArgumentException p){
Console.WriteLine("Exceptia a fost: {0}", p.Message);
}
finally{
Console.WriteLine("S-a executat blocul finally ");
}

try{
Console.WriteLine("Apelam functia factorial cu n=-5");
factorial(-5);
}
catch(System.ArgumentException p){
Console.WriteLine("Exceptia a fost: {0}", p.Message);
}
finally{
Console.WriteLine("S-a executat blocul finally ");
}
Console.WriteLine("Sfarsit test");
Test finally
Apelam functia factorial cu n=3
S-a executat blocul finally

10
Programare orientată pe obiecte Curs 8

Apelam functia factorial cu n=-5

Exceptia a fost: Argumentul nu este corect
S-a executat blocul finally
Sfarsit test
Press any key to continue

Observație: Se observă că în ambele situații s-au executat instrucțiunile corespunzătoare

blocului finally. Spre exemplu aici pot fi eliberate resursele ce se folosesc la citirea/scrierea unui
fișier. Acestea vor fi eliberate chiar dacă blocul try nu ar fi executat complet datorită apariției unor
erori la citire/scriere.

Definirea proprietăţilor
Un principiu al programării orientate spre obiecte este acela că nu este indicat să se permită
accesul direct la datele membre ale claselor, recomandându-se mascarea datelor membre prin
declararea acestora de tipul private şi asigurând accesul la acestea prin folosirea funcţiilor membre.
Proprietăţile pun la dispoziţie o modalitate de implementare a datelor membre virtuale
pentru o clasa, fiind nişte metode speciale, declarate folosind cuvântul cheie property. Ele sunt
implementate folosind get şi set. Proprietăţile pot fi virtuale sau chiar pur virtuale şi nu este
obligatoriu ca ambele metode să aibă acelaşi specificator virtual. Dacă este implementată numai
metoda get se obţine o proprietate numai pentru citire, iar dacă este implementată numai metoda
set se obţine o proprietate numai pentru scriere. În metodele proprietăţi se pot folosi excepţiile
pentru tratarea erorilor. Sunt acceptate două tipuri de proprietăţi:
o Proprietăţi scalare – permit accesul la o singură valoare
o Proprietăţi indexate – permit accesul la proprietate ca şi cum aceasta ar fi o matrice,
folosind notaţia cu paranteze pătrate. Proprietăţile indexate sunt utile pentru clasele care au
ca membri colecţii de elemente. Şi proprietăţile indexate folosesc metodele get şi set pentru
implementare.

Exemplu:

class Complex{
private
float re,im;
public Complex(){
re=0;im=0;
}
public float Re{
get{return re;}
set{re=value;}
}
public float Im{
set{re=value;}
}
}

11
Programare orientată pe obiecte Curs 8

Complex z=new Complex();

z.Re=7;
z.Im=z.Re;
Console.WriteLine(z.Im);//eroare 'get' : is not a member of 'Complex.Im'
Console.WriteLine(z.Re);

Observaţie: În exemplul anterior nu se puteau defini proprietăţile cu numele re şi im deoarece

acestea ar fi creat un membru virtual numit re (respectiv im), care ar fi intrat în conflict cu
membrul de date real re (respectiv im).

Utilizarea clasei Math

Clasa Math pune la dispoziție constante și metode statice pentru lucrul cu expresii
matematice (trigonometrice, logaritmice etc.). Această clasă face parte din spațiul de nume System
și este o clasă finală (nu poate fi moștenită).
Printre metodele clasei regăsim:

Nume Descriere
Abs(expresie) Întoarce valoarea absolută pentru argumentul primit ce poate fi de tipul:
Decimal, Double, Int16, Int32, Int64, IntSbyte, Single

Acos Corespunde funcției arccos.

Asin Corespunde funcției arcsin.

Atan Corespunde funcției arctg.

Atan2(val1,val2) Întoarce unghiul a cărui tangentă este egală cu raportul dintre val1 și val2.

Cos Corespunde funcției cosinus.

Cosh Corespunde funcției cosinus hiperbolic.

Exp Corespunde funcției exponențiale cu baza e.

Floor Întoarce cel mai mare întreg mai mic sau egal cu argumentul primit, care poate
fi de tipul Decimal sau Double.

Log(Double) Corespunde funcției ln.

Log(Double, Corespunde funcției logaritm cu baza specificată.

Double)

Log10 Corespunde funcției lg (logaritm cu baza 10).

12
Programare orientată pe obiecte Curs 8

Max(val1,val2) Întoarce maximul dintre valorile primite, care pot fi de tipul: Byte, Decimal,
Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64

Min(val1,val2) Întoarce minimul dintre valorile primite, care pot fi de tipul: Byte, Decimal,
Double, Int16, Int32, Int64, SByte, Single, UInt16, UInt32, UInt64

Pow(val1,val2) Corespunde funcției putere (val1-baza, val2-exponentul)

Round(expresie) Intoarce valoarea întreagă cea mai apropiată de expresie.

Expresie poate avea tipul: Decimal, Double.

Round(expresie,nr) Face rotunjirea pentru expresie la nr zecimale. Expresie poate avea tipul:
Decimal, Double.

Sign(expresie) Întoarce o valoare care indică semnul pentru expresie, ce poate fi de tipul: Byte,
Decimal, Double, Int16, Int32, Int64, SByte, Single

Sin Corespunde funcției sinus.

Sinh Corespunde funcției sinus hiperbolic.

Sqrt Corespunde funcției radical.

Tan Corespunde funcției tangentă.

Tanh Corespunde funcției tangentă hiperbolică.

Truncate(expresie) Calculează partea întreagă pentru expresie. Expresie poate avea tipul: Decimal,
Double.

Ca și constante de clasă avem:

Nume Descriere
E Constanta e.

PI Constanta π.

Exemplu:

class Punct{
String nume;
int x,y;
public Punct(String nume,int x,int y){
this.nume=nume;
this.x=x;
this.y=y;
13
Programare orientată pe obiecte Curs 8

}
public int X{
get{return x;}
set{x=value;}
}
public int Y{
get{return y;}
set{y=value;}
}
public String Text
get{return nume;}
set{nume=value;}
}
public double distanta(int x, int y) {
return Math.Sqrt(Math.Pow(this.x-x,2)+Math.Pow(this.y-y,2));
}
public double distanta(Punct P) {
return distanta(P.X,P.Y);
}
}

static void Main(string[] args)

{
Punct P1 = new Punct("A", 0, 0);
Punct P2 = new Punct("B", 4, 4);
Punct P3 = new Punct("C", 4, 0);
double a, b, c, perimetru, semiperimetru, arie, unghi;

a = P1.distanta(P2);
b = P2.distanta(P3);
c = P1.distanta(P3);
perimetru = a + b + c;

Console.WriteLine("Perimetrul triunghiului {0}{1}{2} este: {3}", P1.Text,

P2.Text, P3.Text, perimetru);

semiperimetru = perimetru / 2;
arie = semiperimetru * (semiperimetru - a) * (semiperimetru - b) *
(semiperimetru - c);
arie = Math.Sqrt(arie);

Console.WriteLine("Aria triunghiului {0}{1}{2} este: {3}", P1.Text, P2.Text,

P3.Text, arie);
Console.WriteLine("Raza cercului circumscris triunghiului {0}{1}{2} este: {3}",
P1.Text, P2.Text, P3.Text, a * b * c / (4 * arie));
Console.WriteLine("Raza cercului inscris triunghiului {0}{1}{2} este: {3}",
P1.Text, P2.Text, P3.Text, arie / semiperimetru);
unghi = Math.Atan2(P2.Y - P1.Y, P2.X - P1.X);
unghi -= Math.Atan2(P3.Y - P1.Y, P3.X - P1.X);
Console.WriteLine("Unghiul {0} are {1} grade.", P1.Text, unghi / Math.PI *
180);//unghi orientat
Console.WriteLine("sin({0})={1}", P1.Text, Math.Sin(unghi));
}

Perimetrul triunghiului ABC este: 13,6568542494924

Aria triunghiului ABC este: 8
Raza cercului circumscris triunghiului ABC este: 2,82842712474619
Raza cercului inscris triunghiului ABC este: 1,17157287525381
Unghiul A are 45 grade.
sin(A)=0,707106781186547
14
Programare orientată pe obiecte Curs 8

Press any key to continue . . .

Generarea numerelor aleatoare

Pentru generarea numerelor aleatoare se va folosi clasa Random din spațiul de nume
System. Un reprezentant al clasei Random reprezintă un generator de numere pseudo-aleatoare,
care produce o secvenţă de numere care îndeplinesc anumite cerinţe statistice. Generarea
numerelor nu este complet aleatorie deoarece ele sunt rezultatul unui algoritm matematic ce are la
bază o valoare de start. Pentru aceeași valoare de start se vor obține aceleași serii de valori. O
metodă de a obține serii diferite de valori generate este aceea de a considera valoarea de start
dependentă de timp.

Observație: Este de preferat crearea unei singure instanțe a clasei Random pentru generarea
mai multor numere în detrimentul generării numerelor cu mai multe instanțe ale clasei.

Constructorii clasei sunt

Random() - algoritmul de generare are valoarea de start dependentă de timp.

Random(Int32) - algoritmul de generare are valoarea de start dependentă de
valoarea primită ca argument.

Metode ale clasei

Nume Descriere
Next() Întoarce un număr aleatoriu nenegativ

Next(Int32) Întoarce un număr aleatoriu nenegativ mai mic decât valoarea specificată.

Next(Int32, Int32) Întoarce un număr aleatoriu din intervalul specificat.

NextDouble Întoarce un număr aleatoriu cuprins între 0.0 și 1.0.

Exemplu:

int x,y;
Random r=new Random();
Console.WriteLine("Un numar intreg: {0}",r.Next());
x=20;
y=50;
Console.WriteLine("Un numar intreg din intervalul {0}..{1}:
{2}",x,y,r.Next(20,50));
Console.WriteLine("Un numar de tip double din intervalul (0,1):
{0}",r.NextDouble());
Console.WriteLine("Un numar de tip double din intervalul ({0},{1}):
{2}",x,y,x+r.NextDouble()*(y-x));

În exemplul următor vom utiliza generatorul de numere aleatoare pentru a determina

valoarea aproximativă a numărului PI. Pentru aceasta ne vom folosi de faptul că daca avem un
15
Programare orientată pe obiecte Curs 8

patrat de latura 2 și un cerc înscris în acesta, probabilitatea ca un punct al pătratului să fie în

interiorul cercului este PI/4 (aria cercului/aria pătratului).

Exemplu:

static double valoare_aproximativa_PI(int N){//nr de incercari

if(N<=0)return 0;
int inInterior=0;
double x,y;
Random r=new Random();
for(int i=0;i<N;i++){
x=-1+r.NextDouble()*2;
y=-1+r.NextDouble()*2;
if(Math.Sqrt(x*x+y*y)<=1)inInterior++;
}
return 4.0*inInterior/N;
}

static void Main(string[] args)

{
for(int i=1;i<=8;i++)
Console.WriteLine("Pentru {0} incercari, valoarea aproximativa a
numarului PI este {1}",Math.Pow(10,i),valoare_aproximativa_PI((int)Math.Pow(10,i)));

Pentru 10 incercari, valoarea aproximativa a numarului PI este 3,6

Pentru 100 incercari, valoarea aproximativa a numarului PI este 3,04
Pentru 1000 incercari, valoarea aproximativa a numarului PI este 3,188
Pentru 10000 incercari, valoarea aproximativa a numarului PI este 3,1596
Pentru 100000 incercari, valoarea aproximativa a numarului PI este 3,14148
Pentru 1000000 incercari, valoarea aproximativa a numarului PI este 3,14152
Pentru 10000000 incercari, valoarea aproximativa a numarului PI este 3,142048
Pentru 100000000 incercari, valoarea aproximativa a numarului PI este 3,14151328

Press any key to continue . . .

Lucrul cu șiruri de caractere

Pentru lucrul cu șiruri de caractre vom folosi clasa String din spațiul de nume System. Ca și
constructori putem folosi:
String(Char*) - crează o instanță a clasei String pe baza unui pointer către un tablou ce
conține caractere Unicode
String(Char[]) - crează o instanță a clasei String pe baza unui tablou ce conține caractere
Unicode
Odată create, instanțele clasei String pun la dispoziție proprietatea Length pentru citirea
lungimii șirului de caractere și operatorul [...] pentru citirea codului elementului de pe o poziție
specificată. Pentru concatenarea șirurilor de caractere se poate folosi operatorul "+" sau metoda
Concat. O copie (clonă) a unei instanțe din clasa String se poate obține folosind metoda Clone.
16
Programare orientată pe obiecte Curs 8

Exemplu:

String s1="abcdefghij";
char[] c1={'a','b','c','d','e'};
String s2=new String(c1);

int nr=0;
for(int i=0;i<s1.Length;i++)
nr+=s1[i];

Console.WriteLine("Suma codurilor caracterelor sirului {0} este {1}",s1,nr);

Console.WriteLine(s1+s2);//s1+s2 este echivalent cu String.Concat(s1,s2)

Metode ale clasei String:

 metoda Compare - folosită pentru compararea a două șiruri de caractere (are la bază
ordinea lexicografică)

Exemplu:

String s1="123";
String s2="121";
String.Compare(s1,s2);//1
String.Compare("a","ab");//-1
String.Compare("ab","ab");//0
String.Compare("abc","ab");//1
String.Compare("Ab","ab");//1
String.Compare("Ab","ab",true);//0-true, pentru a nu mai fi case
sensitive

 metodele EndsWith și StartsWith - folosite pentru a testa dacă un șir de caractere se

termina sau începe cu o valoare data (pentru comparare se poate folosi enumerarea
StringComparison)

Exemplu:

String s1="123";
String s2="abcd";
s1.EndsWith("23");//true
s2.StartsWith(s1);//false
s2.EndsWith("acd");//false
s2.EndsWith("cd");//true
s2.EndsWith("Cd");//false
s2.EndsWith("Cd",System.StringComparison.OrdinalIgnoreCase);//true

 metoda Equals - folosită pentru a testa dacă avem egalitate între două șiruri de caractere
(pentru comparare se poate folosi enumerarea StringComparison)

Exemplu:

String s1="ABC";
String s2="abcd";
s2.Equals(s1);//false

17
Programare orientată pe obiecte Curs 8

String.Equals(s1+"D",s2);//false
String.Equals(s1+"D",s2,System.StringComparison.OrdinalIgnoreCase); //true

 metoda IndexOf - folosită pentru a determina într-un șir de caractere indexul primei apariții
a valorii specificate (pentru comparare se poate folosi enumerarea StringComparison)

Exemplu:

String s1="ABCA";
String s2="abcd";
s1.IndexOf('B');//1
s2.IndexOf("cd");//2
s1.IndexOf("E");//-1
s2.IndexOf("Cd");//-1
s2.IndexOf("Cd",System.StringComparison.OrdinalIgnoreCase);//2

 metoda LastIndexOf - se folosește la fel ca metoda IndexOf doar că dă indexul ultimei

apariții a valorii specificate (pentru comparare se poate folosi enumerarea
StringComparison)

Exemplu:

String s1="ABCA";
s1.LastIndexOf('A');//3

 metoda Insert - se folosește pentru a insera într-un șir valoarea specificată, în poziția
specificată

Exemplu:

String s1 = "ABCA";
String s2 = "abcd";
s1.Insert(2, s2);//"ABabcdCA"
s1.Insert(10, "123");//eroare, nu există pozitia cu indexul 10

 metoda Remove - se folosește pentru a elimina caractere dintr-un șir de caractere

Exemplu:

String s1="ABCD";
s1.Remove(1);//"A"- elimină tot de la poziția dată
s1.Remove(1,2);//"AD"- elimină numărul specificat de caractere,
începând cu poziția dată

 metoda Replace - înlocuiește textul căutat (dacă este găsit) cu cel specificat

Exemplu:

String s1="ABCA";
s1.Replace('A','5');//"5BC5"
s1.Replace('a','5');//"ABCA"
s1.Replace("BC","123");//"A123A"
s1.Replace("Bc","123");//"ABCA"

18
Programare orientată pe obiecte Curs 8

 metoda Split - crează un tablou de șiruri de caractere pe baza separatorului dat

Exemplu:

String s1 = "A/B/CD";
String[] s2 = s1.Split('/'); s2[0];//"A"
s2[1];//"B"
s2[2];//"CD"

 metoda Substring - returnează un subșir al șirului dat

Exemplu:

String s1="ABCD";
s1.Substring(1);//"BCD"- întoarce tot, începând cu poziția dată
s1.Substring(1,2);//"BC"- întoarce numărul specificat de
caractere, începând cu poziția dată

 metodele ToLower respectiv ToUpper pot fi folosite pentru a scrie un șir folosind
caractere "mari" sau " mici".

Exemplu:

String s1="AbCd";
s1.ToLower();//"abcd"
s1.ToUpper();//"ABCD"

 pentru eliminarea spațiilor dintr-un șir de caractere se pot utiliza metodele Trim, TrimEnd
sau TrimStart .

Exemplu:

String s1 = " AB CD E ";

Console.WriteLine("|" + s1 + "|");
Console.WriteLine("|" + s1.TrimStart() + "|");
Console.WriteLine("|" + s1.Trim() + "|");
Console.WriteLine("|" + s1.TrimEnd() + "|");

| AB CD E |
|AB CD E |
|AB CD E|
| AB CD E|
Press any key to continue . . .

Observații:
1) Pentru a testa dacă un șir este Null sau gol(empty) se pot folosi metodele IsNullOrEmpty
și IsNullOrWhiteSpace
2) Este permisă utilizarea operatorilor == sau !=

Exemplu:

"abc"=="Abc";//false
"abc"!="Abc";//true
19