Ministerul Educației al Republicii Moldova

Universitatea Tehnică a Moldovei

Departamentul Inginerie Software si Automatica

RAPORT
Lucrare de laborator Nr. 2
la disciplina "Ingineria Produselor Program"
Tema: Șabloane structurale

Elaborat de Tănăsescu Tudor

Grupa TI-141

Verificat de asist. univ. Scrob Sergiu

Chișinău 2017
Scopul Lucrării: De studiat și de implementat 5 șabloane structurale la alegere.

Șabloane structurale - șabloane de proiectare ce rezolvă probleme ce țin de relații dintre

entități. Aceste șabloane aduc răspuns la întrebări ca ce entitate trebuie să cunoască ce entitate, ce
entitate are acces la ce entitate, compunerea de entități.
Adapter este un șablon structural ce are ca scop convertirea unei interfețe la o altă interfață
așteptată de client. El permite claselor să funcționeze împreună, în cazul în care acestea nu pot
funcționa din cauza interfețelor incompatibile. În figura 1 este reprezentă digrama de clase a unei
implementări ale acestui șablon.

Figura 1. Diagrama claselor a șablonului Adapter

În acest caz clasa ShapePainter are nevoie de a desena o figură prin precizarea punctelor
inițiale și a dimensiunii figurii, iar adaptorul – PainterAdaptor permite utilizarea unei clase ce
desenează figuri folosind punctele inițiale și finale a figurii.

Bridge este un șablon structural ce are ca scop decuplarea abstracțiilor de implementări,

permițând acestora să varieze independent. Acesta permite clienților să utilizeze diferite
implementări în timpul rulării. Acest pattern se realizează prin separarea unei abstracții ca un
implementor aparte. În figura 2 este reprezentată implementarea acestui șablon.

1
 Figura 2. Diagrama claselor a șablonului Bridge

În acest exemplu a fost separată logarea de computare ceea ce permite instanțelor clasei
Computation să utilizeze diferite implementări a logării – ConsoleLogger sau FileLogger.
Diferența dintre Adapter și Bridge este că Adaptorul este utilizat pentru a conecta entități deja
existente incompatibile, iar Bridge soluționează separarea abstracțiilor ce trebuie implementate.

Decorator este un șablon structural ce are ca scop soluționarea problemei adăugării

responsabilităților la obiecte, dinamic, în timpul rulării. De obicei responsabilitățile sunt atribuite
claselor în timpul compilării, iar aceste responsabilități sunt statice. Acest șablon propune o
alternativă flexibilă utilizând compoziția obiectelor. Diagrama claselor a acestui șablon este
reprezentată în figura 3.

2
 Figura 3. Diagrama claselor a șablonului Decorator

Acest șablon este format din un tip Component și un tip Decorator, ce au aceleași interfață.
Decoratorul are o instanță a clasei Component, iar datorită implementării aceleiași interfețe,
ambele pot fi utilizate în aceleași locuri. Decoratorul însă mai poate adăuga responsabilități la
instanța pe care o încapsulează.

Facade e un șablon simplu ce are de a simplifica subsisteme complexe prin expunerea a

unei interfețe simple a subsistemului. Ea asigură expunerea doar a metodelor necesare, și duce la
minimizarea dependențelor fiind punte între subsistemul încapsulat. Acest șablon este reprezentat
în figura 4.

3
 Figura 4. Diagrama claselor a șablonului Facade

În exemplul dat interfața fațadei expune doar anumite metode a claselor ce le încapsulează.
Clientul, în cazul dat, nu cunoaște care clase implementează metodele ce le apelează, și nu ține
legătura directă cu clasele subsistemului. Astfel se reduc dependențele între aceștia obținându-se
o cuplare slabă.

Proxy este un șablon structural ce are ca scop rezolvarea problemelor ca restricționarea

accesului la un obiect, sau adăugare de funcțional acestuia. Aceasta este realizat utilizând o clasă
surogat ce are aceeași interfață ca și clasa necesară clientului. Există trei tipuri ale acestui șablon:
remote – asigură accesul la un obiect distant, virtual – ține locul unui obiect complex; protecție -
limitează accesul la un anumit obiect. O implementare a unui proxy virtual este reprezentată în
figura 5.

4
 Figura 5. Diagrama claselor a șablonului Proxy

În acest șablon, proxy încapsulează în sine subiectul, astfel permițând adăugarea

