C#

デザインパターンを学ぶ～その１9：Singletonパターン(2)～

まさる — Thu, 24 Jul 2008 23:24:00 GMT

さて、前回は一番単純なSingletonの実装を紹介しました。そして、そのなかで、

以下のようにマルチスレッドで動かす場合、1つだけであるはずのインスタンスが、複数生成されてしまうことがあります。

～中略～

ごらんのように、インスタンスが２つ生成された結果、ログ出力パスが変わってしまいます。
この問題を解消する方法はないのでしょうか？
実はあります。

と書きました。

まずは、なぜインスタンスが２つ作成されるかを考えてみましょう。そのために、前回のコードの、インスタンス取得部分のコードを再掲します。

C#

  /// <summary>
  /// プロパティ インスタンス
  /// </summary>
  /// <remarks>自身の唯一のインスタンスを返す</remarks>
  public static SingletonLogger Instance
  {
    get
    {
      if ( _uniqueLogger == null )
      {
        _uniqueLogger = new SingletonLogger();
      }
      return _uniqueLogger;
    }
  }

VB

  ''' <summary>
  ''' プロパティ インスタンス
  ''' </summary>
  ''' <value></value>
  ''' <returns></returns>
  ''' <remarks>自身の唯一のインスタンスを返す</remarks>
  Public Shared ReadOnly Property Instance() As SingletonLogger
    Get
      If _uniqueLogger Is Nothing Then
        _uniqueLogger = New SingletonLogger
      End If
      Return _uniqueLogger
    End Get
  End Property

このコードで何が問題かというと、C#、VBともに9行目でインスタンスがないことを確認した後、10行目で新しいインスタンスを作成するのですが、コンストラクタが重い場合、インスタンスが生成される前に他のスレッドによって9行目が再び実行され、このときはやはりインスタンスがないので、そのまま後に実行されたスレッドでも10行目が実行されてしまうのです。

これを解決する方法には大きく２つあるのですが、今回は有名な「二重チェック」の方法を紹介します。さっそくコードを見てみましょう。

C#

/// <summary>
/// ログ出力クラス
/// </summary>
public class SingletonLogger
{
  /// <summary>
  /// ログ出力パス
  /// </summary>
  private string _logPath;

  /// <summary>
  /// プロパティ ログ出力パス
  /// </summary>
  public string LogPath
  {
    get
    {
      return _logPath;
    }
  }

  /// <summary>
  /// コンストラクタ
  /// </summary>
  /// <remarks>new でインスタンス化できないよう、privateでコンストラクタを定義</remarks>
  private SingletonLogger()
  {
    // 重い初期化処理
    for ( var i = 0; i < 100000000; i++ )
    {
    }

    _logPath = DateTime.Now.ToString("yyyyMMddhhmmssfff") + ".log";
  }

  /// <summary>
  /// 自身の唯一のインスタンス
  /// </summary>
  private volatile static SingletonLogger _uniqueLogger;

  /// <summary>
  /// ロック用のオブジェクト
  /// </summary>
  private static object lockObj = new object(); 

  /// <summary>
  /// プロパティ インスタンス
  /// </summary>
  /// <remarks>自身の唯一のインスタンスを返す</remarks>
  public static SingletonLogger Instance
  {
    get
    {
      if ( _uniqueLogger == null )
      {
        lock ( lockObj )
        {
          if ( _uniqueLogger == null )
          {
            _uniqueLogger = new SingletonLogger();
          }
        }
      }
      return _uniqueLogger;
    }
  }

  /// <summary>
  /// ログ出力
  /// </summary>
  /// <param name="message"></param>
  public void WriteLog(string message)
  {
    // ログ出力処理
    // ・・・
  }
}

VB

''' <summary>
''' ログ出力クラス
''' </summary>
''' <remarks></remarks>
Public Class SingletonLogger


  ''' <summary>
  ''' ログ出力パス
  ''' </summary>
  ''' <remarks></remarks>
  Private _logPath As String

  ''' <summary>
  ''' プロパティ ログ出力パス
  ''' </summary>
  ''' <value></value>
  ''' <returns></returns>
  ''' <remarks></remarks>
  Public ReadOnly Property LogPath() As String
    Get
      Return _logPath
    End Get
  End Property

  ''' <summary>
  ''' コンストラクタ
  ''' </summary>
  ''' <remarks>new でインスタンス化できないよう、privateでコンストラクタを定義</remarks>
  Private Sub New()
    ' 重い初期化処理
    For i As Integer = 0 To 100000000
    Next i

    _logPath = DateTime.Now.ToString("yyyyMMddhhmmssfff") & ".log"
  End Sub

  ''' <summary>
  ''' 自身の唯一のインスタンス
  ''' </summary>
  ''' <remarks></remarks>
  Private Shared _uniqueLogger As SingletonLogger

  Private Shared _lockObj As New Object()

  ''' <summary>
  ''' プロパティ インスタンス
  ''' </summary>
  ''' <value></value>
  ''' <returns></returns>
  ''' <remarks>自身の唯一のインスタンスを返す</remarks>
  Public Shared ReadOnly Property Instance() As SingletonLogger
    Get
      If _uniqueLogger Is Nothing Then
        SyncLock (_lockObj)
          If _uniqueLogger Is Nothing Then
            _uniqueLogger = New SingletonLogger
          End If
        End SyncLock
      End If
      Return _uniqueLogger
    End Get
  End Property

