Tipuri de date definite de utilizator:

1) Clasa
Clasele reprezinta tipuri referinta. O clasa poate sa mosteneasca o singura
clasa si poate implementa mai multe interfete.
Clasele pot contine constante, cimpuri, metode, proprietati, evenimente,
indexatori, operatori, constructori de instanta, destructori, constructori de
clasa, tipuri imbricate.
2) Structura
Structurile reprezinta tipuri de date asemanatoare claselor, cu principala
diferenta ca sunt tipuri valoare (o astfel de variabila va contine direct valoarea,
si nu o adresa de memorie).
O structura este automat derivata din System.ValueType, care la rindul ei este derivata din
System.Object ; de asemenea, este automat considerata sealed (nederivabila). Poate insa
sa implementeze una sau mai multe interfete. O structura poate sa contina declaratii de
constante, cimpuri, metode, proprietati, evenimente, indexatori, operatori, constructori,
constructori statici, tipuri imbricate. Nu poate contine destructor.
Asemanari:
Clase
Class AngajatClasa
{
Public tring nume;
Public string prenume;
Public string adresa;
}
AngajatClasaIon = new
AngajatClasa();

structuri
Descrierea tipului:
Struct AngajatStruct
{
Public string nume;
Public string prenume;
Public string adresa;
}
La nivelul creerii de obiecte
AngajatStructVasile = new
AngajatStrct();

Utilizarea functionalitatii tipului

Ion.numr=Sirbu;
Vasile.nume=Virlan;
Ion.prenume=Ion;
Vasile.prenume=Vasile;
Deosebiri
Clase
Structuri
- Sabloane in baza carora se creeaza
- Sabloane pentru crearea tipurilor de date
tipuri de date referentiale
valorice
- Pot fi utilizate pentru obtinerea altor
- Nu pot fi utilizate pentru obtinerea altor
tipuri de date prin mostenire
tipuri de date prin mostenire
- Pot fi obtinute prin mostenire de la
- Pot fi obtinute prin mostenire de la
clase si/sau interfete
interfete
O interfa este o component a aplicaiei, asemntoare unei clase, care declar
prin membrii si (metode, proprieti, evenimente i indexatori) un comportament unitar
aplicabil
mai multor clase, comportament care nu se poate defini prin ierarhia de clase a aplicaiei.

Modificatorii de acces
Daca nu scrim nici un modificator se subintelege ca private.
Functii
Functii membre a Functii membri
membre clasei derivate din a clasei
a clasei clasa data din
derivate a
date
asamblajul dat
clasei date din
alte asamblaje
Private
+
Protected
+
+
+
Internal
+
+
Internal
+
+
+
protected
public
+
+
+

Functii
membri ai
clasei din
asamblaju dat

Functii
membere ale
clasei din alte
asamblaje

+
+

Polimorfismul
Polimorfismul este capacitatea unei entitati de a lua mai multe forme. In limbajul C#
polimorfismul este de 3 feluri: parametric, adhoc si de mostenire.
- Polimorfismul parametric
Este cea mai slaba forma de polimorfism, fiind regasita in majoritatea limbajelor. Prin
polimorfismul parametric se permite ca o implementare de functie sa poata prelucra orice numar
de parametri. Acest lucru se poate obtine prin folosirea in C# a unui parametru de tip params.
- Polimorfismul adhoc
Se mai numeste si supraincarcarea metodelor, mecanism prin care in cadrul unei clase se pot
scrie mai multe metode, avind acelasi nume, dar tipuri si numere diferite de parametri de apel.
Alegerea functiei care va fi apelata se va face la compilare, pe baza corespondentei intre tipurile
parametrilor de apel si tipurile parametrilor formali.
- Polimorfismul de mostenire
Este forma cea mai evoluata de polimorfism. Daca precedentele forme de polimorfism sunt
aplicabile fara a se pune problema de mostenire, in acest caz este necesar sa existe o ierarhie de
clase. Mecanismul se bazeaza pe faptul ca o clasa de baza defineste un tip care este compatibil
din punct de vedere al atribuirii cu orice tip derivate.
Indexatori
Functii member care permit accesu la date din cadru unui obiect dupa modelul unui tablou.
Accesu poate fi:
-pentru citire
- pentru scriere
-pentru citire si scriere
Acceptorii get/set

