DDD领域模型企业级系统Unity（五）

添加程序集：



写一个接口：

public interface IPlayer
{
void Play();
}

两个实现类：

public class NewPlay : IPlayer
{
public void Play()
{
MessageBox.Show("NewPlay");
}
}

public void Play()
{

MessageBox.Show("OldPlay");
}

ServiceLocator类：

public class ServiceLocator
{
IUnityContainer container = new UnityContainer();
public ServiceLocator()
{
container.RegisterType<IPlayer, NewPlay>("new");
container.RegisterType<IPlayer, OldPlay>("old");
}

public IUnityContainer GetContainer()
{
return container;
}
}

调用：获取一个和全部

ServiceLocator servicelocator =
new ServiceLocator();
var iplay = servicelocator.GetContainer().Resolve<IPlayer>("new");
var iplays = servicelocator.GetContainer().ResolveAll<IPlayer>();
foreach(var iplay in iplays)
{
iplay.Play();
}

构造函数的调用：

[InjectionConstructor]
public OldPlay()
{
MessageBox.Show("构造函数被执行");
}

var iplay = servicelocator.GetContainer().Resolve<IPlayer>("old");

属性注入：

写一个类：

public class Person
{
public string Name { get { return "孙"; } }
public int Age { get { return 32; } }
}

[Dependency]
public Person person { get; set; }

自动实例化

public void Play()
{
MessageBox.Show("OldPlay "+person.Name);
}

方法调用注入：

public Person person { get; set; }

public void Play()
{

MessageBox.Show("OldPlay");
}

[InjectionMethod]
public void Auto(Person person)
{
MessageBox.Show("注入方法 "+person.Name);
}

依赖注入的原理：



添加ProductRepository的仓储：（给聚合根建立仓储）

public class ProductRepository:EFRepository<Product>
{

}

添加SalesOrderRepository的仓储：

public class SalesOrderRepository:EFRepository<SalesOrder>
{
}

添加ProductRepository的仓储：

public class ProductRepository:EFRepository<Product>
{

}

添加CustomerRepository的仓储：

public class CustomerRepository:EFRepository<Customer>
{
}

定义一个实现Product领域逻辑的部分类（继承聚合根）：

public partial class Product:AggreateRoot
{
//定义仓储的接口
private IRepository<Product> irepository;
//由调用方指定具体仓储的实现
public Product(IRepository<Product> irepository)
{
this.irepository = irepository;
}
//默认构造函数
public Product()
{ }

/// <summary>
/// 实现自身聚合根的职责
/// </summary>
/// <param name="name"></param>
/// <param name="color"></param>
/// <param name="size"></param>
/// <param name="count"></param>
/// <param name="unitprice"></param>
/// <param name="categoryname"></param>
/// <param name="description"></param>
public void CreateProduct(string name,string color,string size,int count,
decimal unitprice,string categoryname,string description)
{
var product = new Product();
product.Id = base.Id; //聚合根的ID
product.ProductName = name;
product.Color = color;
product.Size = size;
product.Count = count;
product.UnitPrice = unitprice;
//聚合根下面的实体和值对象
var productcategory = new ProductCategory(categoryname,description);
product.ProductCategory = productcategory;
//添加到仓储中把对象维护起来
irepository.Create(product);

}
/// <summary>
/// 减少库存的责
/// </summary>
/// <param name="p"></param>
/// <param name="amount"></param>
/// <param name="irepository"></param>
public void ModifyCount(Product p,int amount,IRepository<Product> irepository)
{
p.Count = this.Count - amount;
irepository.Update(p);
}

public Product GetProducyByName(string productname)
{
return irepository.GetByCondition(p => p.ProductName == productname)
.FirstOrDefault();
}
}

定义一个值对象：（负责维护自己的领域逻辑和状态信息）

public abstract class ValueObject : IValueObject
{
public Guid Id
{
get
{
var id = Guid.NewGuid();
return id;
}
}
}

public interface IValueObject
{
Guid Id { get; }
}

产品类别的逻辑：

public partial class ProductCategory:ValueObject
{
public ProductCategory(string categoryname,string description)
{
this.Id = base.Id;
this.CategoryName = categoryname;
this.Description = description;
}
}

地址的值对象：

/// <summary>
/// 值对象
/// </summary>
public partial class Address:ValueObject
{
public Address(string state,string city,string street)
{
this.State = state;
this.City = city;
this.Street = street;
}
}

定义一个实现Customer领域逻辑的部分类（继承聚合根）：

public partial class Customer:AggreateRoot
{
//定义仓储接口
private IRepository<Customer> irepository;
//构造函数
public Customer(IRepository<Customer> irepository)
{
this.irepository = irepository;
}

public void CreateCustomer(string name,string mobile,string state,string city,
string street)
{
Customer customer = new Customer();
customer.Id = base.Id;
customer.Name = name;
customer.Mobile = mobile;
addcustomeraddress(customer, state, city, street);
irepository.Create(customer);
}

/// <summary>
/// 添加地址
/// </summary>
/// <param name="customer"></param>
/// <param name="state"></param>
/// <param name="city"></param>
/// <param name="street"></param>
private void addcustomeraddress(Customer customer,string state,string city,string street)
{
//值对象
var address = new Address(state, city, street);
//添加地址
customer.Address.Add(address);
}

public void AddCustomerOtherAddress(Customer customer,string state,string city,
string street)
{
addcustomeraddress(customer, state, city, street);
irepository.Update(customer);
}

public Customer GetCustomerByName(string name)
{
return irepository.GetByCondition(p => p.Name == name).FirstOrDefault();
}
}

单元测试（添加引用）：



单元测试：

EFRepositoryContext context =
new EFRepositoryContext();
[TestMethod]
public void CreateProduct()
{
//Product product = new Product(new ProductRepository());
ProductAppService product = new ProductAppService();
product.CreateProduct("P1", "Red", "Small", 100, 55, "C1", "T恤类产品");
product.CreateProduct("P2", "Green", "Big", 200, 40, "C2", "运动类产品");
context.Commit();
Assert.IsNotNull(product.GetProductByName("P1"));

}

[TestMethod]
public void CreateCustomer()
{
Customer customer = new Customer(new CustomerRepository());
customer.CreateCustomer("sun", "13458629365", "sanxi", "sanxi", "sanxi");
context.Commit();
Assert.IsNotNull(customer.GetCustomerByName("sun"));
}