 SİTE
İÇİ ARAMA |
|
|
 Blogroll |
|
|
|
|
|
|
"Builder" Tasarım Deseninin C# ile Gerçekleştirilmesi |
|
| Gönderiliyor lütfen bekleyin... |
|
|
Bu yazıda "Creational"
desenler grubunda yer alan "Builder" tasarım deseninden ve bu deseni
C# ile nasıl gerçekleştirebileceğimizden bahsedeceğim.
Bu yazıyı okumadan önce "Singleton"
ve "Abstract Factory" tasarım
desenlerini konu alan yazılarımı okumanızı tavsiye ederim.
"Builder" deseni adından da anlaşılacağı üzere bir nesnenin oluşturulması
ile ilgilidir. Bu desende kullanılan yapılar hemen hemen "Abstract Factory"
deseninde kullanılan yapılar ile aynıdır. Bu iki desen arasında çok küçük farklılıklar
vardır. Bu farkları ilerleyen kısımlarda açıklayacağım.
"Builder" deseni birden fazla parçadan oluşan kompleks yapıdaki bir
nesnenin oluşturulmasını ve bu kompleks nesnenin oluşturulma safhalarını istemci
modülünden tamamen gizlemek için kullanılır. Kompleks nesnenin yaratılması istemci
modülünden tamamen yalıtıldığı için nesnenin yaratılması ile ilgili işlemler
farklı versiyonlarda tamamen değiştirilebilir, bu istemci programın çalışmasını
hiç bir şekilde etkilemeyecektir. Burda dikkat edilmesi gereken nokta ise şudur
: bu desen kompleks nesneyi oluşturan yapıların gerçek nesneden tamamen bağımsız
bir yapıda olduğu durumlarda kullanıldığı zaman esneklik getirecektir. Dolayısıyla
her bir farklı parçanın kompleks nesnede kullanılması, kompleks nesnenin işlevini
değiştirmeyeceği gibi sadece görünümünü yada tipini değiştirecektir.
Builder deseninin Abstract Factory deseninden farkına gelince; "Abstract
Factory" deseninde soyut fabrika olarak bilinen yapının metotları fabrikaya
ait nesnelerin yaratılmasından bizzat sorumludur. Builder deseninde ise aynı
mekanizma biraz daha farklı işlemektedir. Builder deseninde istemci modülü,
nesnelerin ne şekilde oluşturulacağına soyut fabrika yapısına benzer bir yapı
olan Builder yapısının metotları ile
karar verir ve istemci oluşturulan bu nesneyi Builder sınıfından tekrar talep
eder.
Yukarıdaki soyut açıklamalardan sonra daha gerçekçi bir örnekle bu deseni açıklamamın
sizin ruh haliniz açısından faydalı olacağını düşünüyorum. Farklı donanım ürünlerinin
biraraya getirilerek bilgisayar sistemlerinin oluşturulduğu bir teknik servisi
göz önünde bulunduralım. Bir müşteri bu servise gelerek çeşitli özellikleri
içinde barındıran bir bilgisayar talep eder. İsteği alan servis temsilcisi bu
isteği teknik birimlere iletir ardından teknik eleman istenilen özelliklerde
bir bilgisayarın oluşması için gerekli donanımları raflarından alır ve birleştirir.
Sonuçta müşterinin isteği yerine gelir ve karşılıklı bir mutluluk havası içine
girilir. Tabi bizi ilgilendirin müşterinin ve satıcının mutluluğu değil elbette.
Bizi ilgilendiren nokta müşterinin bilgisayarı oluşturuan parçaların birleştirilmesinden
tamamen soyutlandığıdır. Dikkat ederseniz verilen özelliklerde bilgisayarın
oluşmasında müşterinin hiç bir etkisi olmamıştır. Eğer müşteri son anda vazgeçip
farklı özelliklerde bir bilgisayar istemiş olsaydı yine bir etkisi olmayacaktı.
Bu durumda eski bilgisayarın ilgili parçaları değiştirilip yeni isteğe uygun
parçalar takılacaktı. Burda da kompleks bir yapı olan bilgisayar sisteminin
kendisini oluşturan parçalardan (donanım) tamamen bağımsız bir yapıda olduğunu
görüyoruz. Herhangi bir diskin yada monitörün değişmesi bilgisayarı bilgisayar
yapmaktan çıkarmayacak sadece bilgisayarın tipini ve görüntüsünü değiştirecektir.
Bu durum bizim yukarıda açıkladığımız builder deseninin amacına tam olarak uymaktadır.
Zira birazdan bir teknik servisteki bu işleri otomatize eden temel desenimizi
C# ile nasıl gerçekleştirebileceğimizi göreceğiz.
Builder desenin de temel olarak 4 yapı bulunmaktadır. Bu yapılar sırasıyla şöyledir
:
- "Builder"
Arayüzü : Bu yapı içinde gerçek/somut(concrete) Builder sınıflarının uygulaması
gereken özellikleri ve metotları barındırır. "Builder" abstract
bir sınıf olabileceği gibi bir arayüz de olabilir. En çok tercih edilen yapı
arayüz olmasına rağmen uygulamanızın ihtiyacına göre abstract sınıflarıda
kullanabilirsiniz. Gerçek örneğimizde bu yapı bir bilgisayar sisteminin minimum
olarak uygulaması gereken özellikleri temsil eder. Örneğin kullanıcılara satılacak
her bilgisayar sistemi mutlaka HDD,RAM gibi yapıları içerisinde bulundurmalıdır.
Dolayısıyla birbirinden farklı bilgisayar sistemlerinin bu tür yapıları mutlak
olarak içerisinde barındırabilmesi için zorlayıcı bir etkene diğer bir değişle
abstract üye elemanlara yada arayüzlere ihtiyacımız vardır.
- "Concrete(Somut)
Builder" Yapısı : Gerçek bir bilgisayar sistemini temsil eden ana
yapımızdır. Farklı farklı donanımların bir araya getirilmesi ile çok sayıda
sistem oluşturulabilir. Oluşturulabilecek her sistem gerçek bir Builder yapısına
denk düşmektedir.
- Product(Ürün)
: Gerçek bir bilgisayar sistemini ve bu sistemde hangi özelliklerin bulunduğunu
somut olarak yapısında barındıran bir modeldir. Bu noktada bir önceki Concrete
Builder yapısının parçaları oluşturduğunu, bu parçaların birleşmesinden oluşan
kompleks nesneninde Product olduğunu belirtmekte yarar var.
- Director(Yönetici)
: Genellikle istemci ile yani örneğimizdeki müşteri ile Builder(parçaları
birleştirip ürün yapan birimler) yapıları arasında köprü görevinde bulunan
yapı olarak bilinir. Kısacası bilgisayar sisteminin oluşması için raflardan
donanımları alıp onları birleştiren teknik eleman Director görevindedir. Tabi
Director yapısının iş yaparken Builder arayüzünün kısıtlarına göre çalışması
gerektiğinide belirtmek gerekir.
UML
Modeli
Aşağıdaki şekil
"Builder" tasarım deseninin UML sınıf diagramını göstermektedir. Şemadaki
her bir şekil desendeki iligili yapıyı modellemektedir. Ayrıca desendeki sınıflar
arasındaki ilişkilerde detaylı bir şekilde gösterilmiştir.
Yukarıdaki UML diyagramını kısaca özetleyecek olursak : Builder arayüzünde bulunan
metotlar yardımıyla gerçek builder sınıflarında kompleks nesnenin parçaları
birleştirilerek istenilen nesne oluşturulur. Kompleks sistemi oluşturan parçalar
farklı sayılarda olabildği halde minumum gereklilikleri de sağlamak zorundadır.
Bu minumum gereksinimler Builder arayüzünde bildirilmiştir. Director sınıfındaki
bir metot, her sistem için standart olan Builder arayüzündeki metotları kullanarak
hangi sistemin oluşturulduğundan bağımsız olarak kompleks nesnenin oluşturulması
sağlanır. Yani Director hangi tür bir bir bilgisayar sisteminin oluşturulacağı
ile ilgilenmez. Director sınıfı sadece kendisine gönderilen parametre sayesinde
Builder arayüzünün metotlarından haberdardır. Son olarak istemci Director sınıfının
ilgili metotlarını kullanarak gerçek ürünün oluşmasını sağlar. Bunun için elbette
Director sınıfının ilgili metoduna hangi ürünün oluşturulacağını bildirmesi
gerekir.
Bu kısa açıklamadan sonra yukarıdaki diyagramı baz alarak modern bir programlama
dili olan C# ile bu deseni nasıl gerçekleştirebileceğimizi inceleyelim.
Builder Deseninin C# ile Gerçekleştirilmesi
! Aşağıdaki kodları kısaca inceleyip açıklamaları okumaya devam edin.
using
System;
namespace
BuilderPattern
{
public interface IBilgisayarToplayicisi
{
Bilgisayar Bilgisayar{get;}
void
CDROM_Olustur();
void
HDD_Olustur();
void
Monitor_Olustur();
void
RAM_Olustur();
}
public
class GoldPC : IBilgisayarToplayicisi
{
private
Bilgisayar mBilgisayar;
public
Bilgisayar Bilgisayar
{
get{return
mBilgisayar;}
}
public
GoldPC()
{
mBilgisayar
= new Bilgisayar("Gold-PC");
}
public
void CDROM_Olustur()
{
mBilgisayar["cdrom"]
= "52X GoldStar";
}
public
void HDD_Olustur()
{
mBilgisayar["hdd"]
= "60 GB Seagate";
}
public
void Monitor_Olustur()
{
mBilgisayar["monitor"]
= "17' Hyundai";
}
public
void RAM_Olustur()
{
mBilgisayar["ram"]
= "512 MB DDR Kingston";
}
}
public
class SilverPC : IBilgisayarToplayicisi
{
private
Bilgisayar mBilgisayar;
public
Bilgisayar Bilgisayar
{
get{return
mBilgisayar;}
}
public
SilverPC()
{
mBilgisayar
= new Bilgisayar("Silver-PC");
}
public
void CDROM_Olustur()
{
mBilgisayar["cdrom"]
= "48X Creative";
}
public
void HDD_Olustur()
{
mBilgisayar["hdd"]
= "30 GB Maxtor";
}
public
void Monitor_Olustur()
{
mBilgisayar["monitor"]
= "15' Vestel";
}
public
void RAM_Olustur()
{
mBilgisayar["ram"]
= "256 MB SD Kingston";
}
}
public
class Bilgisayar
{
private
string mBilgisayarTipi;
private
System.Collections.Hashtable mParcalar = new
System.Collections.Hashtable();
public
Bilgisayar(string BilgisayarTipi)
{
mBilgisayarTipi
= BilgisayarTipi;
}
public
object this[string key]
{
get
{
return
mParcalar[key];
}
set
{
mParcalar[key]
= value;
}
}
public
void BilgisayariGoster()
{
Console.WriteLine("Bilgisayar
Tipi : " + mBilgisayarTipi);
Console.WriteLine("--->
CD-ROM Model : " + mParcalar["cdrom"]);
Console.WriteLine("--->
Hard Disk Model : " + mParcalar["hdd"]);
Console.WriteLine("--->
Monitör Model : " + mParcalar["monitor"]);
Console.WriteLine("--->
RAM Model : " + mParcalar["ram"]);
}
}
public
class TeknikServis
{
public
void BilgisayarTopla(IBilgisayarToplayicisi bilgisayarToplayicisi)
{
bilgisayarToplayicisi.CDROM_Olustur();
bilgisayarToplayicisi.HDD_Olustur();
bilgisayarToplayicisi.Monitor_Olustur();
bilgisayarToplayicisi.RAM_Olustur();
}
}
}
|
Kaynak koddan da görüleceği üzere en temel yapımız IBilgisayarToplayicisi arayüzüdür.
Bu arayüzde bir Bilgisayar ürününü temsil etmek için bir özellik ve bilgisayarı
oluşturan parçaları oluşturmak için gereken metotlar bulunmaktadır. Bu metotların
bu arayüzden türeyen bütün sınıflar tarafından uygulanması gerekmektedir. Örneğimizde
bir GoldPC ve SilverPC bilgisayar modelleri için gereken bileşenleri oluşturmak
için 4 adet metot bulunmaktadır. Burada en önemli nokta her Bilgisayar tipinde
bir özelliğinde bulunması. Bu özellik istendiği zaman oluşturulan Bilgisayar
ürününü istemciye vermektedir. Zaten dikkat ederseniz her bir sisteme ilişikin
özellikler Bilgisayar sınıfındaki Hashtable nesnesinde saklanmıştır. Ayrıca
her Bilgisayar nesnesinin ayrıca bir tip bilgisi saklanmaktadır. Son olarak
TeknikServis isimli sınıfımızı ele alalım. Bu sınıf Builder desenindeki Director
yapısına denk düşmektedir. Bu sınıftaki BilgisayarTopla metodu kendisine gönderilen
bilgisayartoplayıcısı arayüzü referansına ait metotları kullanarak Bilgisayar
nesnesinin parçalarını kendisi oluşturmaktadır. Bu örnekte bilgisayarı oluşturan
her parça kafa karıştırmamak için ayrı bir sınıf olarak tasarlanmamıştır. Bunun
yerine string türünden değerlere sahip olan bir hashtable nesnesi kullanılmıştır.
Not : Yukarıdaki örnek gerçek otomasyonda birebir kullanılamayabilir. Örneğin
her bir bilgisayar modeli için ayrı ayrı sınıf tasarlamak hoş olmayabilir. Bu
sorunu daha dinamik bir şekilde çözmek gerekir. Buradaki örnek sadece Builder
desenin daha rahat bir şekilde kavrayabilmeniz için verilmiştir.
Son olarak yukarıdaki yapıları kullanan bir istemci programı yazıp desenimizi
test edelim.
using
System;
namespace
BuilderPattern
{
class Class1
{
static
void Main(string[] args)
{
TeknikServis
teknikservis = new TeknikServis();
IBilgisayarToplayicisi
BT1 = new GoldPC();
IBilgisayarToplayicisi
BT2 = new SilverPC();
tekniksevis.BilgisayarTopla(BT1);
teknikservis.BilgisayarTopla(BT2);
BT1.Bilgisayar.BilgisayariGoster();
Console.WriteLine("-------------");
BT2.Bilgisayar.BilgisayariGoster();
}
}
}
|
Programı çalıştırdığımızda aşağıdaki ekran görüntüsünü elde ederiz.
Bilgisayar
Tipi : Gold-PC
---> CD-ROM Model : 52X GoldStar
---> Hard Disk Model : 60 GB Seagate
---> Monitör Model : 17' Hyundai
---> RAM Model : 512 MB DDR Kingston
-------------
Bilgisayar Tipi : Silver-PC
---> CD-ROM Model : 48X Creative
---> Hard Disk Model : 30 GB Maxtor
---> Monitör Model : 15' Vestel
---> RAM Model : 256 MB SD Kingston |
Desenlerle ilgili bir sonraki yazımda Creational desenlerden olan "Prototype"
desenini ele alacağım. Herkese iyi çalışmalar.
Makale:
"Builder" Tasarım Deseninin C# ile Gerçekleştirilmesi C#, Visual C# ve .NET Sefer Algan
|
|
|
|
|
-
-
Eklenen Son 10
-
Bu Konuda Geçmiş 10
Son Eklenen 10 Makale Yükleniyor
Bu Konuda Yazılmış Geçmiş Makaleler Yükleniyor
|
|
|
|