End Class

実行結果は次の通り。

実行結果

20080724111338001.log
20080724111338001.log

この方法のポイントは以下の通り。

ロック用オブジェクトを用意する。（C#の44行目、VBの44行目）
Instanceプロパティにアクセスされた際、インスタンスの有無を確認後、C#はlockステートメント、VBはSyncLockステートメントを使い、1.で用意したオブジェクトをロックする。（C#の56行目、VBの55行目）
これにより、後に実行されたスレッドは先に実行されたスレッドにてロックが解除されるまで待つこととなる。
ロックした後、もう一度インスタンスの有無を確認した後、インスタンスがなければ生成する。（C#の58～60行目、VBの56行目から57行目）

なお、C#のコードの39行目にて、_uniqueLoggerフィールドを宣言する際、「volatile」というキーワードをつけています。これは、このキーワードを付けられたフィールドは、キャッシュメモリ内に領域を確保しなくなるため、RAMとキャッシュで値が食い違うという現象が発生しなくなります。

が、CLRのメモリ管理ではこの問題を解決しているため、「volatile」は無くても問題ありません。（Monoなど他のプラットフォームでは必要です、たぶん。）

＃この辺りのことは、「プログラミング .NET Framework 第2版」のp.693、「24.3.8 ロックのための有名な二重チェックテクニック」に詳しく書かれています。

ところで、上記書籍の該当箇所にこんなことも書いてあります。

このテクニックが有名なのは、特に面白かったり便利だったりするからではありません。これが有名な理由は、これについて書かれた文献が多いからです。このテクニックはJavaで非常によく使われています。そして、Javaではこれがどこででも動作するわけではないことが後に明らかになりました。この問題を説明している有名な文書が次のWebページにあります。

http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

この問題って今はどうなってるんでしょうか？教えて！Javaのエロい人！

＃次回はもうひとつの方法について紹介します。

お許し下さい。決して魂を売ったわけじゃないんです・・・

まさる — Fri, 11 Jul 2008 15:06:00 GMT

しばらくVBをやっててC#に戻ったら、セミコロンの打ち忘れが多発しました・・・

デザインパターンを学ぶ～その１8：Singletonパターン(1)～

まさる — Sun, 08 Jun 2008 01:24:00 GMT

Singleton　（シングルトン）
　一人っ子、単一のこと・もの

Singletonパターンは、インスタンスがひとつしかない唯一のオブジェクトを生成し、そのインスタンスを取得する方法を公開します。

例えば、アプリケーション実行時のログを出力するような場合を考えます。ログのファイル名をシステム日付＋時刻でつけるとしましょう。ログ出力を初回に行う際に、ログファイル名を決定し、以後はそのログファイルにログを出力します。

この場合、ログファイル名はアプリケーション実行時に1つだけでなくてはなりません。このような場合、Singletonが使えます。

以下に、コード例を示します。

C#

/// <summary>
/// ログ出力クラス
/// </summary>
public class SingletonLogger
{
  /// <summary>
  /// ログ出力パス
  /// </summary>
  private string _logPath;

  /// <summary>
  /// プロパティ ログ出力パス
  /// </summary>
  public string LogPath
  {
    get
    {
      return _logPath;
    }
  }

  /// <summary>
  /// コンストラクタ
  /// </summary>
  /// <remarks>new でインスタンス化できないよう、privateでコンストラクタを定義</remarks>
  private SingletonLogger()
  {
    _logPath = DateTime.Now.ToString("yyyyMMddhhmmssfff") + ".log";
  }

  /// <summary>
  /// 自身の唯一のインスタンス
  /// </summary>
  private static SingletonLogger _uniqueLogger;

  /// <summary>
  /// プロパティ インスタンス
  /// </summary>
  /// <remarks>自身の唯一のインスタンスを返す</remarks>
  public static SingletonLogger Instance
  {
    get
    {
      if ( _uniqueLogger == null )
      {
        _uniqueLogger = new SingletonLogger();
      }
      return _uniqueLogger;
    }
  }