Constructori statici
Un constructor static este un membru care implementeaza actiunile cerute pentru initializara
unei clase. Declararea unui constructor static se face ca mai jos:
atributeopt modificator-de-constructor-static identificator( ) corp
Modificatorii de constructori statici se pot da sub forma:
- externopt static
- static externopt
Constructorii statici nu se mostenesc, nu se pot apela direct si nu se pot supraincarca. Un
constructor static se va executa cel mult o data intr-o aplicatie.
Se garanteaza faptul ca acest constructor se va apela inaintea primei creari a unei instante a clasei
respective sau inaintea primului acces la un membru static. Acest apel este nedeterminist,
necunoscinduse exact cind sau daca se va apela. Un astfel de constuctor nu are specificator de
acces si poate sa
acceseze doar membri statici.

Mostenire
Transmiterea de proprietati si functionalitati de la o seri de tipuri de date la alte tipuri de date se
numeste mostenire.
Mostenire singulara:
Tip de baza clasa
Tip de baza interface

tip derivate clasa

tip derivate interface, class, structura

De 2 tipuri:
1. mostenire de clasa(implementare)
2. mostenire de interfata
Restrictii:
- Structura ca tip de date nu poate fi tip de baza
- Structura nu poate fi obtinuta prin derivare(mostenire) de la o clasa
- Structura poate fi obtinuta prin mostenire de interfata
Mostenire multipla:
Tip de baza class
tip derivat class, interface
Tip de baza interface tip returnat interface
Ti de baza struct
tip derivate interface

Mostenire de implementare:

Modificatori de acces
la clasa de vaza

private
protected
public

Gradu de acces la
membrii clasei
derivate
Inaccesibil
Protected
public

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading; // pentru med\toda
de retinere cu sleep
namespace ConsoleApplication1
{
class Program
{
static void Main(string[] args)
{
/* for (int i = 0; i < 10; i++)
{
Console.WriteLine(i);
Thread.Sleep(500); // metoda 2
de retinere a afisarii
//Timp(100000000); prima metoda
de retinere a afisarii
}
}
static void Timp(int i )
{
for (int j = 1; j < i; j++) ;

}*/
/*
long[,] tr2l;
tr2l = new long[3, 4];
for (int i = 0; i < 3; i++)
//for (int j = 0; j < 4; j++)
for (int j = 0; j < 4; )
// tr2l[i, j] =
long.Parse(Console.ReadLine());
//
if(long.TryParse(Console.ReadLine(), out
tr2l[i,j]))
// j++;
j=
(long.TryParse(Console.ReadLine(), out
tr2l[i, j])) ?
j += 1 : j;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4;j++)
{

Console.Write("{0,4}", tr2l[i,
j]);
}
Console.WriteLine();
}
Console.ReadLine();*/
long[][] tnr2l;
int[] ll = { 4, 2, 1, 3 };
tnr2l = new long[4][];
for (int i = 0; i < 4; i++)
{
tnr2l[i] = new long[ll[i]];
for (int j = 0; j < ll[i]; )
j=
(long.TryParse(Console.ReadLine(), out
tnr2l[i][j])) ?
j += 1 : j;
}
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < tnr2l[i].Length;
j++)
{
Console.Write("{0,4}",
tnr2l[i][j]);
}
Console.WriteLine();
}
Console.ReadLine();
/*
int[] t1i = new int[10];
int[,] tr2i = new int[4, 5];
int[][] tnr2i = new int[4][] { new
int[2], new int[3], new int[1], new int[4] };
Console.WriteLine(t1i.Length);
Console.WriteLine(tr2i.Length);
Console.WriteLine(tnr2i.Length);
Console.WriteLine(tr2i.GetLength(0));
Console.WriteLine(tr2i.GetLength(1));
Console.WriteLine(tnr2i[0].Length);
Console.WriteLine(tnr2i[1].Length);
Console.WriteLine(tnr2i[2].GetLength(0));
Console.WriteLine(tnr2i[3].Length);*/
}
}}

Modificatorii la mostenire
Modificatorii dicteaza comportamentul metodelor, proprietatilor in cadru claselor de baza si
derivate.
Modificator
Public
Private
Protected
Internal
Internal protected

New
Virtual

Override
Abstract
sealed
partial

Aplicabil
Orice tip si orice
membr
Orice tip si orice
membru
Membrilor clasei,
tipuri incluse
Membrilor clasei,
tipuri incluse
Functii membre

Descriere
Ofera accesibilitatea din orice punct al
programului
Ofera accesibilitatea doar in cadru clasei

Ofera accesibilitatea doar in cadru clasei si in

