Prototype

Especifica os tipos de objetos a serem criados usando uma instância-protótipo e cria novos objetos a partir do mesmo. É recomendado usar este padrão para evitar o crescimento de classes no sistema.

O Prototype e os padrões fábricas são similares em sua intenção. Ambos são criacionais. A principal diferença entre eles é o modo que são construídos. Nas fábricas, pode-se construir objetos usando os parâmetros de cada vez. Há uma similaridade entre eles. O Prototype, é usado para clonar qualquer objeto dado.

1. Diagrama de Classes


2. Considerações Importantes

Provavelmente, o mais complexo deste padrão é o método clone. Ela pode ser difícil quando a clone faz o uso de referências. Para algumas linguagens mais dinâmicas, como nosso c# ou Java, há uma implementação genérica por reflection. O nome da técnica usada é shallow clone. Naturalmente, você pode implementar seu próprio método-clone, programaticamente (chama-se deep copy).

3. Benefícios x Desvantagens

Acrescenta e remove produtos em tempo de execução: permite que incorporar uma nova classe concreta apenas registrando uma instância prototype com o cliente, deixando flexível instalar e remover em tempo de execução.

Reduz o número de subclasses: evita uma explosão de classes, pois permite clonar em vez de criar um novo objeto. Você pode especificar novos objetos a partir da variação da estrutura interna.

4. Código

C#

using System;
using System.Collections.Generic;
using System.Text;

namespace Prototype
{
    class Program
    {

        static void Main(string[] args)
        {
            Prototype p1 = new ConcretePrototype1("ID");
            Prototype c1 = p1.Clone();
            Console.WriteLine("Real: {0} - Clone: {1}", p1.ToString(), c1.ToString());
        }
    }


    public abstract class Prototype
    {

        private string _id;


        public string ID
        {
            get { return _id; }
            set { _id = value; }
        }


        public Prototype(string id)
        {
            this.ID = id;
        }


        public override string ToString()
        {
            return ID;
        }

        public abstract Prototype Clone();
    }


 
    public class ConcretePrototype1 : Prototype
    {

        public ConcretePrototype1(string id) :base(id)
        {
        }



        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }
    }


    public class ConcretePrototype2 : Prototype
    {
        public ConcretePrototype2(string id) : base(id)
        {
        }

        public override Prototype Clone()
        {
            return (Prototype)this.MemberwiseClone();
        }
    }
}

VB.NET

Imports System
Imports System.Collections.Generic
Imports System.Text

Namespace Prototype
    Class Program
        
        Private Shared Sub Main(ByVal args As String())
            Dim p1 As Prototype = New ConcretePrototype1("ID")
            Dim c1 As Prototype = p1.Clone()
            Console.WriteLine("Real: {0} - Clone: {1}", p1.ToString(), c1.ToString())
        End Sub
    End Class
    
    
    Public MustInherit Class Prototype
        
        Private _id As String
        
        
        Public Property ID() As String
            Get
                Return _id
            End Get
            Set(ByVal value As String)
                _id = value
            End Set
        End Property
        
        
        Public Sub New(ByVal id As String)
            Me.ID = id
        End Sub
        
        
        Public Overloads Overrides Function ToString() As String
            Return ID
        End Function
        
        Public MustOverride Function Clone() As Prototype
    End Class
    
    
    
    Public Class ConcretePrototype1
        Inherits Prototype
        
        Public Sub New(ByVal id As String)
            MyBase.New(id)
        End Sub
        
        
        
        Public Overloads Overrides Function Clone() As Prototype
            Return DirectCast(Me.MemberwiseClone(), Prototype)
        End Function
    End Class
    
    
    Public Class ConcretePrototype2
        Inherits Prototype
        Public Sub New(ByVal id As String)
            MyBase.New(id)
        End Sub
        
        Public Overloads Overrides Function Clone() As Prototype
            Return DirectCast(Me.MemberwiseClone(), Prototype)
        End Function
    End Class
End Namespace