  /// <summary>
  /// ログ出力
  /// </summary>
  /// <param name="message"></param>
  public void WriteLog(string message)
  {
    // ログ出力処理
    // ・・・
  }
}

VB

''' <summary>
''' ログ出力クラス
''' </summary>
''' <remarks></remarks>
Public Class SingletonLogger

  ''' <summary>
  ''' ログ出力パス
  ''' </summary>
  ''' <remarks></remarks>
  Private _logPath As String

  ''' <summary>
  ''' プロパティ ログ出力パス
  ''' </summary>
  ''' <value></value>
  ''' <returns></returns>
  ''' <remarks></remarks>
  Public ReadOnly Property LogPath() As String
    Get
      Return _logPath
    End Get
  End Property

  ''' <summary>
  ''' コンストラクタ
  ''' </summary>
  ''' <remarks>new でインスタンス化できないよう、privateでコンストラクタを定義</remarks>
  Private Sub New()
    _logPath = DateTime.Now.ToString("yyyyMMddhhmmssfff") & ".log"
  End Sub

  ''' <summary>
  ''' 自身の唯一のインスタンス
  ''' </summary>
  ''' <remarks></remarks>
  Private Shared _uniqueLogger As SingletonLogger

  ''' <summary>
  ''' プロパティ インスタンス
  ''' </summary>
  ''' <value></value>
  ''' <returns></returns>
  ''' <remarks>自身の唯一のインスタンスを返す</remarks>
  Public Shared ReadOnly Property Instance() As SingletonLogger
    Get
      If _uniqueLogger Is Nothing Then
        _uniqueLogger = New SingletonLogger
      End If
      Return _uniqueLogger
    End Get
  End Property

  ''' <summary>
  ''' ログ出力
  ''' </summary>
  ''' <param name="message"></param>
  Public Sub WriteLog(ByVal message As String)
    ' ログ出力処理
    ' ・・・
  End Sub

End Class

このコードのポイントは以下の3点です。

コンストラクタをprivateとして、外からはインスタンス化できないようにする。
privateな静的フィールドとして、自身の型のフィールドを用意し、クライアントにはそれを提供するようにする。
Instanceプロパティ内で、上記静的フィールドがnullの場合のみ、新たにインスタンス化するようにし、唯一のオブジェクトを保障する。

以上のコードを使って見ましょう。

C#

public class Program
{
  static void Main(string[] args)
  {
    {
      var logger = SingletonLogger.Instance;
      Console.WriteLine(logger.LogPath);
    }

    System.Threading.Thread.Sleep(1000);

    {
      var logger = SingletonLogger.Instance;
      Console.WriteLine(logger.LogPath);
    }

    Console.ReadKey();
  }
}

VB

Public Class Program

  Public Shared Sub Main()

    With Nothing
      Dim logger = SingletonLogger.Instance
      Console.WriteLine(logger.LogPath)
    End With

    System.Threading.Thread.Sleep(1000)

    With Nothing
      Dim logger = SingletonLogger.Instance
      Console.WriteLine(logger.LogPath)
    End With

    Console.ReadKey()

  End Sub

End Class

実行結果

20080608125533068.log
20080608125533068.log

実行結果を見るとわかるように、1つのインスタンスが使いまわされていることがわかります。

さて、以上のコードは、通常の使用方法では問題がないのですが、以下のようにマルチスレッドで動かす場合、1つだけであるはずのインスタンスが、複数生成されてしまうことがあります。

C#

/// ログ出力クラス
/// </summary>
public class SingletonLogger
{
  ・・・

  /// <summary>
  /// コンストラクタ
  /// </summary>
  /// <remarks>new でインスタンス化できないよう、privateでコンストラクタを定義</remarks>
  private SingletonLogger()
  {
    // 重い初期化処理
    for ( var i = 0; i < 100000000; i++ )
    {
    }

    _logPath = DateTime.Now.ToString("yyyyMMddhhmmssfff") + ".log";
  }

  ・・・
}

public class Program
{
  static void Main(string[] args)
  {
    SingletonLogger logger1 = null;
    var thread1 = new Thread(
      () =>
      {
        logger1 = SingletonLogger.Instance;
      }
    );
    SingletonLogger logger2 = null;
    var thread2 = new Thread(
      () =>
      {
        logger2 = SingletonLogger.Instance;
      }
    );

    thread1.Start();
    thread2.Start();

    while ( logger1 == null || logger2 == null)
    {
      Thread.Sleep(10);
    }

    Console.WriteLine(logger1.LogPath);
    Console.WriteLine(logger2.LogPath);

    Console.ReadKey();
  }
}

