1. Facade 패턴
2. Adapter 패턴
3. Bridge 패턴
4. Abstract Factory 패턴
5. Strategy 패턴
6. Decorate 패턴

최소 지식 원칙에서의 가이드라인

1. 객체 자체만의 호출

2. 메소드에서 매개 변수로 전달된 객체

3. 그 메소드에서 생성하거나 인스턴스를 만든 객체

4. 그 객체에 속하는 구성 요소

public static double GetTemplrature()

{

  // NOTE : 틀린 경우

  Thermoeter thermometer = station.GetThermometer();

  return thermometer.GetTemperature();

}

public static double GetTemperature()

{

  //NOTE : 맞는 경우 

  return station.GetTemperature();

 } 

구상되는 기본틀은 모두 Template를 이용하고, Template에서 이용되는 method들을 따로 객체화 시킨다.

namespace TemplatePattern

{

  public abstract class SYNCmailBasePannel

  {

    public abstract void LoadPannel();

    public abstract void MoveNextPannel();

    public abstract void MovePreviousPannel();

    public void ArrangeSubControls()

    {

      //NOTE : arrange sub controls

    }

    public void PaintPanel()

    {

      //NOTE : paint panel

    }

  }

  #region Using Strategy Pattern

  public interface ILoginService

  {

    bool Login(string logonName, string password);

  }

  public interface IChangeDisplayName

  {

    bool ChangeDisplayName(string displayName);

  }

  public class SYNCmailLoginService : ILoginService

  {

    #region ILoginService Members

    public bool Login(string logonName, string password)

    {

      throw new NotImplementedException();

    }

    #endregion

  }

  public class SYNCmailChangeDisplayNamer : IChangeDisplayName

  {

    #region IChangeDisplayName Members

    public bool ChangeDisplayName(string displayName)

    {

      throw new NotImplementedException();

    }

    #endregion

  }

  #endregion

  public class SYNCmailDisplayPannel : SYNCmailBasePannel

  {

    public IChangeDisplayName iChangeDisplayName;

    public override void LoadPannel()

    {

      throw new NotImplementedException();

    }

    public override void MoveNextPannel()

    {

      iChangeDisplayName.ChangeDisplayName("newDisplayName");

    }

    public override void MovePreviousPannel()

    {

      throw new NotImplementedException();

    }

  }

  public class SYNCmailLoginPannel : SYNCmailBasePannel

  {

    public ILoginService iLoginService;

    public override void LoadPannel()

    {

      //TODO : GET Login information

    }

    public override void MoveNextPannel()

    {

      //TODO :

      // 1. Connection SYNCmail API

      // 2. Check Login Informations

      if ( iLoginService.Login("logonName", "password") )

      {

        //NOTE : Move Next Pannel

      }

    }

    public override void MovePreviousPannel()

    {

      //TODO :

      // Move previous Pannel

    }

  }

}

Collection 구현 방법을 노출하지 않으면서 Collection 안에 들어있는 모든 항목에 접근할 수 있게 해주는 방법의 제공

항목들에 대한 반복 작업을 일괄적으로 할 수 있도록 해준다.

.NET Framework :

System.Collections.IEnumerable  : GetEnumerator()를 통해서 IEnumerator를 얻어낸다.

System.Collections.IEnumerator : 객체에 대한 접근 항목을 보여주는 interface. Current, MoveNext, Reset을 통해서 모든 객체에 대한 일괄적인 접근제어를 한다. 

  public class DinnerMenus2 : IEnumerable

  {

    #region IEnumerable Members

    public IEnumerator GetEnumerator()

    {

      throw new NotImplementedException();

    }

    #endregion

  }

  public class DinnerMenus : IEnumerator

  {

    private int position;

    public DinnerMenus()

    {

      position = 0;

    }

    #region IEnumerator Members

    public object Current

    {

      get { throw new NotImplementedException(); }

    }

    public bool MoveNext()

    {

      throw new NotImplementedException();

    }

    public void Reset()

    {

      throw new NotImplementedException();

    }

    #endregion

  }

공통적으로 일하는 것과 각기 다른 객체들간의 차이점을 나누는 것부터 시작한다. 

Class의 Method에서 알고리즘의 골격을 만들어주고, 몇몇 단계를 sub-class에서 이용하는 방식.

