デザインパターン

デザインパターンを学ぶ～その２７：IObservable、IObserverでObserverパターン～

まさる（高野将、TAKANO Sho） — Tue, 23 Aug 2011 23:32:00 GMT

.NET Framework 4 では、イベントベースでないObserverパターンを実装するためのインターフェースとして、

の２つが新たに追加されました。

この２つのインターフェースはReactive Extensions（Rx）でもおなじみですが、どのように使えばよいかを学ぶため、デザインパターンを学ぶ～その４：Ovserverパターン(1)～のコードをIObserver<T>、IObservable<T>を使用する形で再実装してみました。

using System;
using System.Collections.Generic;

namespace ConsoleApplication1
{
  // メール情報
  class MailInfo
  {
    public string From { get; set; }
    public string To { get; set; }
    public string Subject { get; set; }
  }

  // メール管理クラス
  class MailManager : IObservable<MailInfo>
  {
    // Observerリスト
    private List<IObserver<MailInfo>> observers;

    // クラス
    public MailManager()
    {
      observers = new List<IObserver<MailInfo>>();
    }

    // Observer購読
    public IDisposable Subscribe(IObserver<MailInfo> observer)
    {
      if (!observers.Contains(observer))
      {
        observers.Add(observer);
      }
      return new Unsubscriber(observers, observer);
    }

    // データ設定
    public void SetData(MailInfo mailInfo)
    {
      // Observerに通知
      observers.ForEach(x => x.OnNext(mailInfo));
    }

    // 購読解除クラス
    public class Unsubscriber : IDisposable
    {
      private ICollection<IObserver<MailInfo>> observers;
      private IObserver<MailInfo> observer;

      public Unsubscriber(ICollection<IObserver<MailInfo>> observers, IObserver<MailInfo> observer)
      {
        this.observers = observers;
        this.observer = observer;
      }

      // 購読解除
      public void Dispose()
      {
        if (observers.Contains(observer))
        {
          observers.Remove(observer);
        }
      }
    }
  }

  // Faxクラス
  class Fax : IObserver<MailInfo>
  {
    public void OnNext(MailInfo value)
    {
      Console.WriteLine("Faxを送信します。");
      Console.WriteLine("From:{0}, To:{1}, Subject:{2}", value.From, value.To, value.Subject);
    }

    public void OnCompleted()
    {
      throw new NotImplementedException();
    }

    public void OnError(Exception error)
    {
      throw new NotImplementedException();
    }
  }

  // Printerクラス
  class Printer : IObserver<MailInfo>
  {
    public void OnNext(MailInfo value)
    {
      Console.WriteLine("印刷します。");
      Console.WriteLine("From={0}, To={1}, Subject={2}", value.From, value.To, value.Subject);
    }

    public void OnCompleted()
    {
      throw new NotImplementedException();
    }

    public void OnError(Exception error)
    {
      throw new NotImplementedException();
    }
  }

  // テストプログラム
  class Program
  {
    static void Main(string[] args)
    {
      var manager = new MailManager();

      // Faxで購読
      var fax = new Fax();
      IDisposable faxUnsubscriber = manager.Subscribe(fax);

      // データ設定、通知
      manager.SetData(new MailInfo()
      {
        From = "masaru@wankuma.com",
        To = "test@example.com",
        Subject = "送るよ～ん"
      });

      // Printerで購読
      var printer = new Printer();
      IDisposable printerUnsubscriber = manager.Subscribe(printer);

      // データ設定、通知
      manager.SetData(new MailInfo()
      {
        From = "masaru@wankuma.com",
        To = "test@example.com",
        Subject = "再送するよ～ん"
      });

      // Faxでの購読解除
      faxUnsubscriber.Dispose();

      // データ設定、通知
      manager.SetData(new MailInfo()
      {
        From = "masaru@wankuma.com",
        To = "test@example.com",
        Subject = "最後送るよ～ん"
      });
    }
  }
}

実行結果