cadru clasei derivate
Ofera accesibilitatea doar in cadru
asamblajului curent
Ofera accesibilitatea doar in cadru
asamblajului current sau in cadru clasei
derivate
Functii membre
Permite existent in clasa de basa si in cea
derivata a functiei cu acelasi nume
Functii membre
Permite existent in clasa de basa si in cea
derivata a functiei cu acelasi signatura care
poate fi schimbata
Functii membre
Permite schimbarea functiei virtual ion clasa
derivate
Functii membre, tipuri Permite existent functiilor ne implementate
de date
Functii membre, tipuri Impune imposibilitatea schimbarii functiei sau
de date
mostenirii
Tip de date
Permite divizarea realizarii tipurilor de date

Mostenire de interfete
Exista situatii cind metoda nu poate fi realiyata in interfata
[modif] interface nume Interfata
Descriere de signature pentru supraincarcare de operatori in cadru interfetelor nu exista.
Realizarea metodelor din interfete se face in tipuri derivate de la interfata: in clase si structure
Pot fi metode de standardizare utilizarea interfetelor
Nu se folosesc modificatori de acces in cadru interfetelor
Posibiliotati de mostenire
Clasa- interfata
Interfata-interfata metodele din interfata de baza nu vor fi realizate

Testarea la egalitate
In clasa object exista o serie de functii orientate la testarea la egalitate
Printre functii sunt statice si nestatice:
Static bool Reference Equals(object A,object B)
Compara adresele sau referintele obiectelor A,B
Daca nu aau valorea null return TRUE
Unul null, iar altul diferit de null Flase
null , null true/false

Virtual bool Equals (object A)

Ob1.Equals(ob 2)
Va fi apelata dupa prototipul :
Tip.ReferenceEquals(ob1,ob2);
Compararea referintelor obiectelor ob1,ob2
Obiect 1 nu trebuie sa fie null
null
null-FALSE
null
null- True/False
Static bool Equals(objectA, object B)
Tip.Equals(ob1,ob2) -apelarea
Realizeaza compararea de adresa
Null
null
true
null
null
false
null
null
true/false
Daca vor fi null se va apela metoda virtual bool Equals(ob1,ob2)
La tipuri fredefinite operatoru e realizat
La supraincarcari trebuie manual de supraincarcat operatoru

Exemplu de interfta si mostenire de

interfete
Using System;
Name space Cont
{
Public interface IContbancar
{
void Adaug(decimal s);
bool Extrag(decimal s);
decimal Bilant{get;};
}
Public interface ITransferbancar:
IContbancar
{
Bool Transfer(IContbancar c, decimal s);
}
Public class Victoria: IContbancar
{
Decimal Suma;
Public Victoria (decimal s) //constructor
{
Suma = s;
}
Public void Adaug (decimal s)// realizam
metodele(Metoda 1)
{
Suma+=s
}
Public bool Extrag(decimal s) //metoda 2
{
If (s<= suma)
{ suma-=s;
Return true;
}
Else
Return false;
}
Public decimal Bilant // metoda 3
{
Get
{
Return suma;
}
}
} // acoloada clasei Victoria
Public class Mobias: Itransferbancar
{
Decimal suma;
Public Mobias(decimal s)
{
Suma = s;

}
Public void Adaug (decimal s)// realizam
metodele(Metoda 1)
{
Suma+=s
}
Public bool Extrag(decimal s) //metoda 2
{
If (s<= suma)
{ suma-=s;
Return true;
}
Else
Return false;
}
Public decimal Bilant // metoda 3
{
Get
{
Return suma;
}
}
Public bool Transfer (IContbancar c,
decimal s)
{
Bool rez = Extrag(s);
If (rez == true)
c.Adaug(s);
return rez;
}
} // acoloada de la Mobias
Public class Program
{
Static void Main()
{
IContbancar cv;
ITransferbancar cm;
Cv= new Victoria(1000m);
Cm = new Mobias(2500m);
cv.Adaug(500m);
Console.WriteLine(cv.Bilant);
Console.WriteLine(cm.Bilant);
cm.Transfer(cv,500m);
Console.WriteLine(cv.Bilant);
Console.WriteLine(cm.Bilant);
} // acoloada main
} // acoloada class Program
} // acoloada namespace

Conversia datelor
-

Conversie automata (implicita)

Conversie fortata(explicita)

Automata:
- La atribuire
- In expresii
La atribuire:
Tipu variabilei din stinga este diferit de tipu expresiei din dreapta
Tip 1 tipu expr 2

La expresii:
Cind tipu la expresia1 tipu expresiei 2
Nu trebuie sa fie pierderi de informatie
tip
Sbyte
Byte
Short
Ushort
Int
Uint
long
Ulong
Float
char

