Design patterns
Modello di prototipo
Ricerca…
introduzione
Il pattern Prototype è un pattern creazionale che crea nuovi oggetti clonando l'oggetto prototipo esistente. Il modello del prototipo accelera l'istanziazione delle classi quando la copia degli oggetti è più veloce.
Osservazioni
Il modello prototipo è un modello di design creativo. Viene utilizzato quando il tipo di oggetti da creare è determinato da un'istanza prototipica, che viene "clonata" per produrre nuovi oggetti.
Questo modello viene utilizzato quando una classe ha bisogno di un "costruttore di materiali polimorfici (copia)" .
Prototype Pattern (C ++)
class IPrototype {
public:
virtual ~IPrototype() = default;
auto Clone() const { return std::unique_ptr<IPrototype>{DoClone()}; }
auto Create() const { return std::unique_ptr<IPrototype>{DoCreate()}; }
private:
virtual IPrototype* DoClone() const = 0;
virtual IPrototype* DoCreate() const = 0;
};
class A : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<A>{DoClone()}; }
auto Create() const { return std::unique_ptr<A>{DoCreate()}; }
private:
// Use covariant return type :)
A* DoClone() const override { return new A(*this); }
A* DoCreate() const override { return new A; }
};
class B : public IPrototype {
public:
auto Clone() const { return std::unique_ptr<B>{DoClone()}; }
auto Create() const { return std::unique_ptr<B>{DoCreate()}; }
private:
// Use covariant return type :)
B* DoClone() const override { return new B(*this); }
B* DoCreate() const override { return new B; }
};
class ChildA : public A {
public:
auto Clone() const { return std::unique_ptr<ChildA>{DoClone()}; }
auto Create() const { return std::unique_ptr<ChildA>{DoCreate()}; }
private:
// Use covariant return type :)
ChildA* DoClone() const override { return new ChildA(*this); }
ChildA* DoCreate() const override { return new ChildA; }
};
Ciò consente di costruire la classe derivata da un puntatore della classe base:
ChildA childA;
A& a = childA;
IPrototype& prototype = a;
// Each of the following will create a copy of `ChildA`:
std::unique_ptr<ChildA> clone1 = childA.Clone();
std::unique_ptr<A> clone2 = a.Clone();
std::unique_ptr<IPrototype> clone3 = prototype.Clone();
// Each of the following will create a new default instance `ChildA`:
std::unique_ptr<ChildA> instance1 = childA.Create();
std::unique_ptr<A> instance2 = a.Create();
std::unique_ptr<IPrototype> instance3 = prototype.Create();
Modello di prototipo (C #)
Il modello prototipo può essere implementato utilizzando l'interfaccia ICloneable in .NET.
class Spoon {
}
class DessertSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
class SoupSpoon : Spoon, ICloneable {
...
public object Clone() {
return this.MemberwiseClone();
}
}
Prototype Pattern (JavaScript)
Nei linguaggi classici come Java, C # o C ++ iniziamo creando una classe e quindi possiamo creare nuovi oggetti dalla classe o estendere la classe.
In JavaScript per prima cosa creiamo un oggetto, quindi possiamo aumentare l'oggetto o creare nuovi oggetti da esso. Quindi penso che JavaScript mostri un prototipo reale rispetto al linguaggio classico.
Esempio :
var myApp = myApp || {};
myApp.Customer = function (){
this.create = function () {
return "customer added";
}
};
myApp.Customer.prototype = {
read: function (id) {
return "this is the customer with id = " + id;
},
update: function () {
return "customer updated";
},
remove: function () {
return "customer removed";
}
};
Qui, creiamo un oggetto denominato Customer , e quindi senza creare nuovo oggetto abbiamo esteso l' Customer object esistente utilizzando la parola chiave prototype . Questa tecnica è conosciuta come Prototype Pattern .