Sarcina :

Crearea unui programa utilizant sabloanelel de proiectare Composite si Builder, care va gestiona
necesitatile unei sali de sport.

Problema identificata :

Fiin in regim de pandemiasala noastra a decis sa organizeze un program online de antrenament. Pentru
a facilita interactiunea dintre membrii , ne-am gandit ca fiecare antrenor sa aiba un grup de cateva
persoane , iar cea mai buna persoana din grupa respectiva sa poata antrena o grupa proprie . Iar o alta
optiune este crearea unui program specific de antrenament pentru fiecare membru.

Deci pentru a putea implimenta aceasta posibilitatea in care un antrenor poate avea mai multi membrii
in echipa , iar cel mai bun sa poata avea propria echipa , iar ei ca antrenori sa decida pe cine sa adauge ,
pe cine sa scoata din echipa , si sa obtina informatia despre echipa la nivele <<ierarhice mai jos>> fara a
depinde daca este si el antrenat de cineva am decis implimentarea sablonului de proiectare Composite ,
care ne ajuta sa creem structuri asemanatoare arborilor , unde fiecare not poate actiona de sine statator
cu ramificatiile care pleaca de la el. Iar pentru crearea de antrenamente specifice pentru fiecare
membru am decis implimentarea sablonului Builder.
Diagrame UML :

Diagramele pentru care demonstreaza implimentarea clasei ce reprezinta

1)Component - PersonEntity

2)Composite – Trainer , care mosteneste si de la interfata ITrainer pentru a putea adauga/scoate

membrii din echipa

3)Leaf - Member

Diagramele pentru care demonstreaza implimentarea clasei ce reprezinta

1)Director - TrainerService

2)Builder - ISession

3)Concret Builder –GetTrainingSession

4)Product - TrainingSession
Codul sursa :

PersonEntity.cs

public abstract class PersonEntity

{
private TrainerService trainer = new TrainerService();
private GetTrainingSession trainingSession = new GetTrainingSession();

protected string name;

protected TrainingSession session;

public PersonEntity(string name, TrainingType type)

{
this.name = name;
trainer.Session = trainingSession;
if(type == TrainingType.TypeOne)
{
trainer.GetTypeOneTrainingSession();
}
else if(type == TrainingType.TypeTwo)
{
trainer.GetTypeTwoTrainingSession();
}
session = trainingSession.GetProduct();
}

public abstract int GetTeamCount();

public abstract List<ExerciseTypes> GetTrainingSession();
}
Trainer.cs

public class Trainer : PersonEntity , ITrainer

{
private List<PersonEntity> teamMembers;
public Trainer(string name, TrainingType type) : base(name,type)
{
teamMembers = new List<PersonEntity>();
}

public void AddMember(PersonEntity entity)

{
teamMembers.Add(entity);
}

public void RemoveMember(PersonEntity entity)

{
teamMembers.Remove(entity);
}

public override int GetTeamCount()

{
int count = 1;
foreach(var obj in teamMembers)
{
count += obj.GetTeamCount();
}
return count;
}

public override List<ExerciseTypes> GetTrainingSession()

{
var newList = new List<ExerciseTypes>();
newList.AddRange(session.ExercisesList());
foreach(var obj in teamMembers)
{
newList.AddRange(obj.GetTrainingSession());
}
return newList.Distinct().ToList();

}
}

Member.cs
public class Member : PersonEntity
{
public Member(string name, TrainingType type) : base(name,type)
{

public override int GetTeamCount()

{
return 1;
}
public override List<ExerciseTypes> GetTrainingSession()
{
return session.ExercisesList();
}
}

TrainerService.cs

public class TrainerService

{
private ISession _session;

public ISession Session

{
set { _session = value; }
}

public void GetTypeOneTrainingSession()

{
this._session.AddBicepsExercises();
this._session.AddLegsExercises();
this._session.AddTricepsExercises();
}

public void GetTypeTwoTrainingSession()

{
this._session.AddBicepsExercises();
this._session.AddCardioExercises();
this._session.AddTricepsExercises();
this._session.AddCardioExercises();
}
}
GetTrainingSession
public class GetTrainingSession : ISession
{

private TrainingSession _session = new TrainingSession();

public GetTrainingSession()
{
this.Reset();
}

public void Reset()

{
this._session = new TrainingSession();
}

public void AddChestExercises()

{
_session.Add(ExerciseTypes.ChestExercises);
}

public void AddBicepsExercises()

{
_session.Add(ExerciseTypes.BicepsExercises);
}

public void AddLegsExercises()

{
_session.Add(ExerciseTypes.LegsExercises);
}

public void AddTricepsExercises()

{
_session.Add(ExerciseTypes.TricepsExercises);
}

public void AddCardioExercises()

{
_session.Add(ExerciseTypes.CardioExercises);
}

public TrainingSession GetProduct()

{
TrainingSession result = this._session;

this.Reset();

return result;
}
}
ISession.cs
public interface ISession
{
public void AddChestExercises();
public void AddBicepsExercises();
public void AddLegsExercises();
public void AddTricepsExercises();
public void AddCardioExercises();
}

TrainingSession
public class TrainingSession
{
private List<ExerciseTypes> _exercises = new List<ExerciseTypes>();

public void Add(ExerciseTypes part)

{
this._exercises.Add(part);
}

public List<ExerciseTypes> ExercisesList()

{
return _exercises;
}
}

Program.cs

var trainerOne = new Trainer("Nicu", TrainingType.TypeOne);

var memberOne = new Member("Max", TrainingType.TypeTwo);
var trainerTwo = new Trainer("Ion", TrainingType.TypeTwo);
trainerOne.AddMember(memberOne);
trainerOne.AddMember(trainerTwo);
Console.WriteLine(trainerOne.GetTeamCount());
foreach(var obj in trainerOne.GetTrainingSession())
{
Console.WriteLine(obj);
}
Concluzie :
In cadrul acestei lucrari de laborator m-am familiarizat cu un sablon de proiectare nou : Composite si am
aplicat intr-o alta solutie sablonul Builder. Fiecare a fost conceput pentru a rezolva o anumita problema.
Composite este sablonul de proiectare care nu ajuta sa facem un management eficient atunci cand
datele noastre sunt organizate in forma unui arbore , iar fiecare nod are posibilitatea sa actioneze de
sine statator , iar sablonul Builder ne permite sa construim obiecte complexe cu configuratii diferite.