VB

''' <summary>
''' ログ出力クラス
''' </summary>
''' <remarks></remarks>
Public Class SingletonLogger

  ・・・

  ''' <summary>
  ''' コンストラクタ
  ''' </summary>
  ''' <remarks>new でインスタンス化できないよう、privateでコンストラクタを定義</remarks>
  Private Sub New()
    ' 重い初期化処理
    For i As Integer = 0 To 100000000
    Next i

    _logPath = DateTime.Now.ToString("yyyyMMddhhmmssfff") & ".log"
  End Sub

  ・・・

End Class

Public Class Program

  Public Shared Sub Main()

    Dim loggerHelper1 As New LoggerHelper()
    Dim thread1 = New Thread(AddressOf loggerHelper1.SetLogger)

    Dim loggerHelper2 As New LoggerHelper()
    Dim thread2 = New Thread(AddressOf loggerHelper2.SetLogger)

    thread1.Start()
    thread2.Start()

    While (loggerHelper1.Logger Is Nothing OrElse loggerHelper2.Logger Is Nothing)
      Thread.Sleep(10)
    End While

    Console.WriteLine(loggerHelper1.Logger.LogPath)
    Console.WriteLine(loggerHelper2.Logger.LogPath)

    Console.ReadKey()

  End Sub

  Public Class LoggerHelper

    Public Logger As SingletonLogger

    Public Sub SetLogger()
      Me.Logger = SingletonLogger.Instance
    End Sub
  End Class

End Class

実行結果

20080608011949432.log
20080608011949613.log

ごらんのように、インスタンスが２つ生成された結果、ログ出力パスが変わってしまいます。

この問題を解消する方法はないのでしょうか？

実はあります。このあたり、次回のエントリで取り上げようと思います。

＃今回から、.NET Framework 3.5 のコードにしています。

デザインパターンを学ぶ～その１６：Factoryパターン(3)～

まさる — Wed, 27 Feb 2008 23:58:00 GMT

記念すべき100エントリ目となりました。いい加減にシリーズ再開せねばということで、前回から間が空きましたが、今回はAbstract Factoryパターンを取り上げます。

Abstract Factoryパターンは、具象クラスに依存することなく、一連の関連するオブジェクトを生成するためのインタフェイスを提供します。

具体的には、例えばGUIインタフェイスでスキンを指定したら、それに紐付くボタン、枠、スクロールバーなどを生成する、といった用途で使われているようですね。

では、コード例です。今回はお弁当の種類に応じたごはんとおかずを作るFactoryをコードにしてみます。

生成される製品の抽象クラスを定義します。

C# Code

public abstract class Abstractごはん
{
  public abstract string 名前
  {
    get;
  }
}

public abstract class Abstractおかず
{
  public abstract string 名前
  {
    get;
  }
}

VB Code

Public MustInherit Class Abstractごはん

  Public MustOverride ReadOnly Property 名前() As String

End Class

Public MustInherit Class Abstractおかず

  Public MustOverride ReadOnly Property 名前() As String

End Class

1.で作成した抽象製品クラスを継承し、具象製品クラスを定義します。

C# Code

public class ごはん : Abstractごはん
{
  public override string 名前
  {
    get { return "ごはん"; }
  }
}

public class ふりかけごはん : Abstractごはん
{
  public override string 名前
  {
    get { return "ふりかけごはん"; }
  }
}

public class ごま塩ごはん : Abstractごはん
{
  public override string 名前
  {
    get { return "ごま塩ごはん"; }
  }
}

public class 梅干し : Abstractおかず
{
  public override string 名前
  {
    get { return "梅干し"; }
  }
}

public class から揚げ : Abstractおかず
{
  public override string 名前
  {
    get { return "から揚げ"; }
  }
}

public class 玉子焼き : Abstractおかず
{
  public override string 名前
  {
    get { return "玉子焼き"; }
  }
}

public class 焼き鮭 : Abstractおかず
{
  public override string 名前
  {
    get { return "焼き鮭"; }
  }
}

public class 煮物 : Abstractおかず
{
  public override string 名前
  {
    get { return "煮物"; }
  }
}

public class ウインナ : Abstractおかず
{
  public override string 名前
  {
    get { return "ウインナ"; }
  }
}

VB Code

Public Class ごはん
  Inherits Abstractごはん

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "ごはん"
    End Get
  End Property

End Class

Public Class ふりかけごはん
  Inherits Abstractごはん

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "ふりかけごはん"
    End Get
  End Property