一言でいえば、IObservable<T>のSubscribeメソッドで、IObserver<T>での購読を指定し、購読登録したIObserver<T>のOnNextメソッドで通知を行う、となるでしょうか。

（なお、今回はIObserver<T>のOnCompletedメソッド、OnErrorメソッドは実装を省いています。）

デザインパターンを学ぶ～その５：Ovserverパターン(2)～でのイベントを用いた実装では、イベントハンドラーの登録、削除を行う必要があり若干煩雑になってしまっていましたが、今回の実装では登録はSubscribe、解除はDisposeするだけと、非常にシンプルになっています。

また、イベントの登録、解除はC#では+=,-=演算子、VBではAddHandler,RemoveHandlerステートメントと実装がバラバラになってしまうので、それが統一できることも大きい改善点ではないかと思います。

まだ、さわりの部分しか試していませんが、よく出来ていますねぇ。

また機会を見て、OnCompletedメソッド、OnErrorメソッドの動きを含め、Rxと絡めつつ学んでいこうと思います。

デザインパターンを学ぶ～その26：Facade（Façade）パターン～

まさる — Mon, 29 Mar 2010 02:50:00 GMT

Facade（Facade）：ファサード
　表面、一面、うわべ、建物の正面

Facade（Facade）パターンは、複数の関連するクラス群のオブジェクトを使った、ある程度複雑な処理に対して「窓口」となるインターフェースを提供するパターンです。ただし、Facadeで使用するクラスのカプセル化は行わないため、Facadeを通さずに直接使用することも可能です。

インターフェースを用意するという点で、Adapterパターンに似ていると感じるかもしれません。ただ、Adapterパターンの目的がインターフェースの「変換」であるのに対して、Facadeパターンの目的はインターフェースを「簡素化」することです。

それでは、実装例を見てみましょう。まずは、以下のようなクラス群があったとします。

public class RoomLight
{
	public void TurnOn()
	{
		Console.WriteLine("ルームライトをつけました");
	}

	public void TurnOff()
	{
		Console.WriteLine("ルームライトを消しました");
	}
}

public class DVDPlayer
{
	public void PowerOn()
	{
		Console.WriteLine("プレイヤーの電源を入れました");
	}

	public void PowerOff()
	{
		Console.WriteLine("プレイヤーの電源を落としました");
	}

	public void Insert(string dvdName)
	{
		Console.WriteLine("{0}を挿入します", dvdName);
	}

	public void Eject()
	{
		Console.WriteLine("DVDを取り出しました");
	}

	public void Play()
	{
		Console.WriteLine("再生しました");
	}

	public void Stop()
	{
		Console.WriteLine("停止しました");
	}
}

これらのクラス群を用いた処理として、以下の2つを考えます。

・DVDの視聴開始

・DVDの視聴終了

この2つの処理を行うFacadeクラスは以下のようになります。

public class TheaterRoomFacade
{
	public void PlayMovie(string dvdName)
	{
		Console.WriteLine("DVD:{0}の視聴を始めます", dvdName);
		var player = new DVDPlayer();
		player.PowerOn();
		player.Insert(dvdName);
		player.Play();

		var light = new RoomLight();
		light.TurnOff();
	}

	public void StopMovie()
	{
		Console.WriteLine("DVDの視聴を終えます");
		var light = new RoomLight();
		light.TurnOn();

		var player = new DVDPlayer();
		player.Stop();
		player.Eject();
		player.PowerOff();
	}
}

クライアント（今回はProgramクラスのMainメソッド）では、Facadeを通して各クラスを用いた処理を行うようにします。

public class Program
{
	static void Main(string[] args)
	{
		var facade = new TheaterRoomFacade();
		facade.PlayMovie("崖の上のポニョ");

		Console.WriteLine("--- 視聴中 ---");

		facade.StopMovie();
	}
}

それでは実行してみましょう。

Facadeパターンを適用する際の利点として、たとえば今後オーディオシステムも導入した場合、クライアントコードの変更はせずに、Facadeにだけ変更を加えればよくなるといったことがあげられます。

