Paradigme de programare

= un set de concepte, modele şi practici care descriu esenţa programării

• programare imperativă => este descris fluxul de control al întregii
procesări => se descrie modul în care se execută programul,
programele fiind o succesiune de comenzi pentru care ordinea de
execuție este foarte importantă și care utilizează atât date mutabile,
cât și imutabile (C++, Java, C#, etc.) => folosește instrucțiuni care
schimbă starea unui program
– programare procedurală (structurată) = un program este
conceput pe baza unei secvenţe de funcţii care cooperează între
ele în atingerea scopului dorit
– programare orientata obiect = programele sunt vazute ca fiind
nişte colecţii de obiecte care interacţionează unele cu altele în
atingerea scopului dorit
 Paradigme de programare
• programare declarativă => exprimă pur și simplu logica procesării
=> scopul principal este de a descrie rezultatul dorit fără a explicita
în mod direct modalitatea de obținere a acestuia, utilizând doar tipuri
imutabile (Haskell, Prolog, Erlang, etc.) => un alt mod de a gândi
procesul de codificare care exprimă logica unui calcul fără a descrie
fluxul său de control
- programare logică
- programare funcţională
• unele limbaje se încadrează categoria limbajelor funcționale/logice
și sunt specifice domeniului (DSL): XML, HTML, SQL, CSS, etc.
 Programarea procedurală
• se bazează pe descompunerea funcţională şi abordarea top-down
(de sus în jos)
• este focalizată aproape în întregime pe producerea de instrucţiuni
(porţiuni de cod) necesare rezolvării unei anumite probleme;
proiectarea structurilor de date nu reprezintă o prioritate în această
abordare
• funcţiile care manipulează aceleaşi structuri de date pot diferi ca şi
convenţii de numire, listă de parametri, etc. făcînd dificilă utilizarea
acestora iar codul astfel rezultat este greu de înţeles existînd de
multe ori porţiuni semnificative de cod duplicat
• codul rezultat este difícil de reutilizat în alte proiecte: datorită faptului
că proiectarea începe pornind de la o problemă concretă dată,
divizînd-o în părţi componente, tendinţa este aceea de a rezulta cod
specific acelei probleme particulare
• extinderea ulterioară a aplicaţiilor este dificilă
 Programarea orientată pe obiecte
• reprezintă o tehnică de programare alternativă la programarea
structurată care se bazează pe conceptul modular de obiect. Un
obiect este un fascicul de informaţie care modelează un concept de
nivel înalt din domeniul problemei pe care o implementeză.
• abordare bottom-up (de sus in jos)
• programarea orientată pe obiecte, având la bază conceptul de
obiect şi conceptele fundamentale de încapsulare, moştenire şi
polimorfism, prezintă următoarele avantaje :
– paradigma transmiterii de mesaje între obiecte, caracteristică
programării orientate pe obiecte furnizează o sintaxă clară şi
consistentă pentru manipularea obiectelor;
– obiectele sunt prevăzute cu un set complet de funcţii necesare şi
suficiente pentru manipularea acestora
– încapsularea previne accesul neautorizat şi necontrolat asupra datelor
– moştenirea permite definirea de noi structuri de date pe baza altora
existente, reutilizând codul existent (şi testat)
 Concepte fundamentale

• Incapsularea = previne accesul neautorizat asupra datelor =>

ascunderea informatiei
=> mentenanta mai simplă
• Mostenirea = permite definirea de noi structuri de date pe baza
celor existente, prin adaugarea de noi caracteristici si facilitati
=> promoveaza reutilizarea codului
• Polimorfismul = permite crearea de programe mult mai generale
=> promoveaza reutilizarea codului
=> utilizarea componentelor software in alte proiecte,
cu impact semnificativ asupra efortului si costurilor de dezvoltare
ale aplicaţiei
 Exemplu – definirea unei clase cu
câmpuri de date şi proprietăţi
//Program.cs
Punct testpt = new Punct();
//Punct.cs
//setarea proprietatii X
internal class Punct
testpt.X = 5;
{
//setarea proprietatii Y
//campuri de date
testpt.Y = 7;
int x;
//afisare proprietati
int y;
Console.WriteLine

//proprietati get/set (" Coordonata x = "+testpt.X+

public int X { get => x; " Coordonata y = "+testpt.Y);
set => x = value;
}
public int Y { get => y;
set => y = value;
}
}
 Proprietăţi
