public static void Main()
{
var factoryA = new Factory <ProductA>(ProductA.InitializeProduct);
var factoryB = new Factory <ProductB>(ProductB.InitializeProduct);
ProductA prodA = factoryA.CreateProduct();
ProductB prodB = factoryB.CreateProduct();
}
public static ProductA CreateProductA(double price)
{
ProductA productA = new ProductA();
productA.Price = price;
return(productA);
}
public void GetVariableAnnualCost_ProductA_Consumption3500()
{
ProductA productA = new ProductA();
decimal consumption = 3500;
Assert.AreEqual(770M, productA.GetVariableAnnualCost(consumption));
}
public static Product GetInstance(eProduct productType)
{
Product p = null;
switch (productType)
{
case eProduct.A:
{
p = new ProductA();
}
break;
case eProduct.B:
{
p = new ProductB();
}
break;
case eProduct.C:
{
p = new ProductC();
}
break;
default:
{
p = new Product();
}
break;
}
return(p);
}
public void GetTotalAnnualCosts_ProductA_Consumption3500()
{
ProductA productA = new ProductA();
decimal consumption = 3500;
Assert.AreEqual(830M, productA.GetTotalAnnualCosts(consumption));
}
static void Main(string[] args)
{
#region Static Factory Method Pattern
// use static method
ILogger_static_factory logger_static_factory = LoggerFactory_static_factory.Create(LoggerType.DB);
#endregion
#region Simple Factory Pattern
// no using static method
var factory_simple = new LoggerFactory_simple_factory();
var dbLogger_simple = factory_simple.CreateDbLogger();
#endregion
#region Factory Method Pattern
LogFactory logger = new XmlLogFactory();
logger.Log("Log something");
LogFactory logger_s = LogFactory.GetLogger();
logger_s.Log("Log somethinf");
#endregion
#region Abstract Factory Patthern
AbstractFactory factory = new ConcreteFactory1();
ProductA prodA = factory.CreateProductA();
ProductB prodB = factory.CreateProductB();
#endregion
}
public IProduct MakeProduct(Condition condition)
{
IProduct product;
switch (condition)
{
case Condition.CaseA:
product = new ProductA();
// Other product setup code
break;
case Condition.CaseA2:
product = new ProductA();
// Yet other product setup code
break;
case Condition.CaseB:
product = new ProductB();
// Other product setup code
break;
default:
throw new Exception(string.Format("Condition {0} ...", condition));
}
return(product);
}
public override Product Create()
{
var a = new ProductA();
Console.WriteLine("Created Product A");
return(a);
}
public void Test_CalculationModelA(int consumption, int result)
{
ProductA pr = new ProductA();
var resultingConsumption = pr.CalculationModel(consumption);
Assert.AreEqual(result, resultingConsumption);
}
public void ChildrenAndInheritance()
{
var datacontext = new Configuration(Constants.Connectionstring).WithDocuments(typeof(Order), typeof(ProductA), typeof(ProductB)).Create();
datacontext.EnsureNewDatabase();
var order = new Order()
{
Id = Guid.NewGuid()
};
datacontext.Insert(order);
var p1 = new ProductA {
Id = Guid.NewGuid(), Text = "abc", ValueA = "va"
};
datacontext.Insert(p1);
var p2 = new ProductB {
Id = Guid.NewGuid(), Text = "abc", ValueB = "vb"
};
datacontext.Insert(p2);
datacontext.AppendChild(order, p1);
datacontext.AppendChild(order, p2);
var children = datacontext.GetChildren <Order, IProduct>(order);
Assert.AreEqual(2, children.Count);
var children2 = datacontext.GetChildren <Order, Product>(order);
Assert.AreEqual(2, children2.Count);
}
static void Main(string[] args)
{
Console.WriteLine("Please, input the annual electric consumption.");
string strConsumptionPerYear = Console.ReadLine();
int.TryParse(strConsumptionPerYear, out var consuptionPerYear);
ITariffCalculator productA = new ProductA();
ITariffCalculator productB = new ProductB();
TariffCalculateService service = new TariffCalculateService(productA, productB);
var list = service.GetList(consuptionPerYear);
Console.WriteLine("------------------------------------------------------------");
Console.WriteLine("See the two products sorted by annual tariff.");
int count = 0;
list.ForEach(x =>
{
count += 1;
Console.WriteLine($"{count} - {x.Title}: {x.AnnualTariff} euros");
});
Console.ReadKey();
}
public ProductBase Create()
{
ProductA p = new ProductA();
populate(p);
p.z = some_z;
return(p);
}
public override IProduct FactoryMethod()
{
Debug.Log("生产产品A");
ProductA productA = new ProductA();
//TODO...
return(productA);
}
private static int GetTotalPrice(List <Product> products)
{
var finalPrice = 0;
finalPrice += new ProductA <List <Product> >(products.Where(x => x.Id == "A").ToList()).CalculateProductPrice();
finalPrice += new ProductB <List <Product> >(products.Where(x => x.Id == "B").ToList()).CalculateProductPrice();
finalPrice += new ProductCnD <List <Product> >(products.Where(x => x.Id == "C" || x.Id == "D").ToList()).CalculateProductPrice();
return(finalPrice);
}
public void ProductABuilderTest()
{
ProductABuilder builder = new ProductABuilder();
new Director(builder).Action();
ProductA product = builder.GetProduct();
AssertProduct(product, typeof(ProductA));
}
private TariffModel InitializeTariffModel()
{
TariffModel model = new TariffModel();
ProductA productA = new ProductA(productA_Name);
ProductB productB = new ProductB(productB_Name);
model.AddProduct(productA);
model.AddProduct(productB);
return(model);
}
public void CacheGetByNameTest_IfNothingFound()
{
var productA = new ProductA("test productA", 22, 5);
var productB = new ProductB("test productB", 30, 4000, 800);
_sut.InsertProduct(productA);
_sut.InsertProduct(productB);
var item = _sut.GetProductByName("test productC");
Assert.Null(item);
}
public void CacheInsertTest()
{
var productA = new ProductA("test productA", 22, 5);
var productB = new ProductB("test productB", 30, 4000, 800);
_sut.InsertProduct(productA);
_sut.InsertProduct(productB);
var items = _sut.GetAllProducts();
Assert.Equal(2, items.Length);
}
public void ProductATestTotalPrice_Returns_Zero_OnNoProduct()
{
//Arrange
List <Product> products = new List <Product>();
//Assert
var value = new ProductA <List <Product> >(products).CalculateProductPrice();
//Act
value.Equals(0);
}
public void ProductBTestTotalPrice_Returns_NonPromotion_Price()
{
//Arrange
List <Product> products = new List <Product>();
products.Add(new Product("B", 1));
//Assert
var value = new ProductA <List <Product> >(products).CalculateProductPrice();
//Act
value.Equals(30);
}
public void Setup()
{
_pointOfSale = new POS();
_terminal = new Terminal(_pointOfSale);
var productA = new ProductA();
var productB = new ProductB();
var productC = new ProductC();
var productD = new ProductD();
List <Product> products = new List <Product> {
productA, productB, productC, productD
};
foreach (var product in products)
{
Utils.DoSafe(() =>
{
_pointOfSale.AddProduct(product);
});
}
Utils.DoSafe(() =>
{
_terminal.SetPricing(productA.Code, (decimal)1.25d);
});
Utils.DoSafe(() =>
{
_terminal.SetPricing(productA.Code, (decimal)3.00d, 3);
});
Utils.DoSafe(() =>
{
_terminal.SetPricing(productB.Code, (decimal)4.25d);
});
Utils.DoSafe(() =>
{
_terminal.SetPricing(productC.Code, (decimal)1.00d);
});
Utils.DoSafe(() =>
{
_terminal.SetPricing(productC.Code, (decimal)5.00d, 6);
});
Utils.DoSafe(() =>
{
_terminal.SetPricing(productD.Code, (decimal)0.75d);
});
}
public void TestPointOfSale_AddDuplicatedProducts()
{
var productA = new ProductA();
var pointOfSale = new POS();
Assert.DoesNotThrow(() => {
pointOfSale.AddProduct(productA);
});
Assert.Throws <DuplicatedProductException>(() => {
pointOfSale.AddProduct(productA);
});
}
static List <TariffProduct> Comparison(int consumption)
{
List <TariffProduct> comparisonList = new List <TariffProduct>();
Product productA = new ProductA();
Product productB = new ProductB();
TariffProduct tariffProductA = new TariffProduct(productA, consumption);
TariffProduct tariffProductB = new TariffProduct(productB, consumption);
comparisonList.Add(tariffProductA);
comparisonList.Add(tariffProductB);
return(comparisonList.OrderBy(item => item.AnnualCost).ToList());
}
public void TestPointOfSale_InitialiseWithProductList()
{
var productA = new ProductA();
var productB = new ProductB();
var productC = new ProductC();
var productD = new ProductD();
List <Product> products = new List <Product> {
productA, productB, productC, productD
};
Assert.DoesNotThrow(() => {
var pointOfSale = new POS(products);
Assert.IsNotEmpty(products);
Assert.AreEqual(products, pointOfSale.Products);
});
}
private static void Init()
{
var productA = new ProductA();
var productB = new ProductB();
var productC = new ProductC();
var productD = new ProductD();
List <Product> products = new List <Product> {
productA, productB, productC, productD
};
PointOfSale = new POS(products);
Terminal = new Terminal(PointOfSale);
Utils.DoSafe(() =>
{
Terminal.SetPricing(productA.Code, (decimal)1.25d);
});
Utils.DoSafe(() =>
{
Terminal.SetPricing(productA.Code, (decimal)3.00d, 3);
});
Utils.DoSafe(() =>
{
Terminal.SetPricing(productB.Code, (decimal)4.25d);
});
Utils.DoSafe(() =>
{
Terminal.SetPricing(productC.Code, (decimal)1.00d);
});
Utils.DoSafe(() =>
{
Terminal.SetPricing(productC.Code, (decimal)5.00d, 6);
});
Utils.DoSafe(() =>
{
Terminal.SetPricing(productD.Code, (decimal)0.75d);
});
}
public void TestPointOfSale_AddProducts()
{
var productA = new ProductA();
var productB = new ProductB();
var productC = new ProductC();
var productD = new ProductD();
List <Product> products = new List <Product> {
productA, productB, productC, productD
};
var pointOfSale = new POS();
Assert.DoesNotThrow(() => {
foreach (var product in products)
{
pointOfSale.AddProduct(product);
}
Assert.IsNotEmpty(products);
Assert.AreEqual(products, pointOfSale.Products);
});
}
public void Setup()
{
_pointOfSale = new POS();
_terminal = new Terminal(_pointOfSale);
var productA = new ProductA();
var productB = new ProductB();
var productC = new ProductC();
var productD = new ProductD();
List <Product> products = new List <Product> {
productA, productB, productC, productD
};
foreach (var product in products)
{
Utils.DoSafe(() =>
{
_pointOfSale.AddProduct(product);
});
}
}
public string AnotherUsefulFunctionB(ProductA collaborator)
{
var result = collaborator.UsefulFunctionA();
return($"The result of the B2 collaborating with the ({result})");
}
public override void BuildPart1()
{
product = new ProductA();
}
public void Reset()
{
productA = new ProductA();
}