ちなみに、Facadeパターンの実際に実用的な例としては、ASP.NET MVCやStrutsなどのMVCモデルのアプリケーションでは、Controllerにあたるクラスが一種のFacadeとみなせます。

さて、今回はFacadeパターンについて簡単に解説しました。次回はTemplate Methodパターンを紹介します。

デザインパターンを学ぶ～その25：Adapterパターン(2)～

まさる — Wed, 10 Mar 2010 23:52:00 GMT

前回に引き続き「Adapterパターン」です。

前回は「継承型」のAdapterパターンを紹介しました。今回は「委譲型」のAdapterパターンを紹介します。

まずはおさらいとして、Adapterで適合させたいインターフェイス、クラスを見てみましょう。

// しゃべれるインターフェース
interface ISpeakable
{
  void Speak();
}

// 人間クラス
class Human : ISpeakable
{
  // しゃべる
  public void Speak()
  {
    Console.WriteLine("こんにちは");
  }
}

// アヒルクラス
class Duck
{
  // 鳴く
  public void Quack()
  {
    Console.WriteLine("クワックワッ");
  }
}

今回の目的はDuckクラスをISpeakableインターフェイスを使って呼び出すようにすることです。

そのためには、ISpeakableインターフェイスを実装したクラスの内部にDuckクラスのオブジェクトを持たせ、SpeakメソッドではそのオブジェクトのQuackメソッドを呼び出す（委譲）ようにします。

それでは、委譲型のAdapterの例を以下に示します。

// 委譲Adapter
class DelegateSpeakAdapter : ISpeakable
{
	// 内部にアヒル型を持つ
	private Duck duck = new Duck();

	// しゃべる
	public void Speak()
	{
		// 内部に持ったアヒルを鳴かせる <- ここのところが委譲
		this.duck.Quack();
	}
}

実行結果は以下の通りです。

さて、インターフェイスを実装するクラス内にオブジェクトを含有する構造はDecoratorパターンに似ています。しかし、Decoratorパターンがクラスの「装飾」を目的としていたのに対し、Adapterパターンは既存のクラスにインターフェイスを「適合」させることが目的です。

したがって、パターンを適用する場合は明確に使い分けるように注意しなければなりません。

以上でAdapterパターンは終わりです。

次回はAdapterパターンと目的が似ているFacadeパターンを取り上げるつもりです。

デザインパターンを学ぶ～その24：Adapterパターン(1)～

まさる — Mon, 08 Mar 2010 23:25:00 GMT

Adapter
　適合者

Adapterパターンはその名の通り、クラスのインターフェースを「適合」させるためのパターンです。

ベンダーが作成したクラスなど、手を加えられないクラスに対して、統一したインターフェースを実現したい場合に用います。

例をあげましょう。まず、以下のようなインターフェイスがあったとしましょう。

// しゃべれるインターフェース
interface ISpeakable
{
	void Speak();
}

そして、ISpeakableインターフェイスを実装した人間クラスがあります。

// 人間クラス
class Human : ISpeakable
{
	// しゃべる
	public void Speak()
	{
		Console.WriteLine("こんにちは");
	}
}

今回は、次のようなDuckクラスも、Humanクラスと同じように使用したいと考えています。

// アヒルクラス
class Duck
{
	// 鳴く
	public void Quack()
	{
		Console.WriteLine("クワックワッ");
	}
}

こういったときAdapterパターンを使ってDuckに適合するAdapterクラスを作成します。

なお、Adapterパターンには大きく分けて、「継承型」と「委譲型」があります。今回は「継承型」を紹介します。

// 継承Adapter
class InheritanceSpeakAdapter : Duck, ISpeakable
{
	// しゃべる
	public void Speak()
	{
		// 基底クラスのメソッドを呼び出す
		Quack();
	}
}

継承型のAdapterパターンでは、インターフェースを適合させたいクラスを継承した上で、インターフェイスを実装します。

そして、インターフェイスのメソッドを実装する際、基底クラスのメソッドを呼び出すように設定します。

それでは、実行してみましょう。