옛날부터 내가 자주 사용하던 pattern.  (잘 보면 그전까지 하던 일들에 대해서 용어를 붙이는 느낌이 든다.;;)

namespace TemplatePattern

{

  public abstract class CaffeinBeverage

  {

    public void PrefareRecipe()

    {

      BoilWater();

      Brew();

      PourInCup();

      AddCodiments();

    }

    protected abstract void Brew();

    protected abstract void AddCodiments();

    protected void BoilWater()

    {

      Console.WriteLine("Boil Water");

    }

    protected void PourInCup()

    {

      Console.WriteLine("Pour in Cup");

    }

  }

  public class CoffeeBeverage : CaffeinBeverage

  {

    protected override void Brew()

    {

      Console.WriteLine("Brew Coffee Grinds");

    }

    protected override void AddCodiments()

    {

      Console.WriteLine("Add Sugar");

    }

  }

  public class TeaBeverage : CaffeinBeverage

  {

    protected override void Brew()

    {

      Console.WriteLine("Brew Tea Grinds");

    }

    protected override void AddCodiments()

    {

      Console.WriteLine("Add Lemon");

    }

  }

} 

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

namespace StrategyPattern
{
  /// <summary>
  /// Strategy pattern을 이용. : SYNCmail Mobile도 같은 방법으로 구현해보는 것이 어떨까 고민되고 있음.
  /// </summary>
  public abstract class OperationPanel
  {
    public IOperation Operation { get; set; }
    public void DoOperation()
    {
      Operation.DoMainOperation();
    }
  }

  public interface IOperation
  {
    void DoMainOperation();
    void DoSubOperation();
    void LoadOperation();
  }

  public class CheckPasswordOperation : IOperation
  {
    public string LogonName { get; set; }
    public string Password { get; set; }

    public void DoMainOperation()
    {
      Console.WriteLine("Check Password");
    }

    public void DoSubOperation()
    {
      Console.WriteLine("Cancel operation");
    }

    public void LoadOperation()
    {
      Console.WriteLine("Display");
    }
  }
  //abstract class의 이용을 하지 않고, Interface의 구현 및 조합을 통해서, 각각의 class의 구현을 행한다.
  //abstract method를 사용하지 않고, abstract method에서 사용되는 동작의 정의를 Interface를 통한다. 그 interface의 구현을 통해서 만들어주는 패턴

}

개인적으로 가장 많이 사용한 패턴.

DB에 대한 connection 문제 해결이라던지, 하나의 리소스를 사용하는 방법으로 주로 사용한다.

특히 윈도우에서는 Registery의 참조부분을 행할때 주로 사용하게 된다.

.NET에서 keyword인 volatile를 사용한 것을 주목할것.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace SingletonPattern

{

  public class SingletonData

  {

    private static volatile SingletonData singletonInstance;

    public static SingletonData GetInstance()

    {

      if ( singletonInstance == null )

      {

        singletonInstance = new SingletonData();

      }

      return singletonInstance;

    }

    private SingletonData()

    {

    }

  }

}

using System;
using System.Collections.Generic;

namespace ObserverPattern
{
  public interface IObserver
  {
    void Update(float temp, float humidity, float pressure);
  }

  public interface ISubject
  {
    void RegisterObserver(IObserver o);
    void RemoveObserver(IObserver o);
    void NotifyObservers();
  }

  public interface IDisplayElement
  {
    void Display();
  }


  public class WeatherSubject : ISubject
  {
    readonly List<IObserver> observers;
    float temperature;
    float pressure;
    float humidity;

    public void GetterMeasurements(float inTemperature, float inHumidity, float inPressure)
    {
      temperature = inTemperature;
      humidity = inHumidity;
      pressure = inPressure;
      NotifyObservers();
    }

    public WeatherSubject()
    {
      observers = new List<IObserver>();
    }
    #region ISubject Members

    public void RegisterObserver(IObserver o)
    {
      observers.Add(o);
    }

    public void RemoveObserver(IObserver o)
    {
      observers.Remove(o);
    }

    public void NotifyObservers()
    {
      foreach ( IObserver observer in observers )
      {
        observer.Update(temperature, humidity, pressure);
      }
    }

    #endregion
  }
}