DDD领域模型实现依赖注入（六）

添加下订单的值对象：

public partial class CustomerInfo:ValueObject
{
/// <summary>
/// 下订单的值对象
/// </summary>
/// <param name="customer">Customer值对象</param>
/// <param name="address">Address值对象</param>
public CustomerInfo(Customer customer,Address address)
{
this.Id = base.Id;
this.Name = customer.Name;
this.Mobile = customer.Mobile;
this.State = address.State;
this.City = address.City;
this.Street = address.Street;
}
}

产品值对象：

public partial class CustomerInfo:ValueObject
{
public CustomerInfo(Customer customer,Address address)
{
this.Id = base.Id;
this.Name = customer.Name;
this.Mobile = customer.Mobile;
this.State = address.State;
this.City = address.City;
this.Street = address.Street;
}
}

订单项的实体：

public partial class OrderItem:Entity
{
public OrderItem(Product product,int amount)
{
this.Id = base.Id;
this.Amount = amount;
this.LineTotal = product.UnitPrice * Amount;
}
}

销售订单的聚合根：

public partial class SalesOrder:AggreateRoot
{
//定义仓储的接口
private IRepository<SalesOrder> irepository;
//定义构造函数
public SalesOrder(IRepository<SalesOrder> irepository)
{
this.irepository = irepository;
}
/// <summary>
/// 创建订单
/// </summary>
/// <param name="products">产品列表</param>
/// <param name="customer">客户列表</param>
/// <param name="amounts">产品数量</param>
/// <param name="state">地址</param>
/// <param name="city"></param>
/// <param name="street"></param>
public void CreateOrder(List<Product> products,Customer customer,List<int> amounts,
string state,string city,string street)
{
SalesOrder salesorder = new SalesOrder();
//指定属性
salesorder.Id = base.Id;
//下单的时间
salesorder.DateTime = DateTime.Now;
//设置值对象
salesorder.CustomerInfo =
new CustomerInfo(customer, new Address(state, city, street));

//循环取出产品列表
for(int i=0;i<products.Count;i++)
{
var orderitem = new OrderItem(products[i], amounts[i]);
orderitem.ProductInfo = new ProductInfo(products[i]);
salesorder.OrderItem.Add(orderitem);
salesorder.TotalPrice = salesorder.TotalPrice + orderitem.LineTotal;
}
// 仓储
irepository.Create(salesorder);
}
}

跨聚合的事务处理一般通过领域服务来做。（DomainService）主要是协调的作用

public class SalesOrderService:ISalesOrderService
{
private IRepository<Product> irepositoryproduct;
private IRepository<Customer> irepositorycustomer;
private IRepository<SalesOrder> irepositorysalesorder;

[InjectionConstructor]
public SalesOrderService(IRepository<Product> irepositoryproduct
,IRepository<Customer> irepositorycustomer
,IRepository<SalesOrder> irepositorysalesorder)
{
this.irepositoryproduct = irepositoryproduct;
this.irepositorycustomer = irepositorycustomer;
this.irepositorysalesorder = irepositorysalesorder;
}
/// <summary>
/// 领域服务面向界面的内容
/// </summary>
/// <param name="productnames">产品名字列表</param>
/// <param name="amounts">产品名字对应的数量</param>
/// <param name="customername">客户名</param>
/// <param name="state">地址</param>
/// <param name="city"></param>
/// <param name="street"></param>
public void CreateSalesOrder(List<string> productnames,List<int> amounts,
string customername,string state,string city,string street)
{
//生成Product列表对象
var listproduct = new List<Product>();
//得到具体的产品减少库存
for(int i=0;i<productnames.Count;i++)
{
var product =
new Product(irepositoryproduct).GetProducyByName(productnames[i]);
//减少库存的方法
product.ModifyCount(product, amounts[i], irepositoryproduct);

listproduct.Add(product);
}
var customer = new Customer(irepositorycustomer).GetCustomerByName(customername);
var salesorder = new SalesOrder(irepositorysalesorder);

salesorder.CreateOrder(listproduct, customer, amounts, state, city, street);
}
}

添加界面和核心业务层保护的作用：（DDD.Application）

添加引用：



添加基础服务实现的机制：（DDD.Infrastructure）----通过Unity实现