class Program
{
	static void Main(string[] args)
	{
		// 人間がしゃべる
		{
			var speaker = new Human();
			speaker.Speak();
		}

		// アヒルがしゃべる
		{
			var speaker = new InheritanceSpeakAdapter();
			speaker.Speak();
		}
	}
}

同一の呼び出し方で、人間とアヒルにしゃべらせることができました。

次回は委譲型のAdapterパターンを紹介します。

デザインパターンを学ぶ～その23：Commandパターン(3)～

まさる — Thu, 07 Jan 2010 23:45:00 GMT

デザインパターンを学ぶ～その21：Commandパターン(1)～

デザインパターンを学ぶ～その22：Commandパターン(2)～

と続いたCommandパターンの最後は、Undo機能を実装してみましょう。手順は次の通り。

Do、UndoメソッドをもつIUndoableCommandインターフェイスを定義します。

public interface IUndoableCommand
{
  void Do();
  void Undo();
}

Receiverを定義します。今回はサンプルとしてCounterクラスを考えます。

public class Counter
{
  public Counter(int initialValue)
  {
    Count = initialValue;
  }

  public void Up()
  {
    Count++;
  }

  public void Down()
  {
    Count--;
  }

  public int Count
  {
    get;
    private set;
  }
}

Counterクラスに対し、カウントアップ、ダウンを行うCommandクラスを定義します。

public class CountUpCommand : IUndoableCommand
{
  private Counter counter;

  public CountUpCommand(Counter counter)
  {
    this.counter = counter;
  }

  public void Do()
  {
    counter.Up();
  }

  public void Undo()
  {
    counter.Down();
  }
}

public class CountDownCommand : IUndoableCommand
{
  private Counter counter;

  public CountDownCommand(Counter counter)
  {
    this.counter = counter;
  }

  public void Do()
  {
    counter.Down();
  }

  public void Undo()
  {
    counter.Up();
  }
}

Undoに備えて何もしないNullCommandクラスも定義します。

public class NullCommand : IUndoableCommand
{
  public void Do()
  {
  }

  public void Undo()
  {
  }
}

Invokerとして、CountManagerクラスを定義します。

public class CountManager
{
  private IUndoableCommand upCommand;   // カウントアップ用Command
  private IUndoableCommand downCommand; // カウントダウン用Command
  private IUndoableCommand undoCommand; // Undo用Command

  public CountManager(IUndoableCommand upCommand, IUndoableCommand downCommand)
  {
    // 引数で渡されたCommandをフィールド設定
    this.upCommand = upCommand;
    this.downCommand = downCommand;
    
    // 最初はUndo操作をしても何もしないので、
    // NullCommandをundoCommandに設定
    this.undoCommand = new NullCommand();
  }

  public void DoUp()
  {
    // カウントアップ実行
    upCommand.Do();
    // 実行したCommandをundoCommandに設定
    undoCommand = upCommand;
  }

  public void DoDown()
  {
    // カウントダウン実行
    downCommand.Do();
    // 実行したCommandをundoCommandに設定
    undoCommand = downCommand;
  }

  public void Undo()
  {
    // Undo実行
    undoCommand.Undo();
    // Undoを連続して行えないよう、
    // NullCommandを設定
    undoCommand = new NullCommand();
  }
}

では、実行してみましょう。実行用コードは以下の通りです。

class Program
{
  static void Main(string[] args)
  {
    // 新規カウンター（Receiver）作成
    Counter counter = new Counter(10);
    Console.WriteLine(counter.Count);

    // カウントアップ、ダウン用Commandクラスのインスタンス作成
    CountUpCommand cuc = new CountUpCommand(counter);
    CountDownCommand cdc = new CountDownCommand(counter);

    // CountManager（Invoker）を作成
    CountManager cm = new CountManager(cuc, cdc);

    // カウントアップ
    cm.DoUp();
    Console.WriteLine(counter.Count);

    // カウントダウン
    cm.DoDown();
    Console.WriteLine(counter.Count);

    // Undo
    cm.Undo();
    Console.WriteLine(counter.Count);

    // Undo
    cm.Undo();
    Console.WriteLine(counter.Count);
  }
}

