Selasa, 24 April 2012

Modul 2 Creational Pattern (Prototype, Singleton)

2.1. Prototype Pattern
Prototype Pattern adalah sebuah design pattern kreatif yang digunakan dalam pengembangan perangkat lunak. Jenis object untuk membuat object baru ditentukan oleh prototype contoh. Object di kloning untuk menghasilkan object baru. Prototype pattern masuk dalam creational pattern pola ini merupakan pola yang paling mudah.
Pattern ini digunakan untuk:
·       Menghindari subclass dari object kreator dalam aplikasi klien, tidak seperti abstract factory pattern.
·       Menghindari biaya yang melekat (inherent cost) dari object baru yang dibuat sesuai standar (misalnya, dengan menggunakan keyword ‘new‘), saat biaya itu cukup mahal untuk aplikasi tertentu.
Untuk mengimplementasikan pattern, deklarasikan sebuah abstract base class yang menentukan sebuah pure virtual clone () method. Setiap class yang memerlukan sebuah “polymorphic constructor”, maka kemampuan itu berasal dari class abstract base dirinya sendiri, dan mengimplementasikan operasi clone ().
Klien, bukanya menulis kode yang meminta operator “new” pada sebuah hard-coded class name, memanggil method clone () pada prototipe, memanggil sebuah factory method dengan sebuah parameter tertentu yang menunjuk particular concrete  kelas turunan yang diinginkan, atau mengacu pada method clone () melalui beberapa mekanisme yang disediakan oleh design pattern lain.
Berikut adalah contoh code program prototype pattern pada c#:
class ConcretePrototype : ICloneable
{
    public int X { get; set; }
    public ConcretePrototype(int x)
    {
        this.X = x;
    }

    public void PrintX()
    {
        Console.WriteLine(“Value :” + X);
    }
    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

/**
* Client code
*/
public class PrototypeTest
{
    public static void Main()
    {
        var prototype = new ConcretePrototype(1000);

        for (int i = 1; i < 10; i++)
        {
            ConcretePrototype tempotype = prototype.Clone() as ConcretePrototype;

            // Usage of values in prototype to derive a new value.
            tempotype.X *= i;
            tempotype.PrintX();
        }
        Console.ReadKey();
    }
}
2.2.Singleton Pattern
Singleton Pattern adalah sebuah creational pattern yang menyatakan bahwa dalam sebuah aplikasi hanya boleh terdapat satu instance dari sebuah class. Terkadang muncul pikiran mengapa hanya ada satu instance yang diperbolehkan ? atau mengapa tidak menggunakan global variable saja (kalau anda yang terbiasa menggunakan pascal, dan basic serta bahasa turunan mereka pasti mengenal yang namanya global variable).
Class-class seperti database connection pool, Logging hanya diperlukan sebuah saja instance dari masing-masing class untuk digunakan pada aplikasi. Class-class yang tipenya serupa dengan keduanya hanya diperlukan sebuah saja.
Penggunaan global variable sekilas memang bisa digunakan untuk mengatasi permasalahan satu instance untuk aplikasi jika aplikasi yang dibangun tidak besar dan tidak melibatkan banyak code designer. Jika aplikasi yang dibangun berskala besar dan melibatkan banyak orang tentu akan menyulitkan jika menggunakan global variable karena belum tentu aman dan bisa disetujui oleh banyak orang serta siapa yang berhak untuk melakukan inisialisasi object.
Singleton pattern mengatasi semua masalah ini, singleton pattern bisa memastikan bahwa hanya terdapat satu instance yang dibuat sehingga dapat dipastikan bahwa tidak akan ada lebih dari sebuah instance dalam aplikasi. Contoh implementasinya dalam C# adalah sebagai berikut:
///
/// Singleton class in C#
///
public class Singleton
{
    ///
    /// only a single instance of Singleton is allowed
    /// so we make it as static;
    ///
    private static Singleton instance=null;
///
    /// class constructor make it private access from others
    ///
    private Singleton()
    {
    }
///
    /// get the instance of class
    /// the only one instance
    ///
    public static Singleton Instance()
    {
            if(null==instance)
            instance = new Singleton();
        return instance;
    }
}
Yang terpenting dari class diatas adalah variable instance yang bertipe static dan dan constructor dibuat private sehingga class tersebut hanya bisa di inisialisasi oleh dirinya sendiri, serta dibuat class method instance() yang digunakan untuk mendapatkan instance dari class. Contoh class client yang menggunakan singleton class adalah sebagai berikut:
class Client
{
    ///
    /// The main entry point for the application.
    ///
    [STAThread]
    static void Main(string[] args)
    {
        Singleton s = Singleton.Instance();
        Singleton sx = Singleton.Instance();
        if(s.Equals(sx))
            Console.WriteLine(“they are equals”);
        else
            Console.WriteLine(“they are not equals”);
    }

0 komentar:

Posting Komentar