• în loc de a avea metode specifice de tipul set/get care să
seteze/returneze valoarea câmpurilor de date corespunzătoare ale
clasei, C# defineşte o sintaxa specifică pentru proprietăţi: de regulă
cu nume similar câmpului asociat dar cu literă mare
• sintaxa generalǎ pentru o proprietate de tipul read/write este
urmǎtoarea:
modificator-acces tip_return NumeProprietate
{
get { aici se returneaza o valoare }
set { aici se atribuie o valoare }
}
• modificator acces: proprietǎţile pot fi private sau publice
• proprietǎţile pot fi de tip read/write (get/set), read-only (doar get) sau
write-only (doar set)
• în C#, proprietǎţile nu pot avea parametri
 Proprietăţi
• diferă conceptual faţă de câmpuri chiar dacă seamănă din
perspectiva utilizării: proprietǎţile oferǎ doar acces la date, dar nu
reprezintǎ datele propriu-zise
• proprietǎţile par sǎ atenueze diferenţa între cod şi date: pentru un
program care utilizeazǎ o clasǎ, proprietǎţile aratǎ ca nişte câmpuri
de date, chiar dacǎ ele reprezintǎ de fapt cod. În multe situaţii, o
proprietate publicǎ asigurǎ altor clase accesul la un câmp privat al
clasei
• proprietatea are, spre deosebire de câmp, avantajul cǎ poate face în
plus şi verificǎri de validitate
 Proprietati auto-implementate
• valabile începând versiunea
C# 3.0
• proprietatile auto-implementate
furnizeazǎ o manierǎ mai
simplǎ si concisǎ de a de a internal class Punct
defini proprietati, atunci când {
implementarea acestora NU //proprietati auto implementate
necesitǎ cod aditional public int X { get; set; }
• compilatorul crează în spatele public int Y { get; set; }
proprietăţii un câmp privat care }
însă poate fi accesat doar prin
intermediul proprietǎtii (get/set)
 Metode
• metodele unei clase reprezintă funcţii declarate în cadrul clasei şi care, de regulă,
realizează prelucrări asupra câmpurilor clasei. Sintaxa generală este:
modificator_acces tip_retur Nume_metoda(lista parametri)
{ …instructiuni… }
public void Afisare()
{ Console.WriteLine(X); Console.WriteLine(Y); }
• dacă implementarea metodei constă dintr-o singură instrucţiune, C# furnizează
aşa numitele “expression body methods”, care oferă o alternativă simplificată de
definire a metodelor: acoladele şi instrucţiunea return nu mai sunt necesare a fi
scrise explicit
modificator_acces tip_retur Nume_metoda(lista parametri) => instructiune;
public void AfisareX() => Console.WriteLine(X);
 Structura generală a unei clase
• câmpuri de date
• proprietăţi
• metode – inclusiv constructori şi destructor
• elemente de indexare sau indexatori (indexers)
• evenimente/delegaţi
• operatori
• alte tipuri: eventual, alte clase încuibate
 Spaţii de nume - namespace (1)
• un spaţiu de nume în MicroSoft .NET este asemănător cu un
container care permite identificarea unor entitǎți într-un anumit
context => existența unor entitǎți cu acelaşi nume, dar în contexte
diferite
• poate conţine o serie de elemente precum: clase, structuri,
interfeţe, enumeratori, delegaţi
• utilizat pentru organizarea ierarhică a programelor, care are ca şi
consecinţă directă evitarea conflictelor de nume în cadrul unui
proiect complex (nume de clase, funcţii, variabile) => spaţiile de
nume permit de asemenea atribuirea de nume existente deja în
.NET Framework în cadrul programelor dezvoltate
• conceptul de spaţiu de nume (namespace) faciliteazǎ de
asemenea utilizarea bibliotecilor de clase de la diverşi furnizori şi
care ar putea conţine clase cu nume similare.
 Spaţii de nume - namespace (2)
