static void Main(string[] args)
{
// these statements are here so that we can generate
// results that display US currency values even though
// the locale of our machines is set to the UK
System.Globalization.CultureInfo ci = new System.Globalization.CultureInfo("en-US");
System.Threading.Thread.CurrentThread.CurrentCulture = ci;
System.Threading.Thread.CurrentThread.CurrentUICulture = ci;
IKernel ninjectKernel = new StandardKernel();
//ninjectKernel.Bind<IValueCalculator>().To(typeof(LinqValueCalculator));
//ninjectKernel.Bind<IDiscountHelper>().To(typeof(DefaultDiscountHelper));
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
ninjectKernel.Bind <IDiscountHelper>().To <DefaultDiscountHelper>();
// get the interface implementation
IValueCalculator calcImpl = ninjectKernel.Get <IValueCalculator>();
// create the instance of ShoppingCart and inject the dependency
ShoppingCart cart = new ShoppingCart(calcImpl);
// perform the calculation and write out the result
Console.WriteLine("Total: {0:c}", cart.CalculateStockValue());
}
public HomeController(IValueCalculator calc)
{
_calc = calc;
products.Add(new Product()
{
Name = "Tonys Kayak", Price = 10
});
products.Add(new Product()
{
Name = "Tonys Snooker Table", Price = 12
});
products.Add(new Product()
{
Name = "Tonys Pigeon Hole", Price = 13
});
products.Add(new Product()
{
Name = "Tonys Cricket bat", Price = 14
});
products.Add(new Product()
{
Name = "Tonys Basket ball", Price = 15
});
products.Add(new Product()
{
Name = "Tonys Batminton bat", Price = 16
});
}
/// <summary>
/// Creates the filter builder.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="field">The field.</param>
/// <param name="valueCalculator">The value calculator.</param>
/// <returns>IFieldFilterBuilder.</returns>
/// <exception cref="System.ArgumentException"></exception>
public IFieldFilterBuilder CreateFilterBuilder(string processName, SynchronizationField field, IValueCalculator valueCalculator)
{
if (field == null)
return null;
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
var prop = editableRootType.GetPropertyByName(field.SystemName);
if (prop == null)
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", field.Name));
var crAttr = prop.GetCustomAttributes(typeof(CrossRefFieldAttribute), false).FirstOrDefault();
if (crAttr != null)
{
var crBuilder = new CrossReferenceFieldFilterBuilder();
Ioc.SatisfyImportsOnce(crBuilder);
crBuilder.Init(processName, field, valueCalculator);
return crBuilder;
}
var simpleBuilder = new SimpleFieldFilterBuilder();
Ioc.SatisfyImportsOnce(simpleBuilder);
simpleBuilder.Init(processName, field, valueCalculator);
return simpleBuilder;
}
/// <summary>
/// Initializes the specified process name.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="field">The field.</param>
/// <param name="valueCalculator">The value calculator.</param>
public void Init(string processName, SynchronizationField field, IValueCalculator valueCalculator)
{
if (field == null)
return;
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
_field = field;
_property = editableRootType.GetPropertyByName(field.SystemName);
if (_property == null)
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", field.Name));
var crAttr = (CrossRefFieldAttribute)_property.GetCustomAttributes(typeof(CrossRefFieldAttribute), false).FirstOrDefault();
if (crAttr == null)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a cross reference.", field.Name));
_allowMultiple = crAttr.AllowMultiple;
_referencedProcess = crAttr.ReferenceTableName;
foreach (var keyField in field.KeyFields)
{
var builder = FilterBuilderFactory.CreateFilterBuilder(_referencedProcess, keyField, valueCalculator);
_filterBuilders.Add(builder);
}
if (_filterBuilders.Count == 0)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "No key fields found for cross reference field \"{0}\".", field.Name));
}
/// <summary>
/// Initializes the specified process name.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="field">The field.</param>
/// <param name="valueCalculator">The value calculator.</param>
/// <exception cref="System.InvalidOperationException">States not supported.</exception>
public void Init(string processName, SynchronizationField field, IValueCalculator valueCalculator)
{
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
if (!typeof(ISupportStates).IsAssignableFrom(editableRootType))
throw new InvalidOperationException("States not supported.");
_field = field;
_valueCalculator = valueCalculator;
}
public ShoppingCard(IValueCalculator valueCalc, IDiscount discount)
{
if (valueCalc == null || discount == null)
{
throw new ArgumentNullException("Not all of arguments were set.");
}
this.valueCalc = valueCalc;
this.discount = discount;
}
/// <summary>
/// Initializes a new instance of the <see cref="FieldSetter"/> class.
/// </summary>
/// <param name="fieldInfo">
/// The field info.
/// </param>
/// <param name="valueCalculator">
/// The value calculator.
/// </param>
public FieldSetter(FieldInfo fieldInfo, IValueCalculator valueCalculator)
{
if (fieldInfo == null)
throw new ArgumentNullException("fieldInfo");
if (valueCalculator == null)
throw new ArgumentNullException("valueCalculator");
_field = fieldInfo;
_valueCalculator = valueCalculator;
}
/// <summary>
/// Initializes a new instance of the <see cref="PropertySetter"/> class.
/// </summary>
/// <param name="propertyInfo">
/// The property info.
/// </param>
/// <param name="valueCalculator">
/// The value calculator.
/// </param>
public PropertySetter(PropertyInfo propertyInfo, IValueCalculator valueCalculator)
{
if (propertyInfo == null)
throw new ArgumentNullException("propertyInfo");
if (valueCalculator == null)
throw new ArgumentNullException("valueCalculator");
_property = propertyInfo;
_valueCalculator = valueCalculator;
}
public ShoppingCart(IValueCalculator calcParam)
{
calculator = calcParam;
products = new[] {
new Product(){Name="Kayak", Price=275M},
new Product() { Name = "Lifejacket", Price = 48.95M},
new Product() { Name = "Soccer ball", Price = 19.50M},
new Product() { Name = "Stadium", Price = 79500M}
};
}
/// <summary>
/// Initializes a new instance of the <see cref="ArrayElementSetter"/> class.
/// </summary>
/// <param name="index">
/// The index.
/// </param>
/// <param name="valueCalculator">
/// The value calculator.
/// </param>
public ArrayElementSetter(int index, IValueCalculator valueCalculator)
{
if (index < 0)
throw new ArgumentOutOfRangeException("index", @"Non-negative number required.");
if (valueCalculator == null)
throw new ArgumentNullException("valueCalculator");
_index = index;
_valueCalculator = valueCalculator;
}
public ActionResult Index()
{
IKernel ninjectKernel = new StandardKernel(); ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
IValueCalculator calc = ninjectKernel.Get <IValueCalculator>();
ShoppingCart cart = new ShoppingCart(calc)
{
Products = products
};
decimal totalValue = cart.CalculateProductTotal();
return(View(totalValue));
}
/// <summary>
/// Initializes a new instance of the <see cref="ArrayValueCalculator"/> class.
/// </summary>
/// <param name="elementType">
/// The element type.
/// </param>
/// <param name="valueExpression">
/// The value expression.
/// </param>
/// <param name="elementCalculator">
/// The element calculator.
/// </param>
/// <param name="typeConverter">
/// The type converter.
/// </param>
public ArrayValueCalculator(Type elementType, MappingExpression valueExpression, IValueCalculator elementCalculator, ITypeConverter typeConverter)
{
if (elementType == null)
throw new ArgumentNullException("elementType");
if (typeConverter == null)
throw new ArgumentNullException("typeConverter");
_typeConverter = typeConverter;
_elementType = elementType;
_valueExpression = valueExpression;
_elementCalculator = elementCalculator;
}
static void Main(string[] args)
{
IKernel ninjectKernel = new StandardKernel();
ninjectKernel.Bind <IValueCalculator>().To <ValueCalculator>();
ninjectKernel.Bind <IDiscountHelper>().To <DiscountHelp>();
IValueCalculator iva = ninjectKernel.Get <IValueCalculator>();
ShopCart cart = new ShopCart(iva);
decimal a = cart.CalculateStockValue();
Console.Write(a);
Console.Read();
}
public void SetUp()
{
_discountRepositoryMock = new Mock <IDiscountRepository>();
_identityProviderMock = new Mock <IIdentityProvider>();
_identityProviderMock.Setup(x => x.Next())
.Returns(Guid.NewGuid());
_valueCalculatorMock = new Mock <IValueCalculator>();
_valueCalculatorMock.Setup(x => x.CalculateDiscount(It.IsAny <decimal>(), It.IsAny <Discount>()))
.Returns <decimal, Discount>(CalculateDiscount);
_orderRepositoryMock = new Mock <IOrderRepository>();
_discountRepositoryMock = new Mock <IDiscountRepository>();
_valueCalculator = new ValueCalculator();
_sut = new PlaceOrderHandler(_discountRepositoryMock.Object, _orderRepositoryMock.Object, _valueCalculator);
}
public ActionResult DI()
{
IKernel ninjectKernel = new StandardKernel();
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
ninjectKernel.Bind <IDiscountHelper>().To <DefaultDiscountHelper>().WithConstructorArgument("discountParam", 0M);
IValueCalculator calc = ninjectKernel.Get <IValueCalculator>();
ShoppingCart cart = new ShoppingCart(calc)
{
Products = products
};
decimal totalValue = cart.CalculateProductTotal();
return(View(totalValue));
}
public void FirstInit()
{
// 创建Ninject内核实例
IKernel ninjectKernel = new StandardKernel();
//绑定接口到实现了该接口的类
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
// 获得实现接口的对象实例
IValueCalculator calcImpl = ninjectKernel.Get <IValueCalculator>();
//// 创建ShoppingCart实例并注入依赖
ShoppingCart2 cart = new ShoppingCart2(calcImpl);
//// 计算商品总价钱并输出结果
Console.WriteLine("Total: {0:c}", cart.CalculateStockValue());
}
// GET: Home
public ActionResult Index()
{
IKernel ninjectKernel = new StandardKernel();
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
ninjectKernel.Bind <IDiscountHelper>().To <DefaultDiscountHelper>().WithPropertyValue("DiscountSize", 50m);
ninjectKernel.Bind <IDiscountHelper>().To <FlexibleDiscountHelper>().WhenInjectedInto <LinqValueCalculator>();
IValueCalculator calc = ninjectKernel.Get <IValueCalculator>();
ShoppingCart cart = new ShoppingCart(calc)
{
Products = products
};
decimal totalValue = cart.CalculateProductTotal();
return(View(totalValue));
}
//构造函数，参数为实现了IEmailSender接口的类的实例
public ShoppingCart(IValueCalculator calcParam)
{
calculator = calcParam;
products = new Product[] {
new Product {
Name = "西瓜", Category = "水果", Price = 2.3M
},
new Product {
Name = "苹果", Category = "水果", Price = 4.9M
},
new Product {
Name = "空心菜", Category = "蔬菜", Price = 2.2M
},
new Product {
Name = "地瓜", Category = "蔬菜", Price = 1.9M
}
};
}
// GET: Default
public ActionResult Index()
{
//First stage:create the instance of the Ninject，that is the kernel object which is used to resolve the dependancy and creage a new object.
IKernel ninjectKernel = new StandardKernel();
//Second stage:configure the kernel of Ninject in order to indecate which class should be used to instantiate the interface
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
//Third stage:create object of the interface via the Get method
IValueCalculator calc = ninjectKernel.Get <IValueCalculator>();
//IValueCalculator calc = new LinqValueCalculator();
ShoppingCart cart = new ShoppingCart(calc);
cart.Products = products;
decimal totalValue = cart.CalculateProductTotal();
return(View(totalValue));
}
/// <summary>
/// Initializes the specified process name.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="field">The field.</param>
/// <param name="valueCalculator">The value calculator.</param>
/// <exception cref="System.ArgumentException"></exception>
/// <exception cref="System.InvalidOperationException"></exception>
public void Init(string processName, SynchronizationField field, IValueCalculator valueCalculator)
{
if (field == null)
return;
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
_property = editableRootType.GetPropertyByName(field.SystemName);
if (_property == null)
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", field.Name));
if (!_property.CanWrite)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not writeable.", field.Name));
_field = field;
_valueCalculator = valueCalculator;
}
/// <summary>
/// Initializes the specified process name.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="field">The field.</param>
/// <param name="valueCalculator">The value calculator.</param>
/// <exception cref="System.InvalidOperationException">
/// Versioning not supported.
/// or
/// No key fields found for version master.
/// </exception>
public void Init(string processName, SynchronizationField field, IValueCalculator valueCalculator)
{
if (field == null)
return;
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
if (!typeof(ISupportVersioning).IsAssignableFrom(editableRootType))
throw new InvalidOperationException("Versioning not supported.");
foreach (var keyField in field.KeyFields)
{
var builder = FilterBuilderFactory.CreateFilterBuilder(processName, keyField, valueCalculator);
_filterBuilders.Add(builder);
}
if (_filterBuilders.Count == 0)
throw new InvalidOperationException("No key fields found for version master.");
}
public void ZhiDingZhiBangDing()
{
IKernel ninjectKernel = new StandardKernel();
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
//如果要给多个属性赋值，则可以在Bind和To方式后添加多个WithPropertyValue(< 属性名 >,< 属性值 >)方法。
//ninjectKernel.Bind<IDiscountHelper>()
// .To<DefaultDiscountHelper>().WithPropertyValue("DiscountSize", 5M);
ninjectKernel.Bind <IDiscountHelper>()
.To <DefaultDiscountHelper>().WithConstructorArgument("discountParam", 5M);
IValueCalculator calcImpl = ninjectKernel.Get <IValueCalculator>();
ShoppingCart2 cart = new ShoppingCart2(calcImpl);
Console.WriteLine("Total: {0:c}", cart.CalculateStockValue());
Console.ReadKey();
}
/// <summary>
/// Initializes the specified process name.
/// </summary>
/// <param name="processName">Name of the process.</param>
/// <param name="field">The field.</param>
/// <param name="valueCalculator">The value calculator.</param>
public void Init(string processName, SynchronizationField field, IValueCalculator valueCalculator)
{
if (field == null)
return;
var editableRootType = DynamicTypeManager.GetEditableRootType(processName);
_property = editableRootType.GetPropertyByName(field.SystemName);
if (_property == null)
throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" not found.", field.Name));
var fileAttr = _property.GetCustomAttributes(typeof(FileProcessAttribute), false).FirstOrDefault();
if (fileAttr == null)
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Field \"{0}\" is not a file.", field.Name));
_field = field;
_valueCalculator = valueCalculator;
}
public void YiBanZhiDing()
{
// 创建Ninject内核实例
IKernel ninjectKernel = new StandardKernel();
IValueCalculator calcImpl2 = new LinqValueCalculator();
ShoppingCart2 cart2 = new ShoppingCart2(calcImpl2);
Console.WriteLine("Total: {0:c}", cart2.CalculateStockValue());
ninjectKernel.Bind <IValueCalculator>().To <LinqValueCalculator>();
ninjectKernel.Bind <IDiscountHelper>().To <DefaultDiscountHelper>();
IValueCalculator calcImpl3 = ninjectKernel.Get <IValueCalculator>();
ShoppingCart2 cart3 = new ShoppingCart2(calcImpl3);
Console.WriteLine("Total: {0:c}", cart3.CalculateStockValue());
//Console.WriteLine("Total: {0:c}", cart3.GetDiscount());
//Console.WriteLine() ;
}
/// <summary>
/// Initializes a new instance of the <see cref="SoapHeaderAttributesCalculator"/> class.
/// </summary>
/// <param name="name">
/// The header name.
/// </param>
/// <param name="xmlNamespace">
/// The header namespace.
/// </param>
/// <param name="actorCalculator">
/// The actor calculator.
/// </param>
/// <param name="mustUnderstandCalculator">
/// The must understand calculator.
/// </param>
/// <param name="relayCalculator">
/// The relay calculator.
/// </param>
/// <param name="typeConverter">
/// The type converter.
/// </param>
public SoapHeaderAttributesCalculator(
string name,
string xmlNamespace,
IValueCalculator actorCalculator,
IValueCalculator mustUnderstandCalculator,
IValueCalculator relayCalculator,
ITypeConverter typeConverter)
{
if (string.IsNullOrEmpty(name))
throw new ArgumentException(@"Header name cannot be null or empty.", "name");
if (typeConverter == null)
throw new ArgumentNullException("typeConverter");
Name = name;
XmlNamespace = xmlNamespace;
ActorCalculator = actorCalculator;
MustUnderstandCalculator = mustUnderstandCalculator;
RelayCalculator = relayCalculator;
TypeConverter = typeConverter;
}
public ShoppingCart(IValueCalculator calcParam)
{
calculator = calcParam;
products = new[] {
new Product()
{
Name = "Kayak", Price = 275M
},
new Product()
{
Name = "Lifejacket", Price = 48.95M
},
new Product()
{
Name = "Soccer ball", Price = 19.50M
},
new Product()
{
Name = "Stadium", Price = 79500M
}
};
}
public LimitShoppingCart(IValueCalculator calcParam)
: base(calcParam)
{ }
/// <summary>
/// Initializes a new instance of the <see cref="IntegrationServiceMethod"/> class.
/// </summary>
/// <param name="processName">
/// The process name.
/// </param>
/// <param name="fieldMappings">
/// The field mappings.
/// </param>
/// <param name="resultCalculator">
/// The result calculator.
/// </param>
/// <param name="dynamicTypeManager">
/// The dynamic type manager.
/// </param>
/// <param name="applicationContext">
/// The application context.
/// </param>
/// <param name="runtimeDatabase">
/// The runtime database.
/// </param>
/// <param name="editableRootDataContextFactory">
/// The editable root data context factory.
/// </param>
/// <param name="logger">
/// The logger.
/// </param>
public IntegrationServiceMethod(
string processName,
IEnumerable<IProcessFieldMapping> fieldMappings,
IValueCalculator resultCalculator,
IDynamicTypeManager dynamicTypeManager,
IApplicationContext applicationContext,
IRuntimeDatabase runtimeDatabase,
IEditableRootDataContextFactory editableRootDataContextFactory,
ILogger logger)
{
if (string.IsNullOrEmpty(processName))
throw new ArgumentException(@"The process name cannot be null or empty.", "processName");
if (fieldMappings == null)
throw new ArgumentNullException("fieldMappings");
if (dynamicTypeManager == null)
throw new ArgumentNullException("dynamicTypeManager");
if (applicationContext == null)
throw new ArgumentNullException("applicationContext");
if (runtimeDatabase == null)
throw new ArgumentNullException("runtimeDatabase");
if (editableRootDataContextFactory == null)
throw new ArgumentNullException("editableRootDataContextFactory");
if (logger == null)
throw new ArgumentNullException("logger");
ProcessName = processName;
DynamicTypeManager = dynamicTypeManager;
ApplicationContext = applicationContext;
RuntimeDatabase = runtimeDatabase;
EditableRootDataContextFactory = editableRootDataContextFactory;
Logger = logger;
foreach (var fieldMapping in fieldMappings)
{
FieldMappings.Add(fieldMapping);
if (fieldMapping.IsKey)
KeyMappings.Add(fieldMapping);
}
ResultCalculator = resultCalculator;
}
//构造函数，参数为实现了IValueCalculator接口的类的实例
public ShoppingCart(IValueCalculator calcParam)
{
calculator = calcParam;
}
// in Output window when debugging you can see the counter = 2 instances
public HomeController(IValueCalculator calcParam, IValueCalculator calcParam2, IValueCalculatorDiscount calcDiscountParam) // constructor injection
{
calc = calcParam;
calcDiscount = calcDiscountParam;
}
public ShoppingCart(IValueCalculator calculator)
{
this.calculator = calculator;
}
public ShoppingCart(IValueCalculator calcParm)
{
_calc = calcParm;
}
public HomeController(IValueCalculator calculator)
{
this.calculator = calculator;
}
public HomeController(IValueCalculator calcParam)
{
this.calc = calcParam;
}
public ShoppingCart(/*LinqValueCalculator*/ IValueCalculator calcParam)
{
calc = calcParam;
}
public PlaceOrderHandler(IDiscountRepository discountRepository, IOrderRepository orderRepository, IValueCalculator valueCalculator)
{
_discountRepository = discountRepository;
_orderRepository = orderRepository;
_valueCalculator = valueCalculator;
}
public EssentialHomeController(IValueCalculator calcParam)
{
calc = calcParam;
}
public Basket(IVoucherValidator voucherValidator, IValueCalculator valueCalculator)
{
_voucherValidator = voucherValidator ?? throw new ArgumentNullException(nameof(voucherValidator));
_valueCalculator = valueCalculator ?? throw new ArgumentNullException(nameof(valueCalculator));
}
public HomeController(IValueCalculator calculator)
{
this.calculator = calculator;
}
public ShoppingCart(IValueCalculator calcParap)
{
calc = calcParap;
}
public ShoppingCart(IValueCalculator calc) {
this.calc = calc;
}
public ShoppingCart(IValueCalculator calcParam)
{
this.calc = calcParam;
}
public HomeController(IValueCalculator calcParam, IValueCalculator calc2)
{
calc = calcParam;
}
public HomeController(IValueCalculator calc)
{
this.calc = calc;
}
public LimitShoppingCart(IValueCalculator calcParam)
: base(calcParam)
{
// nothing to do here
}
public HomeController(IValueCalculator calcParam, IValueCalculator calcPram2)
{
// Добавление интерфейса с Ninject
calc = calcParam;
}
public HomeController(IValueCalculator clc1, ITestCount its)
{
calc = clc1;
itst = its;
}
public TestController(IValueCalculator calculator)
{
calc = calculator ;
}
public HomeController(IValueCalculator calcParam)
{
calc = calcParam;
} // constructor accepting an IValueCalculator type
//构造函数，参数为实现了IValueCalculator接口的类的实例
public ShoppingCart(IValueCalculator calcParam)
{
calculator = calcParam;
}
public LimitShoppingCart(IValueCalculator calcParam)
: base(calcParam)
{
// nothing to do here
}
public HomeController(IValueCalculator CalCparam)
{
Calc = CalCparam;
}
public EssentialToolsController(IValueCalculator calcParam, IValueCalculator calc2)
{
calc = calcParam;
}
public HomeController(IValueCalculator calcParam)
{
calc = calcParam;
}
public HomeController(IValueCalculator calculator, IShoppingCart cart, IValueCalculator calc)
{
this.calculator = calculator;
this.cart = cart;
cart.Products = this.products;
}
public ShoppingCart(IValueCalculator calc)
{
this.calc = calc;
}
public ShoppingCart(IValueCalculator calculator)
{
this.calculator = calculator;
}