実行結果は以下の通り。

一度目のUndoでカウンターが元に戻り、二度目のUndoではカウンターに変化がないことが確認できます。

さて、ここまでのやり方は一度しかUndoが出来ないものでした。これを複数回Undo可能にするにはどうすればいいのでしょうか？

実はかなり簡単です。Invokerの中にStackとして実行したCommandを保持して、PopしながらUndoを行えばいいだけです。以下は、複数回のUndoを可能にしたCountManagerMultiUndoableです。

public class CountManagerMultiUndoable
{
  private IUndoableCommand upCommand;           // カウントアップ用Command
  private IUndoableCommand downCommand;         // カウントダウン用Command
  private Stack<IUndoableCommand> undoCommands; // Undo用CommandのStack

  public CountManagerMultiUndoable(IUndoableCommand upCommand, IUndoableCommand downCommand)
  {
    // 引数で渡されたCommandをフィールド設定
    this.upCommand = upCommand;
    this.downCommand = downCommand;

    // Stackを初期化
    undoCommands = new Stack<IUndoableCommand>();
  }

  public void DoUp()
  {
    // カウントアップ実行
    upCommand.Do();
    // 実行したCommandをStackにPush
    undoCommands.Push(upCommand);
  }

  public void DoDown()
  {
    // カウントダウン実行
    downCommand.Do();
    // 実行したCommandをStackにPush
    undoCommands.Push(downCommand);
  }

  public void Undo()
  {
    if (undoCommands.Count != 0)
    {
      // Stackが空でなければ、PopしてUndo実行
      var undoCommand = undoCommands.Pop();
      undoCommand.Undo();
    }
  }
}

では、実行してみましょう。先ほどと違って、Undoを3回行うようにしてみます。

class Program
{
  static void Main(string[] args)
  {
    // 新規カウンター（Receiver）作成
    Counter counter = new Counter(10);
    Console.WriteLine(counter.Count);

    // カウントアップ、ダウン用Commandクラスのインスタンス作成
    CountUpCommand cuc = new CountUpCommand(counter);
    CountDownCommand cdc = new CountDownCommand(counter);

    // CountManager（Invoker）を作成
    CountManagerMultiUndoable cm = new CountManagerMultiUndoable(cuc, cdc);

    // カウントアップ
    cm.DoUp();
    Console.WriteLine(counter.Count);

    // カウントダウン
    cm.DoDown();
    Console.WriteLine(counter.Count);

    // Undo
    cm.Undo();
    Console.WriteLine(counter.Count);

    // Undo
    cm.Undo();
    Console.WriteLine(counter.Count);

    // Undo
    cm.Undo();
    Console.WriteLine(counter.Count);
  }
}

実行結果は以下の通りです。

2度Undoが行われ、3度目は何もカウンターに変化がないことが確認できます。

ここまで3回にわたりCommandパターンを紹介しましたが、いかがでしたでしょうか？

Commandパターンは他にも、

QueueにCommandオブジェクトを登録して順次呼び出す
Commandオブジェクトを永続化して、必要な際に取り出して呼び出す
Commandオブジェクトを直列化（シリアライズ）して、ネットワークなどの境界を越えて実行

など、色々と活用する場面があるようです。

私も今後もどのように有効に活用できるか考えていきたいと思います。

昨年はまったくと言っていいほど進まなかった、このデザインパターンシリーズ。今年はがんばってやっていこうと思います。次回は「Adapterパターン」に入っていくつもりですので、今後ともお付き合いをお願いします。

なお、今後コードはC#のみとさせてもらいます。案外VBにportするのが大変なものでf(^^;

FizzBuzz＞これは何パターンなんだろ？

まさる — Wed, 21 Oct 2009 00:18:00 GMT

FizzBuzz祭りでいじくってて出来たコードの断片。

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