End Class

Public Class ごま塩ごはん
  Inherits Abstractごはん

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "ごま塩ごはん"
    End Get
  End Property

End Class

Public Class 梅干し
  Inherits Abstractおかず

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "梅干し"
    End Get
  End Property

End Class

Public Class から揚げ
  Inherits Abstractおかず

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "から揚げ"
    End Get
  End Property

End Class

Public Class 玉子焼き
  Inherits Abstractおかず

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "玉子焼き"
    End Get
  End Property

End Class

Public Class 焼き鮭
  Inherits Abstractおかず

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "焼き鮭"
    End Get
  End Property

End Class

Public Class 煮物
  Inherits Abstractおかず

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "煮物"
    End Get
  End Property

End Class

Public Class ウインナ
  Inherits Abstractおかず

  Public Overrides ReadOnly Property 名前() As String
    Get
      Return "煮物"
    End Get
  End Property

End Class

1.で作成した抽象クラスそれぞれを生成するメソッド（Factory Method）を持つ、抽象Factoryクラスを定義します。

C# Code

public abstract class Abstractお弁当Factory
{
  public abstract Abstractごはん Createごはん();
  public abstract Abstractおかず[] Createおかず();
}

VB Code

Public MustInherit Class Abstractお弁当Factory

  Public MustOverride Function Createご飯() As Abstractごはん
  Public MustOverride Function Createおかず() As Abstractおかず()

End Class

3.で作成した抽象クラスを継承し、具象Factoryクラスを定義します。

C# Code

public class 日の丸弁当Factory : Abstractお弁当Factory
{
  public override Abstractごはん Createごはん()
  {
    return new ごはん();
  }

  public override Abstractおかず[] Createおかず()
  {
    return new Abstractおかず[] { new 梅干し() };
  }
}

public class 和風弁当Factory : Abstractお弁当Factory
{
  public override Abstractごはん Createごはん()
  {
    return new ごま塩ごはん();
  }

  public override Abstractおかず[] Createおかず()
  {
    return new Abstractおかず[] {
      new 梅干し()
      , new 焼き鮭()
      , new 煮物()
    };
  }
}

public class こども弁当Factory : Abstractお弁当Factory
{
  public override Abstractごはん Createごはん()
  {
    return new ふりかけごはん();
  }

  public override Abstractおかず[] Createおかず()
  {
    return new Abstractおかず[] {
      new ウインナ()
      , new 玉子焼き()
      , new から揚げ()
    };
  }
}

VB Code

Public Class 日の丸弁当Factory
  Inherits Abstractお弁当Factory

  Public Overrides Function Createご飯() As Abstractごはん

    Return New ごはん()

  End Function

  Public Overrides Function Createおかず() As Abstractおかず()

    Return New Abstractおかず() {New 梅干し()}

  End Function

End Class

Public Class 和風弁当Factory
  Inherits Abstractお弁当Factory

  Public Overrides Function Createご飯() As Abstractごはん

    Return New ごま塩ごはん()

  End Function

  Public Overrides Function Createおかず() As Abstractおかず()

    Return New Abstractおかず() { _
     New 梅干し() _
     , New 焼き鮭() _
     , New 煮物() _
     }

  End Function

End Class

Public Class こども弁当Factory
  Inherits Abstractお弁当Factory

  Public Overrides Function Createご飯() As Abstractごはん

    Return New ふりかけごはん()

  End Function

  Public Overrides Function Createおかず() As Abstractおかず()

    Return New Abstractおかず() { _
     New ウインナ() _
     , New 玉子焼き() _
     , New から揚げ() _
     }

  End Function

End Class

1～4.で作成したクラス群を使用する、Clientクラスを定義します。

C# Code

public class お弁当Client
{
  private Abstractごはん ごはん;
  private Abstractおかず[] おかず;
  private Abstractお弁当Factory お弁当Factory;

  public お弁当Client(string 種類)
  {
    if ( 種類 == "日の丸" )
    {
      this.お弁当Factory = new 日の丸弁当Factory();
    }
    else if ( 種類 == "和風" )
    {
      this.お弁当Factory = new 和風弁当Factory();
    }
    else if ( 種類 == "こども" )
    {
      this.お弁当Factory = new こども弁当Factory();
    }
  }

  public void お弁当作成()
  {
    this.ごはん = お弁当Factory.Createごはん();
    this.おかず = お弁当Factory.Createおかず();
  }

  public override string ToString()
  {
    List<string> おかず名List = new List<string>();
    foreach ( Abstractおかず おかず単品 in おかず )
    {
      おかず名List.Add(おかず単品.名前);
    }
    return String.Format(
        "{0}におかずとして、{1}が付いています。"
      , ごはん.名前
      , String.Join("、", おかず名List.ToArray())
      );
  }
}