public class ServiecLocator
{
//定义Unity的容器
private readonly IUnityContainer container;

//构造函数
public ServiecLocator()
{
//定义配置节点
var section = (UnityConfigurationSection)ConfigurationManager.GetSection("unity");
container = new UnityContainer();
//指定使用节点的信息
section.Configure(container);
}
//静态属性
public static ServiecLocator Instance
{
get { return new ServiecLocator(); }
}
//得到接口对应的具体服务
public T GetService<T>()
{
//解析泛型
return container.Resolve<T>();
}
//返回具体实现类的Object
public T GetService<T>(object overridedarguments)
{
var overrides = GetParameterOverride(overridedarguments);
return container.Resolve<T>(overrides.ToArray());
}

public object GetService(Type serviectype)
{
return container.Resolve(serviectype);
}

public object GetService(Type servicetype,object overridedarguments)
{
var overrides = GetParameterOverride(overridedarguments);
return container.Resolve(servicetype,overrides.ToArray());
}
//定义构造函数参数的信息
private IEnumerable<ParameterOverride> GetParameterOverride(object overridearguments)
{
var overrides = new List<ParameterOverride>();
var argumenttype = overridearguments.GetType();
argumenttype.GetProperties(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)
.ToList()
.ForEach(property =>
{
var propertyvalue = property.GetValue(overridearguments, null);
var propertyname = property.Name;
overrides.Add(new ParameterOverride(propertyname, propertyvalue));

});

return overrides;
}
}

创建订单定义的接口：

//创建订单定义的接口
public interface ISalesOrderService
{
void CreateSalesOrder(List<string> productnames, List<int> amounts,
string customername, string state, string city, string street);
}

Unity的替换：

public class SalesOrderAppService
{
//EFRepositoryContext context = new EFRepositoryContext();
IRepositoryContext context = ServiecLocator.Instance.GetService(typeof(IRepositoryContext))
as IRepositoryContext;
//定义接口
IRepository<Product> productrepository = ServiecLocator.Instance.GetService(typeof(IRepository<Product>))
as IRepository<Product>;
IRepository<Customer> customerrepository = ServiecLocator.Instance.GetService(typeof(IRepository<Customer>))
as IRepository<Customer>;
IRepository<SalesOrder> salesorderrepository = ServiecLocator.Instance.GetService(typeof(IRepository<SalesOrder>))
as IRepository<SalesOrder>;

ISalesOrderService salesorderservice = ServiecLocator.Instance.GetService(typeof(ISalesOrderService)
, new ParameterOverrides { { "irepositoryproduct", "productrepository" }
, {"irepositorycustomer","customerrepository" },
{ "irepositorysalesorder","salesorderrepository" } })
as ISalesOrderService;

public void CreateSalesOrder(List<string> productnames,
List<int> amounts,string customername,string state,string city,string street)
{
//var salesorderservice = new SalesOrderService
//    (new EFRepository<Product>(), new EFRepository<Customer>()
//    , new EFRepository<SalesOrder>());
salesorderservice.CreateSalesOrder(productnames, amounts, customername,
state, city, street);

context.Commit();
}
}

产品的替换：

IRepositoryContext context = ServiecLocator.Instance.GetService(typeof(IRepositoryContext))
as IRepositoryContext;
Product product = new Product(new ProductRepository());

配置文件：（指定unity节点）

<section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>

具体映射机制：

<unity xmlns="http://schemas.microsoft.com/practices/2010/unity">
<sectionExtension type="Microsoft.Practices.Unity.InterceptionExtension.Configuration.InterceptionConfigurationExtension,Microsoft.Practices.Unity.Interception.Configuration" />
<container>
<extension type="Interception"/>
<!--类型-->
<register type="DDD.Domain.DomainService.ISalesOrderService,DDD.Domain" mapTo="DDD.Domain.DomainService.SalesOrderService,DDD.Domain">
</register>
<!--上下文-->
<register type="DDD.Domain.Repository.IRepositoryContext,DDD.Domain" mapTo="DDD.Repository.EFRepositoryContext,DDD.Repository">
</register>
<!--仓储 `泛型的写法 -->
<register type="DDD.Domain.Repository.IRepository`1,DDD.Domain" mapTo="DDD.Repository.EFRepository`1,DDD.Repository">
</register>
</container>
</unity>