namespace Compania1.BibliotecaUtila
{
using UnAltSpatiuDeNume;
..
class ClasaUtila {....}
}
namespace Compania2.BibliotecaExtinsa
{
..
class ClasaUtila {....}
}
Compania1.BibliotecaUtila.ClasaUtila
Compania2.BibliotecaExtinsa.ClasaUtilǎ
• directiva using utilizată pentru a se specifica, la începutul programului, la
ce spaţiu sau spaţii de nume se face referire (se doreşte utilizarea claselor
incluse în cadrul acelor spaţii de nume)
using Compania1.BibliotecaUtila
• spațiile de nume pot utiliza, la rândul lor, alte spații de nume:
using UnAltSpatiuDeNume;
 Spaţii de nume - namespace (3)
• în MicroSoft .NET, fiecare program este creat împreună cu un spaţiu de
nume implicit, aşa numitul spaţiu de nume global. În cadrul programului însă
pot fi create şi alte spaţii de nume, fiecare cu un nume distinct, şi conţinînd
propriile clase, funcţii, variable sau chiar alte spaţii de nume, al căror nume
trebuie să fie unic în cadrul spaţiului de nume respectiv

• MicroSoft .NET defineşte peste 90 de spaţii de nume care încep cu cuvîntul

System şi 5 spaţii de nume care încep cu cuvîntul MicroSoft: System,
System.Drawing, System.Windows.Forms, etc. - fiecare clasǎ definitǎ în
cadrul unui proiect va fi plasatǎ în cadrul unui spaţiu de nume propriu
proiectului şi se specificǎ prin directiva using ce spaţii de nume utilizeazǎ
clasa respectiva

• nu existǎ neapǎrat corespondențǎ directǎ între fişier şi spațiul de nume: un

fişier poate include mai multe spații de nume:
fisier.cs => namespace A {}
namespace B {}
namespace C {}
 Spaţii de nume - namespace (4)
• .NET folosește spații de nume pentru a-și organiza numeroasele
clase din biblioteca de clase => fiecare tip de aplicaţie dezvoltată pe
platforma .NET utilizează biblioteci specifice (spaţii de nume) care
sunt incluse în cadrul proiectului prin directive using.
• spaţiile de nume se utilizează şi pentru declararea propriilor spații de
nume prin intermediul cărora se poate controla domeniul de aplicare
al numelor de clase și metode în proiecte de programare mai mari
=> fiecare proiect se crează implicit într-un spaţiu de nume propriu
 Includerea spaţiilor de nume -
directiva using
//clasa Program cu metoda Main generate in .NET Framework style
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleAppNetFramework
{
internal class Program
{
static void Main(string[] args)
{
Console.WriteLine("Hello World!");
}
}
}
 Includerea spaţiilor de nume -
implicit
// clasa Program generata in .NET 6
Console.WriteLine("Hello, World!");

• noua variantă folosește caracteristici recente C# care simplifică codul

• cele două forme reprezintă același program => ambele sunt valide cu
C# 10.0.
• când se utilizeaza versiunea mai nouă, trebuie doar scris corpul
metodei Main => compilatorul sintetizează o clasă Program cu o
metodă Main și plasează toate instrucțiunile scrise în acea metodă
Main; compilatorul generează includerea celelorlalte elemente
• se utilizează de asemenea directive using implicite (implicit using
directives) care sunt adăugate de către compilator în mod specific cu
tipul de proiect creat (using System; using System.IO;using
System.Collections.Generic;….)
Includerea spaţiilor de nume -
implicit

La crearea unui proiect nou, la pagina

de configurare a informațiilor
suplimentare => Do not use top-level
statements => pentru utilizare varianta
nesimplificată
 Includerea spaţiilor de nume -