VB Code

Public Class お弁当Client

  Private ごはん As Abstractごはん
  Private おかず As Abstractおかず()
  Private お弁当Factory As Abstractお弁当Factory

  Sub New(ByVal 種類 As String)

    If 種類 = "日の丸" Then

      Me.お弁当Factory = New 日の丸弁当Factory()

    ElseIf 種類 = "和風" Then

      Me.お弁当Factory = New 和風弁当Factory()

    ElseIf 種類 = "こども" Then

      Me.お弁当Factory = New こども弁当Factory()

    End If

  End Sub

  Public Sub お弁当作成()

    Me.ごはん = Me.お弁当Factory.Createご飯()
    Me.おかず = Me.お弁当Factory.Createおかず()

  End Sub

  Public Overrides Function ToString() As String

    Dim おかず名List As New List(Of String)()

    For Each おかず単品 As Abstractおかず In Me.おかず

      おかず名List.Add(おかず単品.名前)

    Next

    Return String.Format( _
     "{0}におかずとして、{1}が付いています。" _
     , ごはん.名前 _
     , String.Join("、", おかず名List.ToArray()) _
     )

  End Function

End Class

上記コードを実行してみます。

実行コード

C# Code

public class Program
{
  static void Main(string[] args)
  {
    お弁当Client client;

    Console.WriteLine("日の丸弁当：");
    client = new お弁当Client("日の丸");
    client.お弁当作成();
    Console.WriteLine(client.ToString());

    Console.WriteLine("和風弁当：");
    client = new お弁当Client("和風");
    client.お弁当作成();
    Console.WriteLine(client.ToString());

    Console.WriteLine("こども弁当：");
    client = new お弁当Client("こども");
    client.お弁当作成();
    Console.WriteLine(client.ToString());

    Console.ReadKey();
  }
}

VB Code

Public Class Program

  Public Shared Sub Main(ByVal args As String())

    Dim client As お弁当Client

    Console.WriteLine("日の丸弁当：")
    client = New お弁当Client("日の丸")
    client.お弁当作成()
    Console.WriteLine(client.ToString())

    Console.WriteLine("和風弁当：")
    client = New お弁当Client("和風")
    client.お弁当作成()
    Console.WriteLine(client.ToString())

    Console.WriteLine("こども弁当：")
    client = New お弁当Client("こども")
    client.お弁当作成()
    Console.WriteLine(client.ToString())

    Console.ReadKey()

  End Sub

End Class

実行結果

日の丸弁当：
ごはんにおかずとして、梅干しが付いています。
和風弁当：
ごま塩ごはんにおかずとして、梅干し、焼き鮭、煮物が付いています。
こども弁当：
ふりかけごはんにおかずとして、ウインナ、玉子焼き、から揚げが付いています。

さて、上記のコードをよく見てみると、気付くことがあります。

まずは、3.で定義した抽象Factoryですが、そのメンバである製品を生成するメソッドは、前回紹介したFactory Methodパターンとなっています。

また、Clientクラスの中で、抽象Factoryクラスの変数に、具象Factoryのインスタンスを切り替えて設定し、Factoryメソッドを実行している箇所は、Strategyパターンになっていますね。（この辺の話は以前凪瀬さんがまとめていらっしゃいますのでご一読をオススメします。）

