public void ClientMethod(IAbstractFactory factory)
{
IAbstractProductA productA = factory.CreateProductA();
IAbstractProductB productB = factory.CreateProductB();
Console.WriteLine(productB.GetInfo());
}
public void run(IAbstractFactory factory)
{
IAbstractProductA p1 = factory.CreateProductA();
IAbstractProductB p2 = factory.CreateProductB();
p2.Interact(p1);
}
public void ManufactureSet(IAbstractFactory factory)
{
IAbstractProductA productA = factory.CreateProductA();
IAbstractProductB productB = factory.CreateProductB();
Debug.WriteLine("Created: " + productA.SomeFunction() + ", " + productB.SomeFunction());
Debug.WriteLine("Tested: " + productB.AnotherFunction(productA));
}
public Client(IAbstractFactory factory)
{
productA = factory.CreateProductA();
productB = factory.CreateProductB();
productA.ProductDescription();
productB.ProductDescription();
}
public void ClientMethod(IAbstractFactory factory)
{
IAbstractProductA productA = factory.CreateProductA();
IAbstractProductB productB = factory.CreateProductB();
Console.WriteLine(productB.UsefulFunctionB());
Console.WriteLine(productB.AnotherUsefulFunctionB(productA));
}
public void get_product_A()
{
{
IAbstractProductA prod = GetProduct(factory: new ConcreteFactory1());
Assert.That(prod.GetValue() == ProductTypes.ProductA1);
}
{
IAbstractProductA prod = GetProduct(factory: new ConcreteFactory2());
Assert.That(prod.GetValue() == ProductTypes.ProductA2);
}
IAbstractProductA GetProduct(IAbstractFactory factory) => factory.CreateProductA();
}
public Client(IAbstractFactory factory)
{
_productA = factory.CreateProductA();
_productB = factory.CreateProductB();
}
public void Interact(IAbstractProductA product)
{
Console.WriteLine($"Product set: {product.GetType().Name} and {GetType().Name}");
}
public virtual void Interact(IAbstractProductA a)
{
//--- Interact with 'a'
}
public Tester(IAbstractFactory factory)
{
this.abstractProductA = factory.CreatePorductA();
this.abstractProductB = factory.CreatePorductB();
}
public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
{
var productA = collaborator.UsefulFunctionA();
return($"Eu estou recebendo esse cara => {productA}");
}
public string AnotherUsefulFunctionB(IAbstractProductA productA)
{
return("The result of the B2 collaborating with the " + productA);
}
public Client(IAbstractFactory factory)
{
abstractProductA = factory.CreateProductA();
abstractProductB = factory.CreateProductB();
}
//--- C'tor
public ClientClass(IAbstractFactoryBase factory)
{
abstractProductB = factory.CreateAbstractProductB();
abstractProductA = factory.CreateAbstractProductA();
}
public virtual void Interact(IAbstractProductA a)
{
//--- Interact with 'a'
}
public string func2(IAbstractProductA input)
{
return($"blue B acts with {input.func1()}");
}
//--- C'tor
public ClientClass(IAbstractFactoryBase factory)
{
abstractProductB = factory.CreateAbstractProductB();
abstractProductA = factory.CreateAbstractProductA();
}
/// <summary>
/// Совместная работа различных продуктов.
/// Продукты вполне могут между собой взаимодействовать.
/// При этом фабрика будет гарантировать, что эти продукты будут совместимы,
/// не смотря на то, что в объявлении указывается абстрактный продукт.
/// </summary>
/// <param name="productA"> Первый продукт. </param>
/// <returns> Результат взаимодействия первого и второго продукта. </returns>
public string WorkWithProductA(IAbstractProductA productA)
{
return($"B1 выполнил работу совместно с ({productA.Name})");
}
//变型产品B1只能与变型产品A1正常工作。(不太懂...)
//然而，它接受任何AbstractProductA实例作为参数。
public string AnotherFunctionB(IAbstractProductA productA)
{
var result = productA.FunctionA();
return($"The result of the B1 collaborating with the ({result})");
}
// La variante, Producto B2, solo puede funcionar correctamente con la
// variante, Producto A2. No obstante, acepta cualquier instancia de
// AbstractProductA como argumento.
public string AnorherUsefulFunctionB(IAbstractProductA collaborator)
{
var result = collaborator.UsefulFunctionA();
return($"El resultado del B2 colaborando con el ({result})");
}
public void Interact(IAbstractProductA a)
{
Console.WriteLine(this.GetType().Name + " взаимодействует с " + a.GetType().Name);
}
// The variant, Product B1, is only able to work correctly with the
// variant, Product A1. Nevertheless, it accepts any instance of
// AbstractProductA as an argument.
public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
{
var result = collaborator.AddingFunction(1);
return(Text.WithTheResultFromTheFirstFunction(result));
}
public string AnotherFunction(IAbstractProductA collaborator)
{
return("ConcreteProductB1 collaborates with " + collaborator.SomeFunction());
}
private static void ClientMethod(IAbstractFactory factory)
{
_productA = factory.CreateProductA();
_productB = factory.CreateProductB();
}
public void Interact(IAbstractProductA a)
{
Console.WriteLine(this + " Interacts with " + a);
}
public string AnotherMethodB(IAbstractProductA collaborator)
{
var result = collaborator.MethodA();
return($"The result of the B2 collaborating with the ({result})");
}
public string AnotherUsefulFunctionB(IAbstractProductA collaborator)
{
var result = collaborator.UsefulFunctionA();
return($"The result of the B1 collaborating with the ({result})");
}
public Client(IAbstractFactory factory)
{
this._a = factory.CreateProductA();
this._b = factory.CreateProductB();
}