namespace ConsoleApplication1
{
  class FizzBuzzSpeaker
  {
    private int number;
    private FizzBuzzSpeaker child;

    public FizzBuzzSpeaker(int number, FizzBuzzSpeaker speaker)
    {
      this.number = number;
      this.child = speaker;
    }

    public void Speak()
    {
      if (this.child != null)
      {
        this.child.Speak();
      }

      Console.WriteLine(
        this.number % 3 == 0 && this.number % 5 == 0 ? "FizzBuzz"
        : this.number % 3 == 0 ? "Fizz"
        : this.number % 5 == 0 ? "Buzz"
        : number.ToString()
        );
    }
  }
  class Program
  {
    static void Main(string[] args)
    {
      FizzBuzzSpeaker speaker = null;
      for (var n = 1; n <= 30; n++)
      {
        speaker = new FizzBuzzSpeaker(n, speaker);
      }
      speaker.Speak();
    }
  }
}

Decoratorのような、Chain-of-Responsibilityのような、どちらでもないような？

FizzBuzz＞それChain-of-Responsibilityパターンで

まさる — Tue, 13 Oct 2009 08:05:00 GMT

ネタ元→無意味に難解なFizzBuzz

Decoratorパターンだとぅ?
そんじゃこちとらChain-of-Responsibilityパターンで

C#にportぢゃ！うら！

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

namespace ConsoleApplication1
{
  abstract class Checker
  {
    public abstract bool Equals(int n);
  }

  class Holder
  {
    private Checker checker;
    public Holder(Checker checker)
    {
      this.checker = checker;
    }
    public bool Equals(int n)
    {
      return this.checker.Equals(n);
    }
  }

  class FizzBuzz : Checker
  {
    private int mod;
    private string word;
    public FizzBuzz(int mod, string word)
    {
      this.mod = mod;
      this.word = word;
    }

    public override bool Equals(int n)
    {
      if (n % mod != 0)
      {
        return false;
      }
      Console.WriteLine("{0}({1})", word, n);
      return true;
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
      List<Holder> holders = new List<Holder>();
      holders.Add(new Holder(new FizzBuzz(15, "FizzBuzz")));
      holders.Add(new Holder(new FizzBuzz(3, "Fizz")));
      holders.Add(new Holder(new FizzBuzz(5, "Buzz")));

      for (var i = 1; i <= 30; i++)
      {
        bool hit = false;
        foreach (var holder in holders)
        {
          if (holder.Equals(i))
          {
            hit = true;
            break;
          }
        }
        if (!hit)
        {
          Console.WriteLine("{0} ", i);
        }
      }
    }
  }
}

