public void Test_demo()
{
{
IImplementation implementationA = new ConcreteImplementationA();
Abstraction abstraction = new Abstraction(implementationA);
abstraction.Operation();
Assert.That(abstraction.GetData() == "ImplementationA");
}
{
IImplementation implementationA = new ConcreteImplementationA();
IImplementation implementationB = new ConcreteImplementationB();
Abstraction abstraction = new Abstraction(implementationB);
abstraction.Operation();
Assert.That(abstraction.GetData() == "ImplementationB");
abstraction = new Abstraction(implementationA);
abstraction.Operation();
Assert.That(abstraction.GetData() == "ImplementationA");
}
}
public void Bridge_Pattern_Test()
{
var abstraction = new Abstraction(new ImplementationA());
Assert.AreEqual("Abstract: A", abstraction.Operation());
abstraction = new ExtendedAbstraction(new ImplementationB());
Assert.AreEqual("Extended Abstract: B", abstraction.Operation());
}
public void Bridge_Test()
{
var abs = new Abstraction();
var implementer = new ImplementerA();
var absRedefined = new RedefinedAbstraction();
abs.Implementer = implementer;
absRedefined.Implementer = implementer;
Assert.AreNotEqual(abs.Operation(), absRedefined.Operation());
}
static void Main(string[] args)
{
//구현과 추상을 분리함으로써 서브클래싱으로 확장하기 편합니다.
//Bridge 패턴을 이용하면 구현을 확장하기에 좋고 추상을 확장하기에도 좋습니다.
//AbstractFactory와 협력하여 복합하는 것이 좋습니다.
var abstraction1 = new Abstraction(new ConcreteImplementorA());
var abstraction2 = new RefinedAbstraction(new ConcreteImplementorB());
abstraction1.Operation();
abstraction2.Operation2();
}
public static void TestBridge()
{
Abstraction abstractionA = new Abstraction(new ConcreteImplementationA());
Abstraction abstractionB = new Abstraction(new ConcreteImplementationB());
Abstraction exAbstractionA = new ExtendedAbstraction(new ConcreteImplementationA());
Abstraction exAbstractionB = new ExtendedAbstraction(new ConcreteImplementationB());
Console.WriteLine(abstractionA.Operation());
Console.WriteLine(abstractionB.Operation());
Console.WriteLine(exAbstractionA.Operation());
Console.WriteLine(exAbstractionB.Operation());
}
public static void Run()
{
Console.WriteLine("IBridge Pattern\n");
//Console.WriteLine(new Abstraction(new ImplementationA()).Operation());
//Console.WriteLine(new Abstraction(new ImplementationB()).Operation());
IBridge implementationA = new ImplementationA();
IBridge implementationB = new ImplementationB();
var abstraction1 = new Abstraction(implementationA);
Console.WriteLine(abstraction1.Operation());
var abstraction2 = new Abstraction(implementationB);
Console.WriteLine(abstraction2.Operation());
Console.WriteLine();
Console.WriteLine("******************************************");
Console.WriteLine();
}
private void rateUsButton_OnClicked(object sender, EventArgs e)
{
Abstraction abstraction = null;
switch (Device.RuntimePlatform)
{
case Device.iOS:
abstraction = new Abstraction(new Platform_iOS());
break;
case Device.Android:
abstraction = new Abstraction(new PlatformAndroid());
break;
}
DisplayAlert("Rate us!", abstraction.Operation(), "OK");
}
// Except for the initialization phase, where an Abstraction object gets
// linked with a specific Implementation object, the client code should
// only depend on the Abstraction class. This way the client code can
// support any abstraction-implementation combination.
public string ClientCode(Abstraction abstraction)
{
return(abstraction.Operation());
}
// Except for the initialization phase, where an Abstraction object gets
// linked with a specific Implementation object, the client code should
// only depend on the Abstraction class. This way the client code can
// support any abstraction-implementation combination.
public string ClientCode(Abstraction abstraction)
{
Console.Write(abstraction.Operation());
return(abstraction.Operation());
}
// Except for the initialization phase, where an Abstraction object gets
// linked with a specific Implementation object, the client code should
// only depend on the Abstraction class. This way the client code can
// support any abstraction-implementation combination.
public void ClientCode(Abstraction abstraction)
{
Console.Write(abstraction.Operation());
}