Conversie implicita
Short, int, long, float, double, decimal
Short, ushort, int, uint, long, ulong, float, double, decimal
int, long, float, double, decimal
int, uint, long, ulong, float, double, decimal
long, float, double, decimal
long, ulong, float, double, decimal
float, double, decimal
float, double, decimal
Double
Short, ushort, int, uint, long, ulong, float, double, decimal

Cuvinte cheie in calitate de modificatori de converie:

-

Implicit;
Explicit.

Ex conversie
Using system;
Namespace Conversie
{
Enum curs
{
Lei = 13
Bani = 10;
}
Struct Dolari
{
Uint dolari;
Uint centi;
Public Dolari ( uintr d, uint c) // constructor
{
Dolari d;
Centi c;
}
Public static implicit operator
Float (Dolari d)
{
Return (dolari + centi/100.f);
}
Public static explicit operator Dolari (float s)
{
Return new Dolari ((uint)s, (s-(uint)s)*100);
}
Public override string ToString()
{
Return dolari +$+cent+c;
}
}

Struct Lei
{
Uint lei;
Uint lei
Public Lei(uint l, uint b)
{
Lei = l;
Bani = b;
}
Public static implicit operator Dolari (Lei
L)
{
Float c= curs.lei +curs.bani/100.f;
Float s = D;
Return (Lei) (s*c);
}
}
Class Program
{
Static void Main()
{
Lei L1 = new Lei (34,79);
Float suma;
Lei L2;
Suma L1;
L2 = (lei)suma;
Dolari d= L1;
Console.WriteLine(L2);
Console.WriteLine(d);
}
}
}

Supraincarcarea operatorilor

Using System;
Namespace SupraincarcareOp
{
Class Vector
{
Int x;
Int y;
Int z;
Public vector (int x, int y, int z)
{
This.x =x;
This.y = y;
This.z= z;
}
Public static int operator *
(Vector v1, vector v2)
{
Return v1.x*v2.x + v1.y*v2.y+v1.z*v2.z;
}
Public static Vector operator+
(Vector v1, vector v2)
{
Return new Vector(v1.x+v2.x , v1.y+v2.y,v1.z+v2.z);
}
Public static Vector operator * ( int c, vector v)
{
Return Vector(c*v.x;c*v.y,c*v.z);
}
Public override string ToString()
{
Return (+x.ToString()+,+y+,+z+);
}
}
Class Program
{
Static void Main()
{
Vector v1 = new Vector(3,-2,4);
Vector v2 = new Vector(7,12,-16);
Vector suma;
Suma = v1+v2;
Int produs = v1*v2;
Console.WriteLine(suma); //(10,10,-12)obtinem
Console.WriteLine(produs);
}
}
}

Constructii auxiliare
Marcaje
Descriere succrinta
<c>
Introducerea unei linii de
cod
<code>
Introducerea unui fragment
de cod

<exemplu>

Introducerea unui exemplu

<list >

Crearea unei liste

<item>

Permite descrierea unui

elemnt din lista
Permite descrierea unui
aliniat

<para>

<include>

Introducerea dintr-un fisier

xml

<param>

Permite descrierea unui

parametru
Introducerea unei descrieri
detaliate

<remarks>

<returns>

Permite descrierea valorii

returnate

<see>
Permite introducerea unei
<seealso>
referinte din document dat
<summary> Descrierea succinta o putem
introduce
<values>

Descrierea valorii returnate

de o proprietate

Exemplu de utilizare
///<c> int i;</c>
///<code>
///int i;
///i =100;
///</code>
///<exemplu>
///int i;
///i =100;
///</exemplu>
///<list>
///<item> A</item>
///<item> B</item>
///</list>
///<item> A</item>
///<item> B</item>
///<para>
///aliniat
/// de text
///</para>
///<include file-c:\\salut.xml
///path = doc/members/member// legatura dintre
noduri
///[@name=T:salutare.Program]/>
///<param name= n/>
///<remarks>
///descriere ampla
///</remarks>
///<returns>
///este returnat maximum
///</returns>
///<see cref = name/>
///<summary>
///descrierea rezumatului
///</summary>
///<values>
///este returnata numele persoanei
///</values>

Directivele preprocesorului
#defineXP - definirea

valoarea in C#

Permite crearea de:

- constant simbolice(nume fara valoare cencreta)

Posibilitati:
- Descriere de constant simbolice
- Compilare conditionata a codului
- De a schimba contorul liniilor
- De a evidential un fragment de cod
#undef numeConst -- intreruperea actiunii constantei respective
#line default - se introduce cind stergem niste linii, dar nu se doreste modificarea datelor
contorului
Liniilor
#line hidden -- ascunde fragmentul de cod pina la intilnirea directive #line