＃合ってるかしら？f(^^;

FizzBuzz＞それDecoratorパターンで（改）

まさる — Mon, 12 Oct 2009 08:15:00 GMT

FizzBuzz＞それLINQで＞それワンライナーで

FizzBuzz＞それyield returnで

FizzBuzz＞それDecoratorパターンで

の続き。

よく考えたら逆順にぶっこむ必要がなかったので、改訂版を。

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

namespace ConsoleApplication1
{
  // FizzBuzzのもと
  public abstract class FizzBuzzBase
  {
    // 中の人
    public FizzBuzzBase FizzBuzz { get; private set; }

    // しゃべる言葉
    public abstract string Word { get; }

    // 中の人をセット
    public FizzBuzzBase(FizzBuzzBase fizzbuzz)
    {
      this.FizzBuzz = fizzbuzz;
    }

    // しゃべれ
    public void Speak()
    {
      // 中の人にしゃべらせる
      if (this.FizzBuzz != null)
      {
        this.FizzBuzz.Speak();
      }

      // 自分がしゃべる
      Console.WriteLine(Word);
    }
  }

  // Fizz
  public class Fizz : FizzBuzzBase
  {
    public Fizz(FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
    }

    public override string Word
    {
      get { return "Fizz"; }
    }
  }

  // Buzz
  public class Buzz : FizzBuzzBase
  {
    public Buzz(FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
    }

    public override string Word
    {
      get { return "Buzz"; }
    }
  }

  // FizzBuzz
  public class FizzBuzz : FizzBuzzBase
  {
    public FizzBuzz(FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
    }

    public override string Word
    {
      get { return "FizzBuzz"; }
    }
  }

  // 数字
  public class Number : FizzBuzzBase
  {
    private int number;

    public Number(int number, FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
      this.number = number;
    }

    public override string Word
    {
      get { return this.number.ToString(); }
    }
  }

  // メイン
  class Program
  {
    static void Main(string[] args)
    {
      FizzBuzzBase fizzbuzz = null;
      foreach (int i in Enumerable.Range(1, 20))
      {
        if (i % 3 == 0 && i % 5 == 0)
        {
          fizzbuzz = new FizzBuzz(fizzbuzz);
        }
        else if (i % 3 == 0)
        {
          fizzbuzz = new Fizz(fizzbuzz);
        }
        else if (i % 5 == 0)
        {
          fizzbuzz = new Buzz(fizzbuzz);
        }
        else
        {
          fizzbuzz = new Number(i, fizzbuzz);
        }
      }

      // しゃべれ
      fizzbuzz.Speak();
    }
  }
}

違うのはFizzBuzzBaseクラスのSpeakメソッドの中身。

中の人にしゃべらせてから、自分がしゃべればいいだけでしたf(^^;

一応実行結果。

FizzBuzz＞それDecoratorパターンで

まさる — Mon, 12 Oct 2009 08:09:00 GMT

FizzBuzz＞それLINQで＞それワンライナーで

FizzBuzz＞それyield returnで

の続き。

FizzBuzzを「いかに面倒に解くか」みたいになってるので、Decoratorパターンでやってみた。

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

namespace ConsoleApplication1
{
  // FizzBuzzのもと
  public abstract class FizzBuzzBase
  {
    // 中の人
    public FizzBuzzBase FizzBuzz { get; private set; }

    // しゃべる言葉
    public abstract string Word { get; }

    // 中の人をセット
    public FizzBuzzBase(FizzBuzzBase fizzbuzz)
    {
      this.FizzBuzz = fizzbuzz;
    }

    // しゃべれ
    public void Speak()
    {
      Console.WriteLine(Word);

      // 中の人にしゃべらせる
      if (this.FizzBuzz != null)
      {
        this.FizzBuzz.Speak();
      }
    }
  }

  // Fizz
  public class Fizz : FizzBuzzBase
  {
    public Fizz(FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
    }

    public override string Word
    {
      get { return "Fizz"; }
    }
  }

  // Buzz
  public class Buzz : FizzBuzzBase
  {
    public Buzz(FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
    }

    public override string Word
    {
      get { return "Buzz"; }
    }
  }

  // FizzBuzz
  public class FizzBuzz : FizzBuzzBase
  {
    public FizzBuzz(FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
    }

    public override string Word
    {
      get { return "FizzBuzz"; }
    }
  }

  // 数字
  public class Number : FizzBuzzBase
  {
    private int number;

    public Number(int number, FizzBuzzBase fizzbuzz)
      : base(fizzbuzz)
    {
      this.number = number;
    }

    public override string Word
    {
      get { return this.number.ToString(); }
    }
  }

  // メイン
  class Program
  {
    static void Main(string[] args)
    {
      FizzBuzzBase fizzbuzz = null;
      // 1からしゃべらせるため、逆からぶっこむ
      foreach (int i in Enumerable.Range(1, 20).Reverse())
      {
        if (i % 3 == 0 && i % 5 == 0)
        {
          fizzbuzz = new FizzBuzz(fizzbuzz);
        }
        else if (i % 3 == 0)
        {
          fizzbuzz = new Fizz(fizzbuzz);
        }
        else if (i % 5 == 0)
        {
          fizzbuzz = new Buzz(fizzbuzz);
        }
        else
        {
          fizzbuzz = new Number(i, fizzbuzz);
        }
      }

      // しゃべれ
      fizzbuzz.Speak();
    }
  }
}

うん、上々♪

VBでProducer/Consumerパターン

まさる — Wed, 16 Sep 2009 22:31:00 GMT

ネタ元：生産者と消費者

＃勝手にportしちゃうぞ企画第２段ｗ

今回はMSDNライブラリ「方法 : producer スレッドと consumer スレッドを同期する (C# プログラミングガイド)」のコードをVBにportしました。

VBに変換する際気を付けるのは、以下のような点。

lockステートメントはSyncLock
配列の初期化方法が違う

コードは以下の通り。

Imports System.Threading

Public Class SyncEvents
	Private _newItemEvent As EventWaitHandle
	Public ReadOnly Property NewItemEvent() As EventWaitHandle
		Get
			Return _newItemEvent
		End Get
	End Property

	Private _exitThreadEvent As EventWaitHandle
	Public ReadOnly Property ExitThreadEvent() As EventWaitHandle
		Get
			Return _exitThreadEvent
		End Get
	End Property

	Private _eventArray As WaitHandle()
	Public ReadOnly Property EventArray() As WaitHandle()
		Get
			Return _eventArray
		End Get
	End Property

	Public Sub New()
		_newItemEvent = New AutoResetEvent(False)
		_exitThreadEvent = New ManualResetEvent(False)
		_eventArray = New WaitHandle() {_newItemEvent, _exitThreadEvent}
	End Sub
End Class

Public Class Producer
	Private _queue As Queue(Of Integer)
	Private _syncEvents As SyncEvents

	Public Sub New(ByVal q As Queue(Of Integer), ByVal e As SyncEvents)
		_queue = q
		_syncEvents = e
	End Sub

	Public Sub ThreadRun()
		Dim count As Integer = 0
		Dim r As New Random()
		While Not _syncEvents.ExitThreadEvent.WaitOne(0, False)
			SyncLock DirectCast(_queue, ICollection).SyncRoot
				While _queue.Count < 20
					_queue.Enqueue(r.Next(0, 100))
					_syncEvents.NewItemEvent.Set()
					count += 1
				End While
			End SyncLock
		End While
		Console.WriteLine("Producer thread: produced {0} items", count)
	End Sub
End Class

Public Class Consumer
	Private _queue As Queue(Of Integer)
	Private _syncEvents As SyncEvents

	Public Sub New(ByVal q As Queue(Of Integer), ByVal e As SyncEvents)
		_queue = q
		_syncEvents = e
	End Sub

	Public Sub ThreadRun()
		Dim count As Integer = 0
		While WaitHandle.WaitAny(_syncEvents.EventArray) <> 1
			SyncLock DirectCast(_queue, ICollection).SyncRoot
				Dim item As Integer = _queue.Dequeue()
				count += 1
			End SyncLock
		End While
		Console.WriteLine("Consumer thread: consumed {0} items", count)
	End Sub
End Class

Public Class Program
	Private Shared Sub ShowQueueContents(ByVal q As Queue(Of Integer))
		SyncLock DirectCast(q, ICollection).SyncRoot
			For Each item As Integer In q
				Console.Write("{0} ", item)
			Next
		End SyncLock
		Console.WriteLine()
	End Sub

	Public Shared Sub Main()
		Dim queue As New Queue(Of Integer)
		Dim syncEvent As New SyncEvents()

		Console.WriteLine("Configuring worker threads...")

		Dim producer As New Producer(queue, syncEvent)
		Dim cunsumer As New Consumer(queue, syncEvent)

		Dim producerThread As New Thread(AddressOf producer.ThreadRun)
		Dim consumerThread As New Thread(AddressOf cunsumer.ThreadRun)

		Console.WriteLine("Launching producer and consumer threads...")

		producerThread.Start()
		consumerThread.Start()

		For i As Integer = 0 To 3
			Thread.Sleep(2500)
			ShowQueueContents(queue)
		Next i

		Console.WriteLine("Signaling threadds to terminate...")

		syncEvent.ExitThreadEvent.Set()

		producerThread.Join()
		consumerThread.Join()
	End Sub
End Class