Biblioteca de clase din cadrul de lucru - math.uaic.romapetrii/POO/depozit/Curs8.pdf ·...

Programare orientată pe obiecte Curs 8

1

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(); } }


2

Clasa A din spatiul de nume SN1



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.


3

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


4

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" +


5

"(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.


6

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);

}


7

Î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 Descriere

System.ApplicationException Lansată atunci când apare o eroare nefatală.

System.ArgumentException Lansată atunci când unul dintre argumentele unei funcţii

este invalid. Printre subclasele acesteia se află

System.ArgumentNullException şi

System.ArgumentOutOfRangeException.

System.ArithmeticException 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.

System.Exception Clasă de bază pentru toate tipurile de excepţii.

System.IndexOutOfRangeException Lansată atunci când indexul unei matrice depăşeşte

limita maximă.

System.InvalidCastException Lansată atunci când se încearcă o operaţie invalidă de

conversie.

System.MemberAccessException 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.

System.NotSupportedException Lansată atunci când se încearcă apelarea unei metode

care nu este acceptată.

System.NullReferenceException Lansată atunci când se încearcă dereferirea unei

referinţe nule.

System.OutOfMemoryException Lansată atunci când nu mai poate fi alocată memoria

necesară.

System.SystemException Clasă de bază pentru excepţiile a căror tratare este lăsată

în seama utilizatorilor. Printre subclasele ei se află

ArgumentException şi

ArithmeticException.

System.TypeLoadException 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.


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 . . .


9

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."); }


10

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


11

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;} } }


12

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,

Double)

Corespunde funcției logaritm cu baza specificată.

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


13

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;


14

} 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


15


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


16

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









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.

http://msdn.microsoft.com/en-us/library/6y4za026.aspx

http://msdn.microsoft.com/en-us/library/ttyxaek9.aspx


17

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


18

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"


19

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|


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

http://msdn.microsoft.com/en-us/library/system.string.trimend.aspx

http://msdn.microsoft.com/en-us/library/system.string.trimstart.aspx

http://msdn.microsoft.com/en-us/library/system.string.isnullorempty.aspx

http://msdn.microsoft.com/en-us/library/system.string.isnullorwhitespace.aspx

Biblioteca de clase din cadrul de lucru - math.uaic.romapetrii/POO/depozit/Curs8.pdf ·...

Documents

Transcript of Biblioteca de clase din cadrul de lucru - math.uaic.romapetrii/POO/depozit/Curs8.pdf ·...