GoF Tasarım Örüntüleri

Singleton
Konuyu buraya taşıdım.

Memento
Konuyu buraya taşıdım.

Decorator
Bir nesneyi sarmalayarak davranışını değiştirmeyi sağlar. Decorator sarmaladığı nesne ile aynı arayüzden kalıtır. Örnek:

TextEmail txtEmail = new TextEmail();
SecuredEmail securedEmail = new SecuredEmail(txtEmail);

State 
Tasarım örüntülerinde gösterilen state machine Moore Machine çünkü he bir state'in ismi var. Bir state yapmak istediği işi OnEnter () metodunda yapar. Sonucu ise Process () metodunda değerlendirir. Daha sonra sonuca göre OnExit metodunda bir sonraki state'i belirler.

IState
  void OnEnter
  void Process
  StateEnum OnExit

StateManager::Initialize (){
  stateList.Add (new InitialState (), INITIAL_STATE);
  stateList.Add (new AwaitingState (), AWAITING_STATE);
  ...
  currentState = stateList [ INITIAL_STATE ];
}

StateManager::Run () {
  currentState -> OnEnter (); // Do actual work
  currentState -> Process ();  //Evaluate result
  SetNextState (currentState -> OnExit ()); // Decide which state is next
}

StateManager::SetNextState (StateEnum value) {
  currentState = stateList [ value ];
}

Factory
Factory tasarım örüntüsü ile belli bir arayüzü gerçekleştiren farklı nesneler yaratılabilir.

Eager Factory
Eager benim kullandığım bir tabir. Nesnelerin en baştan bir kere yaratılarak bellekte tutulması ve tekrar tekrar kullanıması anlamına gelir. Örnek:

var fooDict = new Dictionary<int, IBigObject>()
{
    { 0, new Foo() }, // Creates an instance of Foo
    { 1, new Bar() }, // Creates an instance of Bar
    { 2, new Baz() }  // Creates an instance of Baz
}

var quux = fooDict[0]; // quux references Foo

Lazy Factory 
Nesnelerin hep yeniden yaratılması anlamına gelir. Örnek:

var fooDict = new Dictionary<int, Func<IBigObject>>()
{
    { 0, () => new Foo() }, // Returns a new instance of Foo when invoked
    { 1, () => new Bar() }, // Ditto Bar
    { 2, () => new Baz() }  // Ditto Baz
}

var quux = fooDict[0](); // equivalent to saying 'var quux = new Foo();'

C#'taki Lazy sınıfı ile de aynı şey yapılabilir.

var fooDict = new Dictionary<int, Lazy<IBigObject>>()
{
    { 0, new Lazy(() => new Foo()) }, // Returns a new instance of Foo when invoked
    { 1, new Lazy(() => new Bar()) }, // Ditto Bar
    { 2, new Lazy(() => new Baz()) }  // Ditto Baz
}

Builder
Builder ve Factory benzer işleri yapıyorlar. Builder daha çok Composite nesneleri yaratmak için uygun. Factory örüntüsünde daha çok polymorphisim öne çıkarken, Builder çok sayıda parametre gerektiren nesnelerin yaratılmasını kolaylaştırmayı hedefliyor. Builder örüntüsünde de amaç daha az sayıda metod vermek olmalı . Çok sayıdaki parametreyi belli composite yapılar şeklinde kullanmak hedeflenebilir.

Örneğin
MyBuilder().setWidth(float width).setHeight (float heigth) yerine
MyBuilder().setDimension (Dimension d)

şeklinde bir kullanım seçilmelidir.

Builder örüntüsü Fluent Interface kullanımına dayanır.

Bir builder şöyle kullanılabilir.

UserConfig uc = new UserConfig_Cfg("Kermit").age(50).favoriteColor("green").build();

Static Metodlar
Bazı sınıflar constructor yerine static metodlar vererek yaratılmalarını isterler. Bu yöntemi kabaca Builder örüntüsüne benzetiyorum. Ancak Builder'a göre daha basit bir kullanım şekli sunuyor. Direkt constructor kullanımına göre şu avantaja sahip. Static metod bir hata durumunda null dönebilir veya exception atabilir. Constructor kullanımında null döndürmek zaten imkansız. Constructor içinden nesneyi belirsiz bir durumda bırakmak pahasına exception atmak ise tehlikeli. Bu yüzden çok daha iyi bir kullanım şekli ortaya koyuyor.