Tra
le varie limitazioni che ci siamo imposti, dobbiamo rispettare :
"l'aggiunta
di una nuova operazione non deve essere invasiva"
per
rispettare questa richiesta dobbiamo usare un contratto comune a
tutte le operazioni che vogliamo implementare:
public
interface IOperation
{
void
Display(Action<string>
action);
void
Execute();
}
public
interface IBalanceResponse
{
void
Return(Amount
amount);
}
public
class Balance
: IOperation, IBalanceResponse
{
private
readonly
IAccount
account;
private
readonly
IViewOperations
view;
public
Balance(IAccount
account, IViewOperations view)
{
this.account
= account;
this.view
= view;
}
public
void
Display(Action<string>
action)
{
action("Saldo");
}
public
void
Execute()
{
account.BalanceRequest(this);
}
void
IBalanceResponse.Return(Amount
amount)
{
view.Response(string.Format("Il
saldo corrente corrisponde a euro: {0}",
amount.Value));
}
}
L'oggetto
Balance implementa IOperation che è il contratto comune per gestire
tutte le operazioni sull'oggetto IAccount.
Dopo aver ricevuto l'input dalla View,
l'oggetto Operations converte il valore nella corrispondente operazione.
Quando viene eseguito il comando Balance, viene chiamato
BalanceRequest di Account passando l'oggetto che riceverà il
feedback, a tal uopo Balance implementa IBalanceResponse per isolare lo scope di utilizzo.
Vediamo
come è stato implementato IAccount:
public
interface IAccount
{
void
BalanceRequest(IBalanceResponse
balance);
}
public
class
Account
: IAccount
{
private
Amount
current;
public
Account()
{
current
= new
Amount(0);
}
public
void
BalanceRequest(IBalanceResponse
balance)
{
balance.Return(current);
}
}
Quando
l'operatore richiede il saldo, Account riceve la richiesta e notifica
tramite il messaggio Return il valore del saldo corrente. Anche in
questo caso abbiamo usato un sistema di notifica per far interagire
due oggetti.
Stiamo applicando i seguenti principle:
Stiamo applicando i seguenti principle:
Nessun commento:
Posta un commento