funcționalului acestuia. În exemplul dat clasa Map prezintă o clasă de obiecte complexe greu de
încărcat, iar ProxyMap fiind un proxy virtual. În cazul dat poate sau nu fi apelată metoda Draw().
Ca să fie evitată instanțierea în zadar a clasei Map, este utilizat un proxy ce va instanția un subiect
real numai dacă va fi apelată vreo metodă a subiectului.

5
Concluzii
În urma efectuării acestei lucrări au fost studiate cinci șabloanele structurale și s-a încercat
implementarea acestor șabloane.
Șablonul Adapter prezintă o soluție de a interconecta două interfețe existente. Aceasta se
realizează prin utilizarea unei clase adiționale ce implementează interfața necesară clientului și
utilizează o instanță a interfeței incompatibilă. Aceasta rezolvă problema incompatibilității fără a
modifica clasele existente.
Șablonul Bridge este utilizat în cazul în care este necesară separarea abstracțiilor de
implementări. Aceasta permite definirea unei implementări independente, ce poate fi aleasă în
timpul rulării.
Diferența dintre Bridge și Adapter este că Adapter interconectează abstracții existente
incompatibile, iar Bridge prezintă soluții pentru a obține abstracții separate independente.
Șablonul Decorator este utilizat la necesitatea adăugării a mai multor funcționalități unui
obiect, în mod dinamic, în timpul rulării. Aceasta se realizează prin compoziția obiectelor cu
aceeași interfață ca subiect, iar cu fiecare compunere sunt adăugate funcționalități noi.
Destinația șablonului Facade este de a simplifica un sistem complex, prin încapsularea
acestuia cu o singură clasă, care expune doare o interfață simplă cu doar metodele necesare
clientului. Astfel clientul nu cunoaște fiecare clasă a subsistemului ci doar fațada ei. Acest șablon
duce la obținerea cuplărilor minime.
Șablonul Proxy are ca scop rezolvarea problemelor ca restricționarea accesului la un anumit
obiect, sau adăugarea funcționalului nou acestuia. Acesta este realizat cu ajutorul unei clase
surogat ce se utilizează în locul subiectului real, și adaugă funcțional nou lui. Există trei tipuri de
proxy: remote - ce are ca scop permiterea accesului la un obiect distant; virtual – ca înlocțiito a
unui obiect complex, ce poate fi încărcat greu; protection – ce premite limitarea accesului la
subiect.
Șabloanele structurale prezintă metode de a rezolva probleme ce pot apărea la relații între
entități prin specificarea modului de acces și cunoaștere între entități.

6
 Anexa A
Codul sursă a implementării șablonului Adapter

class Program
{
static void Main(string[] args)
{
var painter = new ShapePainter(new PainterAdapter());

painter.DrawRect(20, 20, 50, 80);

Console.ReadKey();
}
}

public interface IPainter

{
void DrawRect(int x, int y, int width, int height);
}

public class FigureDrawer

{
public void DrawRectangle(int xStart, int yStart, int xEnd, int yEnd)
{
Console.WriteLine($"Rectangle from ({xStart}, {yStart}) to ({xEnd}, {yEnd}).");
}
}

public class ShapePainter

{
private readonly IPainter _painter;

public ShapePainter(IPainter painter)

{
_painter = painter;
}

public void DrawRect(int x, int y, int width, int height)

{
_painter.DrawRect(x, y, width, height);
}
}

public class PainterAdapter : IPainter

{
private readonly FigureDrawer _drawer = new FigureDrawer();

public void DrawRect(int x, int y, int width, int height)

{
_drawer.DrawRectangle(x, y, x+width, y+height);
}
}

7
 Anexa A
Codul sursă a implementării șablonului Bridge

class Program
{
static void Main(string[] args)
{
IComputation computation = new Computation(new ConsoleLogger());
computation.Compute();

computation = new Computation(new FileLogger());

computation.Compute();

Console.ReadKey();
}
}

public interface ILogger

{
void Log(string str);
}

public class ConsoleLogger : ILogger

{
public void Log(string str)
{
Console.WriteLine($"Console: {str}");
}
}

public class FileLogger : ILogger

{
public void Log(string str)
{
Console.WriteLine($"Log.txt: {str}");
}
}

public interface IComputation

{
ILogger Logger { get; }

void Compute();
}

