public object Next()
{
IQuackable quack = QuackerList[position];
position++;
return(quack);
}
public void Init()
{
duckFactory = new CountingDuckFactory();
//QuackCounter is Decorator Pattern
mallardDuck = duckFactory.CreateMallardDuck();
redheadDuck = duckFactory.CreateRedheadDuck();
duckCall = duckFactory.CreateDuckCall();
rubberDuck = duckFactory.CreateRubberDuck();
gooseDuck = new GooseAdapter(new Goose());//Adapter Pattern
//Flock is Iterator Pattern
flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
flockOfMallards = new Flock();
mallardOne = duckFactory.CreateMallardDuck();
mallardTwo = duckFactory.CreateMallardDuck();
mallardThree = duckFactory.CreateMallardDuck();
mallardFour = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardOne);
flockOfMallards.Add(mallardTwo);
flockOfMallards.Add(mallardThree);
flockOfMallards.Add(mallardFour);
flockOfDucks.Add(flockOfMallards);
}
public QuackCounter(IQuackable duck)
{
this.duck = duck;
observable = new Observable(this);
}
public void Run()
{
CountingDuckFactory duckFactory = new CountingDuckFactory();
IQuackable redHeadDuck = duckFactory.CreateRedHeadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable gooseAdapter = new GooseAdapter(new Goose());
Flock flockOfMallards = new Flock();
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
flockOfMallards.Add(duckFactory.CreateMallardDuck());
Flock flockOfDucks = new Flock();
flockOfDucks.Add(redHeadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseAdapter);
flockOfDucks.Add(flockOfMallards);
flockOfDucks.RegisterObserver(new Quackologist());
Console.WriteLine("--- Duck Simulator ---");
Simulate(flockOfDucks);
Console.WriteLine($"{QuackCounterDecorator.NumberOfQuacks} quacks recorded");
}
public void Add(IQuackable q)
{
if (q != null)
{
_quackables.Add(q);
}
}
public void Simulate(AbstractDuckFactory duckFactory)
{
IQuackable mallardDuck = duckFactory.CreateMallardDuck();
IQuackable redheadDuck = duckFactory.CreateRedheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable goose = duckFactory.CreateGoose();
var flock = new Flock();
flock.Add(mallardDuck);
flock.Add(redheadDuck);
flock.Add(duckCall);
flock.Add(rubberDuck);
flock.Add(goose);
Quackologist ql = new Quackologist();
flock.RegisterObserver(ql);
System.Console.WriteLine("\nDuck simulator");
Simulate(flock);
//Simulate(redheadDuck);
//Simulate(duckCall);
//Simulate(rubberDuck);
//Simulate(goose);
System.Console.WriteLine(QuackCounter.NumberOfQuacks);
}
public void Simulate(AbstractDuckFactory factory)
{
//Step 9, using IQuackable Decorator(QuackableCounter)
//Duck Factories
IQuackable mallard = factory.CreateMallardDuck();
IQuackable redhead = factory.CreateRedheadDuck();
IQuackable duckcall = factory.CreateDuckCall();
IQuackable adaptedGoose = new QuackableCounter(new GooseAdapter(new Goose()));
Console.WriteLine("Duck Simulator: W Adapter, Decorator & Composite");
//Creating Flock(Composite)
Console.WriteLine("Flock of Ducks & Geese:");
Flock flock = new Flock();
flock.Add(mallard);
flock.Add(redhead);
flock.Add(duckcall);
//flock.Add(adaptedGoose);
//Observers
Quackologist quackologist = new Quackologist();
flock.RegisterObserver(quackologist);
Simulate(flock);
Console.WriteLine("Quack Counter = {0}", QuackableCounter.numberOfQuacks);
}
public void Dispose()
{
duckFactory = null;
mallardDuck = null;
redheadDuck = null;
duckCall = null;
rubberDuck = null;
gooseDuck = null;
flockOfDucks = null;
flockOfMallards = null;
mallardOne = null;
mallardTwo = null;
mallardThree = null;
mallardFour = null;
}
public void Remove(IQuackable q)
{
if (q != null && _quackables.Contains(q))
{
_quackables.Remove(q);
}
}
public void Init()
{
duckFactory = new CountingDuckFactory();
//QuackCounter is Decorator Pattern
mallardDuck = duckFactory.CreateMallardDuck();
redheadDuck = duckFactory.CreateRedheadDuck();
duckCall = duckFactory.CreateDuckCall();
rubberDuck = duckFactory.CreateRubberDuck();
gooseDuck = new GooseAdapter(new Goose()); //Adapter Pattern
//Flock is Iterator Pattern
flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
flockOfMallards = new Flock();
mallardOne = duckFactory.CreateMallardDuck();
mallardTwo = duckFactory.CreateMallardDuck();
mallardThree = duckFactory.CreateMallardDuck();
mallardFour = duckFactory.CreateMallardDuck();
flockOfMallards.Add(mallardOne);
flockOfMallards.Add(mallardTwo);
flockOfMallards.Add(mallardThree);
flockOfMallards.Add(mallardFour);
flockOfDucks.Add(flockOfMallards);
}
internal void Simnulate(AbstractDuckFactory duckFactory)
{
//1.使用工厂创建鸭子
//2.使用装饰者，创建被装饰的鸭子
IQuackable blueheadDuck = duckFactory.CreateBlueheadDuck();
IQuackable pinkheadDuck = duckFactory.CreatePinkheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
//使用适配器模式创建一个会鹅叫的鸭子。
IQuackable gooseDuck = new GooseAdapter(new Goose());
IQuackable[] quacks = { blueheadDuck, pinkheadDuck, duckCall, rubberDuck, gooseDuck };
//使用组合模式和迭代器模式
Flock flockOfDucks = new Flock(quacks);
Console.WriteLine("------鸭子模拟器-------");
Simnulate(flockOfDucks);
Console.WriteLine("------观察开始-------");
//使用观察者模式
IQuackableObservable provider = new IQuackableObservable();
IQuackableObserver reporter1 = new IQuackableObserver();
reporter1.Subscribe(provider);
provider.Notify(duckFactory.CreateRubberDuck());
Console.WriteLine("------观察结束-------");
Console.WriteLine("鸭子叫的次数为：" + QuackCounter.NumberOfQuacks);
}
public QuackCounterDecorator(IQuackable q)
{
if (q != null)
{
_quackable = q;
}
}
public void Simulate(AbstractDuckFactory duckFactory)
{
IQuackable mallardDuck = duckFactory.CreateMallardDuck();
IQuackable redheadDuck = duckFactory.CreateRedheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable quackingGoose = new GooseAdapter(new Goose());
Flock flockOfDucks = new Flock();
flockOfDucks.Add(mallardDuck);
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
Console.WriteLine("Separate Duck Simulation");
Simulate(mallardDuck);
Simulate(redheadDuck);
Simulate(duckCall);
Simulate(rubberDuck);
Simulate(quackingGoose);
Quackologist quackologist = new Quackologist();
flockOfDucks.RegisterObserver(quackologist);
Console.WriteLine("Flock of Ducks simulation");
Simulate(flockOfDucks);
Console.WriteLine("Quack counter : {0}", QuackCounter.QuackCount);
Console.ReadLine();
}
public void Add(IQuackable quacker)
{
quackers.Add(quacker);
}
public void SimulateQack(IQuackable duck, int numberOfQuacks)
{
for (int i = 0; i < numberOfQuacks; i++)
{
duck.quack();
}
}
void Simulate(AbstractDuckFactory duckFactory)
{
IQuackable redheadDuck = duckFactory.CreateRedheadDuck();
IQuackable duckCall = duckFactory.CreateDuckCall();
IQuackable rubberDuck = duckFactory.CreateRubberDuck();
IQuackable gooseDuck = new GooseAdapter(new Goose());
Console.WriteLine("Duck Simulator:");
Flock flockOfDucks = new Flock();
flockOfDucks.Add(redheadDuck);
flockOfDucks.Add(duckCall);
flockOfDucks.Add(rubberDuck);
flockOfDucks.Add(gooseDuck);
IQuackable mallardDuck1 = duckFactory.CreateMallardDuck();
IQuackable mallardDuck2 = duckFactory.CreateMallardDuck();
IQuackable mallardDuck3 = duckFactory.CreateMallardDuck();
IQuackable mallardDuck4 = duckFactory.CreateMallardDuck();
Flock flockOfMallards = new Flock();
flockOfMallards.Add(mallardDuck1);
flockOfMallards.Add(mallardDuck2);
flockOfMallards.Add(mallardDuck3);
flockOfMallards.Add(mallardDuck4);
flockOfDucks.Add(flockOfMallards);
Console.WriteLine("\nWhole Flock:");
this.Simulate(flockOfDucks);
Console.WriteLine("\nMallard Flock:");
this.Simulate(flockOfMallards);
Console.WriteLine("Total Quack: " + QuackCounter.NumberQuacker);
}
static void Main(string[] args)
{
AbstractDuckFactory _duckFactory = new CountingDuckFactory();
IQuackable _mallardDuck = _duckFactory.CreateMallarDuck();
IQuackable _readheadDuck = _duckFactory.CreateRedheadDuck();
IQuackable _duckCall = _duckFactory.CreateDuckCall();
IQuackable _rubberDuck = _duckFactory.CreateRubberDuck();
IQuackable _goose = new GooseAdapter(new Goose());
Console.WriteLine("\nDuck Simulator\n");
//Стая уток
DuckFlock _duckFlock = new DuckFlock();
_duckFlock.Add(_readheadDuck);
_duckFlock.Add(_rubberDuck);
_duckFlock.Add(_duckCall);
_duckFlock.Add(_goose);
_mallardDuck.Quack();
_readheadDuck.Quack();
_duckCall.Quack();
_rubberDuck.Quack();
_goose.Quack();
Console.WriteLine("\nThe ducks quacks " + QuackCounter.GetQuacks() + " times");
//Вызов стаи
_duckFlock.Quack();
Console.ReadLine();
}
void simulate(AbstractDuckFactory duckFactory)
{
//Quackable mallardDuck = duckFactory.createMallardDuck();
IQuackable redheadDuck = duckFactory.createRedheadDuck();
IQuackable duckCall = duckFactory.createDuckCall();
IQuackable rubberDuck = duckFactory.createRubberDuck();
IQuackable gooseDuck = new GooseAdapter(new Goose());
/*
* Quackable mallardDuck = new QuackCounter(new MallardDuck());
* Quackable redheadDuck = new QuackCounter(new RedheadDuck());
* Quackable duckCall = new QuackCounter(new DuckCall());
* Quackable rubberDuck = new QuackCounter(new RubberDuck());
* Quackable gooseDuck = new GooseAdapter(new Goose());
*/
Console.WriteLine("\nDuck Simulator: With Composite - Flocks");
Flock flockOfDucks = new Flock();
flockOfDucks.add(redheadDuck);
flockOfDucks.add(duckCall);
flockOfDucks.add(rubberDuck);
flockOfDucks.add(gooseDuck);
Flock flockOfMallards = new Flock();
IQuackable mallardOne = duckFactory.createMallardDuck();
IQuackable mallardTwo = duckFactory.createMallardDuck();
IQuackable mallardThree = duckFactory.createMallardDuck();
IQuackable mallardFour = duckFactory.createMallardDuck();
flockOfMallards.add(mallardOne);
flockOfMallards.add(mallardTwo);
flockOfMallards.add(mallardThree);
flockOfMallards.add(mallardFour);
flockOfDucks.add(flockOfMallards);
/*
* simulate(mallardDuck);
* simulate(redheadDuck);
* simulate(duckCall);
* simulate(rubberDuck);
* simulate(gooseDuck);
*/
Quackologist quackologist = new Quackologist();
flockOfDucks.registerObserver(quackologist);
Console.WriteLine("\nDuck Simulator: Whole Flock Simulation");
simulate(flockOfDucks);
Console.WriteLine("\nDuck Simulator: Mallard Flock Simulation");
simulate(flockOfMallards);
Console.WriteLine("The ducks quacked " + QuackCounter.getQuacks() + " times");
}
public Duck(string name, IFlyable flyBehavior, IQuackable quackBehavior)
{
this.Name = name;
this._flyBehavior = flyBehavior;
this._quackBehavior = quackBehavior;
this.Display();
}
public void AddQuacker(IQuackable quacker)
{
_quackers.Add(quacker);
foreach (var observer in _observers)
{
quacker.Subscribe(observer);
}
}
public QuackCounter(IQuackable duck)
{
this.duck = duck;
observable = new Observable(this);
}
private IQuackable _gooseDuck;//经过适配器包装的鹅
public DuckSimulator(AbstractDuckFactory duckFactory)
{
_duckFactory = duckFactory;
_mallardDuck = _duckFactory.CreateMallardDuck();
_redheadDuck = _duckFactory.CreateRedheadDuck();
_duckCall = _duckFactory.CreateDuckCall();
_rubberDuck = _duckFactory.CreateRubberDuck();
_gooseDuck = new GooseAdapter(new Goose());
}
public void RegisterObserver(IObserver observer)
{
DuckIterator iterator = new DuckIterator(ducks);
while (iterator.HasNext())
{
IQuackable duck = (IQuackable)iterator.Next();
duck.RegisterObserver(observer);
}
}
public void Quack()
{
IEnumerator <IQuackable> enumerator = quackers.GetEnumerator();
while (enumerator.MoveNext())
{
IQuackable quacker = enumerator.Current;
quacker.Quack();
}
}
public void RegisterObserver(IObserver observer)
{
IEnumerator <IQuackable> enumerator = quackers.GetEnumerator();
while (enumerator.MoveNext())
{
IQuackable quacker = enumerator.Current;
quacker.RegisterObserver(observer);
}
}
public void NotifyObservers()
{
IEnumerator <IQuackable> enumerator = quackers.GetEnumerator();
while (enumerator.MoveNext())
{
IQuackable quacker = enumerator.Current;
quacker.NotifyObservers();
}
}
public void RegisterObserver(IObserver observer)
{
IEnumerator iterator = quackers.GetEnumerator();
while (iterator.MoveNext())
{
IQuackable duck = (IQuackable)iterator.Current;
duck.RegisterObserver(observer);
}
}
public void Quack()
{
DuckIterator iterator = new DuckIterator(ducks);
while (iterator.HasNext())
{
IQuackable quacker = (IQuackable)iterator.Next();
quacker.Quack();
}
}
public void Quack()
{
Iterator iterator = CreateIterator();
while (iterator.HasNext())
{
IQuackable quacker = (IQuackable)iterator.Next();
quacker.Quack();
}
}
public void RegisterObserver(IObserver observer)
{
Iterator iterator = CreateIterator();
while (iterator.HasNext())
{
IQuackable quacker = (IQuackable)iterator.Next();
quacker.RegisterObserver(observer);
}
}
public void registerObserver(IObserver observer)
{
var iterator = quackers.GetEnumerator();
while (iterator.MoveNext())
{
IQuackable quacker = iterator.Current;
quacker.registerObserver(observer);
}
}
private static void CreateDucks(DuckFactoryBase countingDuckFactory, out IQuackable mallarDuck, out IQuackable duckCallDuck,
out IQuackable fakeDuckIsAGoose, out IQuackable rubberDuck,
out IQuackable redheadDuck)
{
mallarDuck = countingDuckFactory.createMallarDuck();
rubberDuck = countingDuckFactory.createRubberDuck();
redheadDuck = countingDuckFactory.createRedHeadDuck();
duckCallDuck = countingDuckFactory.createDuckCallDuck();
fakeDuckIsAGoose = countingDuckFactory.createGooseDucky();
}
public void Quack()
{
var iterator = quackers.GetEnumerator();
while (iterator.MoveNext())
{
IQuackable quacker = iterator.Current;
quacker.Quack();
}
}
public void Dispose()
{
duckFactory = null;
mallardDuck = null;
redheadDuck = null;
duckCall = null;
rubberDuck = null;
gooseDuck = null;
flockOfDucks = null;
flockOfMallards = null;
mallardOne = null;
mallardTwo = null;
mallardThree = null;
mallardFour = null;
}
public QuackCounter(IQuackable duck)
{
this._duck = duck;
}
public void addQuackable(IQuackable quackable)
{
listOfQuackables.Add(quackable);
}
public Simulator(IQuackable simDuck)
{
this.simDuck = simDuck;
}
public Simulator()
{
this.simDuck = new DuckCall();
}
public void simulate(IQuackable duck)
{
duck.quack();
}
private static void Simulate(IQuackable duck)
{
duck.Quack();
}
public void SimulateQack(IQuackable duck,int numberOfQuacks)
{
for (int i = 0; i < numberOfQuacks;i++ )
{
duck.quack();
}
}
private string Simulate(IQuackable duck)
{
return duck.Quack();
}
private static void SimulateQuacks(IQuackable redheadDuck, IQuackable duckCallDuck, IQuackable fakeDuckIsAGoose,
IQuackable mallarDuck, IQuackable rubberDuck)
{
var simDuck = new Simulator();
simDuck.SimulateQack(mallarDuck, 1);
simDuck.SimulateQack(rubberDuck, 2);
simDuck.SimulateQack(redheadDuck, 3);
simDuck.SimulateQack(duckCallDuck, 4);
simDuck.SimulateQack(fakeDuckIsAGoose, 5);
}
public DuckBase()
{
flyBehaviour = new FlyWithWings();
quackBehaviour = new SimpleQuack();
}
public void SetQuackBehaviour(IQuackable newQuackBehaviour)
{
quackBehaviour = newQuackBehaviour;
}
public void Add(IQuackable duck)
{
_ducks.Add(duck);
}
private static void CreateDucks(DuckFactoryBase countingDuckFactory, out IQuackable mallarDuck, out IQuackable duckCallDuck,
out IQuackable fakeDuckIsAGoose, out IQuackable rubberDuck,
out IQuackable redheadDuck)
{
mallarDuck = countingDuckFactory.createMallarDuck();
rubberDuck = countingDuckFactory.createRubberDuck();
redheadDuck = countingDuckFactory.createRedHeadDuck();
duckCallDuck = countingDuckFactory.createDuckCallDuck();
fakeDuckIsAGoose = countingDuckFactory.createGooseDucky();
}
void Simulate(IQuackable duck)
{
duck.Quack();
}
public QuakCounter(IQuackable duck)
{
_duck = duck;
QuackCount = 0;
}