このように、あるパターンの中に他のパターンが紛れている、ということもGoFパターンにはちょくちょくあるようですので、その意味、役割を考えなければいけませんね。わたしももう少し勉強します(^^;

さて、次回はFactoryパターンについてのまとめをお送りする予定です。

C#って文字列の比較を「<」、「>」で出来なかったのね・・・

まさる — Wed, 06 Feb 2008 10:05:00 GMT

いまさら・・・orz

＃VBでは出来るから、C#でも出来るかと思ってたよ・・・

var欲しい

まさる — Thu, 31 Jan 2008 17:55:00 GMT

C# 2.0で型付データセット使ってごにょごにょしてると、クラス名が長くなっていちいち書くのがめんどい・・・

re: re: オブジェクト指向におけるFizzBuzz問題

まさる — Fri, 09 Nov 2007 12:30:00 GMT

＃問題→オブジェクト指向におけるFizzBuzz問題

＃前回→re: オブジェクト指向におけるFizzBuzz問題

ひろえむさんのコメントにより、さらに修正。

C#

public abstract class Animal
{
    private int soundsCount = 1;

    public void SetCount(int count)
    {
        this.soundsCount = count;
    }

    protected abstract string SoundsString
    {
        get;
    }

    public void Sound()
    {
        StringBuilder sounds = new StringBuilder();
        for ( int i = 0; i < this.soundsCount; i++ )
        {
            sounds.Append(this.SoundsString);
        }
        Console.WriteLine(sounds.ToString());
    }
}

public class Cat : Animal
{
    protected override string SoundsString
    {
        get
        {
            return "にゃー";
        }
    }
}

public class Dog : Animal
{
    protected override string SoundsString
    {
        get
        {
            return "わん";
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Animal animal;
        animal = new Dog();
        animal.Sound();
        animal.SetCount(3);
        animal.Sound();
        animal = new Cat();
        animal.Sound();

        Console.Read();
    }
}

せっかくなのでVB版も。

VB

Imports System.Text

Public MustInherit Class Animal

    Private soundsCount As Integer = 1

    Protected MustOverride ReadOnly Property SoundsString() As String

    Public Sub SetCount(ByVal count As Integer)
        Me.soundsCount = count
    End Sub

    Public Sub Sound()
        Dim sounds As New StringBuilder()
        For i As Integer = 1 To Me.soundsCount
            sounds.Append(Me.SoundsString())
        Next i
        Console.WriteLine(sounds.ToString())
    End Sub

End Class

Public Class Cat
    Inherits Animal

    Protected Overrides ReadOnly Property SoundsString() As String
        Get
            Return "にゃー"
        End Get
    End Property

End Class

Public Class Dog
    Inherits Animal

    Protected Overrides ReadOnly Property SoundsString() As String
        Get
            Return "わん"
        End Get
    End Property

End Class

Public Class Program

    Public Shared Sub Main(ByVal args As String())

        Dim animal As Animal
        animal = New Dog()
        animal.Sound()
        animal.SetCount(3)
        animal.Sound()
        animal = New Cat()
        animal.Sound()

        Console.Read()

    End Sub

End Class

re: オブジェクト指向におけるFizzBuzz問題

まさる — Thu, 08 Nov 2007 21:30:00 GMT

＃問題→オブジェクト指向におけるFizzBuzz問題

ってことでやってみました。

C#

public abstract class Animal
{
    private int soundsCount;
    protected string soundsString;

    public Animal()
    {
        this.soundsCount = 1;
    }

    public void Sound()
    {
        StringBuilder sounds = new StringBuilder();
        for ( int i = 0; i < this.soundsCount; i++ )
        {
            sounds.Append(this.soundsString);
        }
        Console.WriteLine(sounds.ToString());
    }

    public void SetCount(int count)
    {
        this.soundsCount = count;
    }
}

public class Cat : Animal
{
    public Cat()
    {
        this.soundsString = "にゃー";
    }
}

public class Dog : Animal
{
    public Dog()
    {
        this.soundsString = "わん";
    }
}

こんなかんじ？結果も確認済み。

※追記

だめだし食らったので再提出。Animalクラスを抽象クラスにしただけですけど。

デザインパターンを学ぶ～その１５：Factoryパターン(2)～

まさる — Wed, 07 Nov 2007 00:57:00 GMT

＃色々あって間が空きましたが、ようやくこのシリーズを再開します。

さて、前回はFactoryの基本ということで、Simple Factoryを取り上げました。今回はFactory Methodパターンを取り上げます。

Factory Methodパターンはインスタンス化するクラスをサブクラスに決定させるため、インスタンス化をサブクラスに先送りできます。これにより、実際にオブジェクトを使用するクラスから具象クラスへの依存がなくなります。

といってもよくわからないので、コードを書いてみましょう。

まず、生成されるオブジェクトのインタフェイスとなる抽象クラスAbstractMemberを定義します。ここで、インタフェイスとは広義の意味であり、interface（VBならInterface）で定義するインタフェイスのことではありません。
C# Code
```
public abstract class AbstractMember
{
    protected string name;

    public abstract void Speak();
}
```
VB Code
```
Public MustInherit Class AbstractMember

    Protected name As String

    Public MustOverride Sub Speak()

End Class
```

AbstractMemberを継承した具象クラスMasaru, Epistemeを定義します。

C# Code

public class Masaru : AbstractMember
{
    public Masaru()
    {
        this.name = "まさる";
    }

    public override void Speak()
    {
        Console.WriteLine("名前は{0}です。", this.name);
        Console.WriteLine("越後のとあるSIerで働いています。");
    }
}

public class Episteme : AbstractMember
{
    public Episteme()
    {
        this.name = "επιστημη";
    }

    public override void Speak()
    {
        Console.WriteLine("名前は{0}です。", this.name);
        Console.WriteLine("わんくま茶藝部顧問です。");
    }
}

VB Code

Public Class Masaru
    Inherits AbstractMember

    Sub New()

        Me.name = "まさる"

    End Sub

    Public Overrides Sub Speak()

        Console.WriteLine("名前は{0}です。", Me.name)
        Console.WriteLine("越後のとあるSIerで働いています。")

    End Sub

End Class

Public Class Episteme
    Inherits AbstractMember

    Sub New()

        Me.name = "επιστημη"

    End Sub

    Public Overrides Sub Speak()

        Console.WriteLine("名前は{0}です。", Me.name)
        Console.WriteLine("わんくま茶藝部顧問です。")

    End Sub

End Class

AbstractMemberを生成するための抽象クラスAbstractCreatorを定義します。

C# Code

public abstract class AbstractCreator
{
    public abstract AbstractMember CreateMember();
}

VB Code

Public MustInherit Class AbstractCreator

    Public MustOverride Function CreateMember() As AbstractMember

End Class

AbstractCreatorを継承したインスタン生成のための具象クラスNormalMemberCreator、SuperMemberCreatorを定義します。

C# Code

public class NormalMemberCreator : AbstractCreator
{
    public override AbstractMember CreateMember()
    {
        return new Masaru();
    }
}

public class SuperMemberCreator : AbstractCreator
{
    public override AbstractMember CreateMember()
    {
        return new Episteme();
    }
}

VB Code

Public Class NormalMemberCreator
    Inherits AbstractCreator

    Public Overrides Function CreateMember() As AbstractMember

        Return New Masaru()

    End Function

End Class

Public Class SuperMemberCreator
    Inherits AbstractCreator

    Public Overrides Function CreateMember() As AbstractMember

        Return New Episteme()

    End Function

End Class

以上のコードを実行してみましょう。

実行コード

C# Code

public static class Program
{
    public static void Main(string[] args)
    {
        {
            NormalMemberCreator memberCreator = new NormalMemberCreator();
            AbstractMember member = memberCreator.CreateMember();
            member.Speak();
        }

        Console.WriteLine("");

        {
            SuperMemberCreator memberCreator = new SuperMemberCreator();
            AbstractMember member = memberCreator.CreateMember();
            member.Speak();
        }

        Console.Read();
    }
}

VB Code

Public Class Program

    Private Shared Block As Object = Nothing

    Public Shared Sub Main(ByVal args As String())

        With Block

            Dim memberCreator As New NormalMemberCreator()
            Dim member As AbstractMember = memberCreator.CreateMember()
            member.Speak()

        End With

        Console.WriteLine("")

        With Block

            Dim memberCreator As New SuperMemberCreator()
            Dim member As AbstractMember = memberCreator.CreateMember()
            member.Speak()

        End With

        Console.ReadLine()

    End Sub

End Class

実行結果

名前はまさるです。
越後のとあるSIerで働いています。

名前はεπιστημηです。
わんくま茶藝部顧問です。

上記の実行コードはSpeakメソッドを実装している具象クラスのことを知りません。これが依存性をなくしたということです。

これによって何が良いのかというと、例えばMasaruクラスでなく、Torikobitoクラスに変更したい場合、実行コードに変更が必要ありません。あくまでTorikobitoクラスの追加と、NormalMemberCreatorの変更だけで済みます。

変更点

C# Code

public class Torikobito : AbstractMember
{
    public Torikobito()
    {
        this.name = "とりこびと";
    }

    public override void Speak()
    {
        Console.WriteLine("名前は{0}です。", this.name);
        Console.WriteLine("Memo(Of T)管理人です。");
    }
}

public class NormalMemberCreator : AbstractCreator
{
    public override AbstractMember CreateMember()
    {
        //return new Masaru();
        return new Torikobito();
    }
}

VB Code

Public Class Torikobito
    Inherits AbstractMember

    Sub New()

        Me.name = "とりこびと"

    End Sub

    Public Overrides Sub Speak()

        Console.WriteLine("名前は{0}です。", Me.name)
        Console.WriteLine("Memo(Of T)管理人です。")

    End Sub
End Class

Public Class NormalMemberCreator
    Inherits AbstractCreator

    Public Overrides Function CreateMember() As AbstractMember

        'Return New Masaru()
        Return New Torikobito()

    End Function

End Class

実行結果

名前はとりこびとです。
Memo(Of T)管理人です。

名前はεπιστημηです。
わんくま茶藝部顧問です。

ということで、今回はFactory Methodパターンをお送りしましたが、私自身まだこのパターンの有用性が理解し切れていません。実際に「こんなときに使ったよ」などありましたらコメントで教えてください。