public void AddExchange(IMarket m, SecurityExchange ex)
{
m.AddExchange(ex);
}
//Option B, through Visitor pattern
public override void Visit(SecurityExchange ex)
{
Console.WriteLine("Security Exchange " + ex.name + " is visited");
//Visit((Exchange)ex);
}
public void Run()
{
//Market1 mkt = new Market2(); //ok
//Market1 mkt = new Market2(); //ok
//Market3 mkt = new Market2(); //not ok
//IMarket mkt = new Market2(); //ok
//Creational Patterns
//////////////////////////////////////////////
//Factory Methods: Market is defined (number of securities / derivatives) at compilation. (Market1 / Market2 / Market3 can be switch but compisitions of them could not be changed)
//IMarket mktA = CreateMarket(); //Factory Method
//IMarket mktB = Market.ParameterisedCreate(1); //Parameterised Factory Method by static method
//using creator ? = delegation
//Creator c1 = new ParameterisedCreator(); //Parameterised Factory Method using Creator
//IMarket mktC = c1.Create(1);
//Creator c2 = new GenericCreator<Market1>(); //Factory Method using Generic Creator
//IMarket mktD = c2.Create(); //Factory Method
//////////////////////////////////////////////
//How to create a different market (different compositions) at run-time?
//Abstract Factory: To create a family of objects - without specifying the concrete classes
//Provide an interface for creating families of related or dependent objects without specifying their concrete classes
//focuses on building a families of parts (either simple or complex), and returns the part IMMEDIATELY.
//Client assembles the parts into complex object
//AbstractMarketFactory f1 = new SecurityMarketFactory();
//IMarket mktE = f1.CreateMarket(); //parts
//Tradable t1 = f1.CreateTradable("t1"); //parts
//mktE.AddTradable(t1);
//Exchange ex = f1.CreateExchange();
//mktE.AddExchange(ex);
//mktE.Display();
//AbstractMarketFactory f2 = new CFDMarketFactory();
//IMarket mktF = f2.CreateMarket(); //parts
//Tradable t2 = f2.CreateTradable("t2"); //parts
//mktF.AddTradable(t2);
//Exchange ex2 = f2.CreateExchange();
//mktF.AddExchange(ex2);
//mktF.Display();
//////////////////////////////////////////////
//Builder
//the same construction process can create different representations
//Separate the construction of a complex object from its representation so that the same construction process can create different representations
//BUILDER RETURNS THE PRODUCT AS A FINAL STEP
//Change Builder, change representation
//MarketBuilder mktBuilder = new SecurityMarketBuilder();
//mktBuilder.BuildTradable("0005HK"); //same construction process
//IMarket mktG = mktBuilder.GetMarket();
//mktG.Display();
//MarketBuilder mktBuilder = new CFDMarketBuilder();
//mktBuilder.BuildTradable("0005HK"); //same construction process
//IMarket mktG = mktBuilder.GetMarket();
//mktG.Display();
//////////////////////////////////////////////
//Prototype
//Abstract Factory and Builder are used for a pre-set combination of parts
//for multi options x multi options combination => class explosion
//
//each market has 1 tradable and 1 exchange
//tradable: Security or CFD
//exchange: Security Exchange or CFD exchange
//MarketPrototypeFactory f3 = new MarketPrototypeFactory(new Exchanges.SecurityExchange("PrototypeExchange"), new Security("PrototypeTradable"));
//IMarket mktH = f3.CreateMarket();
//Exchange ex3 = f3.CreateExchange("Security Exchange ABC");
//mktH.AddExchange(ex3);
//Tradable t = f3.CreateTradable("Security AAPL");
//mktH.AddTradable(t);
//mktH.Display();
//MarketPrototypeFactory f4 = new MarketPrototypeFactory(new Exchanges.CFDExchange("PrototypeExchange"), new CFD("PrototypeTradable"));
//IMarket mktI = f4.CreateMarket();
//Exchange ex4 = f4.CreateExchange("CFD Exchange ABC");
//mktI.AddExchange(ex4);
//Tradable t = f4.CreateTradable("CFD AAPL");
//mktI.AddTradable(t);
//mktI.Display();
//MarketPrototypeFactory f5 = new MarketPrototypeFactory(new Exchanges.FuturesExchange("PrototypeExchange"), new Futures("PrototypeTradable", "", 0, 0));
//IMarket mktJ = f5.CreateMarket();
//Exchange ex5 = f5.CreateExchange("Futures Exchange ABC");
//mktJ.AddExchange(ex5);
//Tradable t5 = f5.CreateTradable("Futures AAPL");
//mktJ.AddTradable(t5);
//mktJ.Display();
//////////////////////////////////////////////
//Singleton
//Singleton.Logger logger = Singleton.Logger.Instance();
//logger.Log(logger.GetHashCode().ToString());
//Singleton.Logger logger2 = Singleton.Logger.Instance();
//logger2.Log(logger2.GetHashCode().ToString());
//Console.WriteLine(logger.Equals(logger2));
//Singleton.Logger logger3 = Singleton.DerivedLogger.Instance();
//logger.Log(logger3.GetHashCode().ToString());
//Singleton.Logger logger4 = Singleton.DerivedLogger.Instance();
//logger2.Log(logger4.GetHashCode().ToString());
//Console.WriteLine(logger3.Equals(logger4));
/////////////////////////////////////////////////////////////////////////////////////////
//Structual Patterns
//Adapter
//also known as Wrapper
//client uses new system and reuse old system codes
//Convert the interface of a class into another interface clients expect.
//Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces
//by class adapter or object adapter
//class adapter
//INewMarket mkt = new ClassAdapter_NewMarket();
//mkt.AddTradable(new Security("class adapter"));
//mkt.Display();
//Market test = mkt as Market;
//if (test != null)
//{
// test.OldMethod(); //interfaces of old system are exposed to new system => problematic
//}
//object adapter
//INewMarket mkt2 = new ObjectAdapter_NewMarket();
////interfaces of old system do not expose
//mkt2.AddTradable(new Security("object adapter"));
//mkt2.Display();
//////////////////////////////////////////////
//Builder
//segregate implememtation by delegation to implementation class
//FlexibleMarket mkt = new FlexibleMarket(new SecurityMarketImplementation());
//mkt.Create();
//mkt.AddTradable(new Security("test2"));
//mkt.AddExchange(new Exchanges.SecurityExchange("1"));
//mkt.Display();
//////////////////////////////////////////////
//Composite Pattern
//Compose objects into tree structures to represent part-whole hierarchies.
//Composite let clients treat individual objects and compositions of objects uniformly
//Strategy is a tradable and Strategy has tradable(s)
//Strategy s = new Strategy("Calendar Spread");
//Futures f1 = new Futures("ABCF7", "ABC", 2017, 1);
//f1.price = 1;
//Futures f2 = new Futures("ABCG7", "ABC", 2017, 2);
//f2.price = 2;
//s.AddTradable(f1);
//s.AddTradable(f2);
//Console.WriteLine("strategy price s = " + s.Price());
////recurrsive
//Strategy s2 = new Strategy("new strategy");
//s2.AddTradable(s);
//Futures f3 = new Futures("ABCH7", "ABC", 2017, 3);
//f3.price = 4;
//s2.AddTradable(f3);
//Console.WriteLine("strategy price s2 = " + s2.Price());
//////////////////////////////////////////////
//Decorator
//Also known as Wrapper (vs Adaptor)
//Class inheritence approach vs object delegation approach
//Class inheritence approach: combinational problem, class explosion
//Object delegation approach is better
//Attach additional responsibilities to an object dynamically.
//Decorators provide a flexible alternative to subclassing for extending functionality
//Stream is a decorator
//FileStream, CryptoStream has-a Stream and is-a Stream.
//Composite Pattern?
//infinite recursive to work on _Next Stream
//flexibible number of layers / number of stream operatons
//Decorator d = new Decorator();
//d.Write();
//string output = d.Read();
//Console.WriteLine(output);
//////////////////////////////////////////////
//Visitor Pattern
Exchange exch = new SecurityExchange("HKEX");
Visitor v1 = new Visitor_Trade();
exch.Accept(v1);
Visitor v2 = new Visitor_Settle();
exch.Accept(v2);
//Exchange exch2 = new CFDExchange("CFD EX");
//exch2.Accept(v1);
//exch2.Accept(v2);
//////////////////////////////////////////////
//////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
//Behaviour Patterns
}
//Option B, through Visitor pattern
public virtual void Visit(SecurityExchange ex)
{
}
