Universitatea Tehnic a Moldovei

Catedra Automatic i Tehnologii Informaionale

Raport
Lucrarea de laborator Nr.1

la disciplina:
Ingineria produselor program
Tema:
Implementarea abloanelor de proiectare creaionale

A afectuat: st.gr.Ti-141 M. Ghelas

A verificat lect. sup. S. Scrob

Chiinu 2017
 Cuprins

ablonul Singletone....................................................................................................................... 3

Sablonul prototype ........................................................................................................................ 4

Factory method ............................................................................................................................. 6

Builder si Abstract factory ........................................................................................................... 8

Tema: Implementarea abloanelor creaionale Singletone, Factory method, Abstract factory,
Prototype, Builder.

ablonul Singletone

Intenia: proiectarea unei clase cu un singur obiect (o singura instan)

Motivaie: ntr-un sistem de operare: n exista un sistem de fiiere n exista un singur manager de
ferestre n.
Aplicabilitate: cnd trebuie s existe exact o instanta clientii clasei trebuie sa aiba acces la instanta
din orice punct bine definit abloane de proiectare

Structura:

Participant: Singleton
colaborari: clientii clasei
Consecine: acces controlat la instanta unica
reducerea spaiului de nume (eliminarea variab. globale)
permite rafinarea operaiilor si reprezentrii
permite un numar variabil de insante
mai flexibila dect operaiile la nivel de clas (statice)

Implementare:
public class Player
{
private static Player _player;
 public int Score { get; set; } = 0;

private Player()
{

public static Player GetPlayer()

{
if(_player == null)
_player = new Player();

return _player;
}

}
Diagrama de clase poate fi analizata in figura 1.

Figura 1- Diagrama de clase a sablonului singleton

Sablonul prototip
Sablonul prototype este un sablon creational. Este utilizat cind tipul obiectelor pentru creare este
determinat de o instant prototip, care este clonat pentru a produce obiect nou. Sablonul este
utilizat pentru:

Evitarea costului de a crea obiecte noi in mod standard utilizind cuvintul cheie new atunci
cind resursele sunt costisitoare.
Pentru a implementa sablonul, se declara o clasa de baza abstracta care specifica metoda clone
care implementeaza clonarea obiectului.
public abstract class Employee
{
public string Name { get; set; }
public string Role { get; set; }
public double Experience { get; set; }
public string Prefered_language { get; set; }

public abstract Employee Clone();

public abstract void GetData();
public abstract void SetData(string name, double exp, string lng);
}
public class Developer : Employee
{
public override Employee Clone()
{
return (Employee)this.MemberwiseClone();
}

public override void GetData()

{
Console.WriteLine("Name: {0}", Name);
Console.WriteLine("Role: {0}", Role);
Console.WriteLine("Experience: {0}", Experience);
Console.WriteLine("Prefered Language: {0} \n", Prefered_language);
}

public override void SetData(string name, double exp, string lng)

{
Name = name;
Role = Roles.Developer.ToString();
Experience = exp;
Prefered_language = lng;
}
}
Diagrama de clase a acestui sablon este prezentata in figura 2.
 Figura 2 - Diagrama de clase a sablonului prototip

Factory method
Definirea intefetei pentru crearea obiectului, dar subclasele decid care clasa de instantiate.
Factory Method permite subclaselor sa instantieze obiecte.

public class CharacterFactory

{

private bool _hero;

private bool _orc;
private bool _zombi;
private Dictionary<CharacterRoles, Character> _characters = new
Dictionary<CharacterRoles, Character>();

public CharacterFactory()
{
_hero = false;
_orc = false;
_zombi = false;
}

public Character CreateCharacter(CharacterRoles role)

{
Character character = null;

if (role == CharacterRoles.Hero)
{
 if (!_hero)
{
character = new HeroCharacter();
_hero = !_hero;
_characters.Add(CharacterRoles.Hero, character);
}
else
{
var ch = _characters.Where(kvp => kvp.Key ==
CharacterRoles.Hero).Select(x => x.Value).Single();
character = ch.Clone();
}
}
else if (role == CharacterRoles.Orc)
{
if (!_orc)
{
character = new OrcCharacter();
_orc = !_orc;
_characters.Add(CharacterRoles.Orc, character);
}
else
{
var ch = _characters.Where(kvp => kvp.Key ==
CharacterRoles.Orc).Select(x => x.Value).Single();
character = ch.Clone();
}
}
else if (role == CharacterRoles.Zombi)
{
if (!_zombi)
{
character = new ZombiCharacter();
_zombi = !_zombi;
_characters.Add(CharacterRoles.Zombi, character);
}
else
{
var ch = _characters.Where(kvp => kvp.Key ==
CharacterRoles.Zombi).Select(x => x.Value).Single();
character = ch.Clone();
}
}

return character;
}

}
Diagrama de clase a sablonului este prezentata in figura 3.
 Figura 3 - Diagrama de clase a sablonului factory method

Builder si Abstract factory

Abstract factory
Asigur o interfa pentru crearea familiilor de obiecte legate sau dependente far de a specifica
clasa lor concret.
Builder
Separa constructia obiectelor complexe de reprezentare pentru ca aceelasi process de constructie
sa creeze reprezentari diferite.
Diagrama sablonului abstract factory este prezentata in figura 4.

Figura 4 - Diagrama de clase a sablonului abstract factory

BUILDER
public class TeamRegister
{
public void CreateTeam(ITeamBuilder team)
{
team.SetGoalKeeper();
team.SetDefence();
team.SetMedfield();
team.SetAttack();

Team finalTeam = team.GetFinalTeam();

finalTeam.ShowTeam(finalTeam);
}
}

Diagrama de clase a acestui sablon este reprezentata in figura 5.

Figura 5 - Diagrama de clase a sablonului Builder

Concluzie
abloanele ne ajut pentru proiectarea corect a arhitecturii unei aplicaii. abloanele se
utilizeaz n dependen de problemele de proiectare care apar n procesul dezvoltrii unui proiect.
ablonul Singleton se utilizeaz pentru a rezolva problema de creare a unei singure
instane a unei clase. Abstract factory creaz o instan a mai multor familii de clase, reprezint un
factory la o alt mulime de factory, nivelul de abstractizare fiind reprezentat in 2 nivele. Builder
separ reprezentarea obiectului de construirea lui, n aa mod putem construi obiecte complexe
printr-o arhitectur mai simpl a codului. Factory method creaza instane a mai multor clase
derivate, acest fapt ne ofer posibilitatea de a construi obiecte separat de client. Prototype creaz
clone de obiecte pentru a utiliza resursele eficient.