implicit
• dacă este necesară utilizarea de directive using care nu sunt incluse
implicit, se pot adăuga la fișierul .cs corespunzator
• dacă se doreşte eliminarea acestui comportament implicit și controlul
manual a spațiilor de nume din proiect => prin configurarea proiectului
– directiva ImplicitUsings (enable/disable):
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net6.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
</Project>
 Ansamble (assembly)
• un ansamblu (assembly) reprezintă un bloc funcţional al unei aplicaţii .NET,
unitatea logică care conţine cod destinat platformei .NET => formează
unitatea fundamentală (structura) de distribuire, versionare, reutilizare a
codului => un ansamblu este un fișier care este generat de compilator la
compilarea cu succes a unei aplicaţii .NET.
• ansamblele sunt stocate ȋn fişiere .exe => <OutputType>Exe</OutputType
sau .dll (Dynamic Link Library)
• aplicațiile simple sunt structurate sub forma:
1 ansamblu = 1 spațiu de nume (namespace) = 1 program
• pentru aplicații mai complexe existǎ însǎ variante:
1 ansamblu = mai multe spații de nume
1 spațiu de nume poate sǎ rezide în mai multe ansamble
• în momentul execuţiei, un tip de date există în interiorul unui ansamblu (şi nu
poate exista în exteriorul acestuia) => ansamblul conţine şi metadate ce
descriu tipurile respective şi care sunt folosite de către CLR (Common
Language Runtime)
• scopul ansamblelor este să se asigure dezvoltarea softului în mod plug-and-
play
 Încapsularea
şi controlul accesului (1)
• încapsularea implică faptul că structura internă a obiectului este
ascunsă total sau parţial de obiectele din exteriorul său; accesul se
realizează prin intermediul aşa numitei interfeţe publice a obiectului
respectiv în mod controlat şi sigur.
• este de dorit să se ascundă starea internă a unui obiect faţă de
accesul direct din afara clasei prin intermediul aşa numiţilor membri
wrapper (metode, proprietăţi) care garantează consistenţa
informaţiilor accesate, controlul accesului putȃnd fi realizat prin
intermediul modificatorilor de acces asociaţi membrilor clasei
• încapsularea presupune reuniunea în cadrul claselor a structurilor de
date împreună cu codul necesar prelucrării acestor structuri
• implică modularitate, şi reprezintă mecanismul prin care se combină
câmpurile de date cu funcţii (metode, proprietăţi) care manipulează
câmpurile de date într-o manieră sigură şi controlată => încapsulare
într-o singură unitate=clasa
 Încapsularea
şi controlul accesului (2)
Modificatorii de acces (access modifier) private, protected, public,
internal controlează accesul la membri (elementele) unei clase
astfel:
• private - elementele sunt direct accesibile numai din interiorul
clasei din care fac parte; în mod automat, dacǎ nu se specificǎ
nimic în acest sens, in C# elementele respective (câmpuri de
date, proprietăţi sau metode) se considerǎ implicit private; totuşi
este indicată precizarea explicită a acestuia
• internal – elementele sunt accesibile doar în cadrul ansamblului
din care fac parte
• protected - mai putin restrictiv decit private, permite în plus şi
membrilor claselor derivate să aibe acces direct la elementele
protected ale claselor strămoşi
 Încapsularea
şi controlul accesului (3)
• public - în mod normal recomandat a fi utilizat numai pentru
metode sau proprietǎţi (nu şi câmpuri de date – încapsularea!), şi
care conferă elementelor proprietatea de a putea fi accesate in
mod direct, din orice secvenţă de cod (atât din interiorul clasei cât
şi din afara acesteia)
• protected internal - reprezintă o combinaţie a celor doi
modificatori adică şi protected şi internal: permite accesul din
cadrul aceluiaşi ansamblu dar şi din clase derivate care nu fac
parte din acelaşi ansamblu
• modificatorii de acces pot fi aplicaţi şi tipurilor de date (claselor)
însă tipurile de date acceptă doar doi modificatori de acces:
public şi internal (implicit); internal implică accesul numai la
tipurile definite în cadrul aceluiaşi ansamblu