public class Computation : IComputation

{
public ILogger Logger { get; }

public Computation(ILogger logger)

{
Logger = logger;
}

public void Compute()

{
var a = 8;
var b = 7;
Logger.Log($"{a}x{b}={a*b}");
}
}

8
 Anexa A
Codul sursă a implementării șablonului Decorator

class Program
{
static void Main(string[] args)
{
var k = new KeyComponent('K');
Console.WriteLine(k);

k = new ShiftKeyDecorator(k);
Console.WriteLine(k);

k = new CtrlKeyDecorator(k);
Console.WriteLine(k);

k = ((KeyDecorator)k).Undecorated;
Console.WriteLine(k);

Console.ReadKey();
}
}

public interface IKeyComponent

{
int KeyCode { get; }
}

public class KeyComponent : IKeyComponent

{
public virtual int KeyCode { get; }

public KeyComponent(int keyCode)

{
KeyCode = keyCode;
}

public override string ToString()

{
return Convert.ToString(KeyCode, 2).PadLeft(32, '0');
}
}

public abstract class KeyDecorator : KeyComponent

{
protected int KeyModifier;
private readonly KeyComponent _component;

public KeyComponent Undecorated

{
get { return _component; }
}

public override int KeyCode

{
get { return _component.KeyCode | KeyModifier; }
}

protected KeyDecorator(KeyComponent component) : base(component.KeyCode)

9
 {
_component = component;
}
}

public class ShiftKeyDecorator : KeyDecorator

{
public ShiftKeyDecorator(KeyComponent component) : base(component)
{
KeyModifier = 1 << (32 - 1);
}
}

public class AltKeyDecorator : KeyDecorator

{
public AltKeyDecorator(KeyComponent component) : base(component)
{
KeyModifier = 1 << (32 - 2);
}
}

public class CtrlKeyDecorator : KeyDecorator

{
public CtrlKeyDecorator(KeyComponent component) : base(component)
{
KeyModifier = 1 << (32 - 3);
}
}

10
 Anexa A
Codul sursă a implementării șablonului Facade

class Program
{
static void Main(string[] args)
{
IImageProcessorFacade facade = new ImageProcessorFacade();
facade.ApplyBlackWhite();
facade.ApplySepia();

facade.Rotate(90);

facade.DrawShape();
facade.DrawText("LABEL TEXT");

Console.ReadKey();
}
}

public interface IImageProcessorFacade

{
void ApplyBlackWhite();
void ApplySepia();
void DrawShape();
void DrawText(string text);
void Rotate(int angle);
}

public class ImageProcessorFacade : IImageProcessorFacade

{
public void Rotate(int angle)
{
new ImageTransformer().Rotate(angle);
}

public void ApplySepia()

{
new ImageEffects().ApplySepia();
}

public void ApplyBlackWhite()

{
new ImageEffects().ApplyBlackWhite();
}

public void DrawText(string text)

{
new ImageDrawer().DrawText(text);
}

public void DrawShape()

{
new ImageDrawer().DrawShape();
}
}

internal class ImageTransformer

{
public void Rotate(int angle)
{
Console.WriteLine($"Rotated by {angle} degrees.");

11
 }
}

internal class ImageEffects

{
public void ApplySepia()
{
Console.WriteLine("Applied Sepia");
}

public void ApplyBlackWhite()

{
Console.WriteLine("Applied Black&White");
}
}
internal class ImageDrawer
{
public void DrawText(string text)
{
Console.WriteLine($"Drawn {text}.");
}

public void DrawShape()

{
Console.WriteLine("Drawn shape");
}
}

12
 Anexa A
Codul sursă a implementării șablonului Proxy

class Program
{
static void Main(string[] args)
{
var worldMap = new WorldMap(new ProxyMap());

worldMap.Draw();

Console.ReadKey();
}
}

public class WorldMap

{
private readonly IMap _map;

public WorldMap(IMap map)

{
_map = map;
}

public void Draw()

{
_map.Draw();
}
}

public interface IMap

{
void Draw();
}

public class ProxyMap : IMap

{
private static readonly Lazy<Map> Lazy = new Lazy<Map>(() => new Map());

private static Map Map

{
get { return Lazy.Value; }
}

public void Draw()

{
Map.Draw();
}
}

public class Map : IMap

{
public void Draw()
{
Console.WriteLine("Map drawn.");
}
}

13