DDD领域模型企业级系统Unity(五)

添加程序集:

 

写一个接口:

1
2
3
4
public interface IPlayer
  {
      void Play();
  }

 两个实现类:

1
2
3
4
5
6
7
8
9
10
11
12
13
   public class NewPlay : IPlayer
      {
          public void Play()
          {
              MessageBox.Show("NewPlay");
          }
      }
 
public void Play()
      {
           
          MessageBox.Show("OldPlay");
      }

 ServiceLocator类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class ServiceLocator
  {
      IUnityContainer container = new UnityContainer();
      public ServiceLocator()
      {           
          container.RegisterType<IPlayer, NewPlay>("new");
          container.RegisterType<IPlayer, OldPlay>("old");
      }
 
      public IUnityContainer GetContainer()
      {
          return container;
      }
  }

 调用:获取一个和全部

1
2
3
4
5
6
7
8
ServiceLocator servicelocator =
              new ServiceLocator();
          var iplay = servicelocator.GetContainer().Resolve<IPlayer>("new");
          var iplays = servicelocator.GetContainer().ResolveAll<IPlayer>();
          foreach(var iplay in iplays)
          {
              iplay.Play();
          }

 构造函数的调用:

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

 

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

属性注入:

写一个类:

1
2
3
4
5
public class Person
   {
       public string Name { get { return "孙"; } }
       public int Age { get { return 32; } }
   }

 

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

 自动实例化

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

 

方法调用注入:

1
2
3
4
5
6
7
8
9
10
11
12
13
  public Person person { get; set; }
 
public void Play()
            {
                
                MessageBox.Show("OldPlay");
            }
 
        [InjectionMethod]
        public void Auto(Person person)
        {
            MessageBox.Show("注入方法 "+person.Name);
        }

 依赖注入的原理:

添加ProductRepository的仓储:(给聚合根建立仓储)

1
2
3
4
public class ProductRepository:EFRepository<Product>
   {
 
   }

 添加SalesOrderRepository的仓储:

1
2
3
public class SalesOrderRepository:EFRepository<SalesOrder>
   {
   }

 添加ProductRepository的仓储:

1
2
3
4
public class ProductRepository:EFRepository<Product>
   {
 
   }

添加CustomerRepository的仓储:

1
2
3
public class CustomerRepository:EFRepository<Customer>
   {
   }

定义一个实现Product领域逻辑的部分类(继承聚合根):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
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();
        }
    }

定义一个值对象:(负责维护自己的领域逻辑和状态信息)

1
2
3
4
5
6
7
8
9
10
11
public abstract class ValueObject : IValueObject
    {
        public Guid Id
        {
            get
            {
                var id = Guid.NewGuid();
                return id;
            }
        }      
    }<br><br> public interface IValueObject<br>    {<br>        Guid Id { get; }<br>    }

 产品类别的逻辑:

1
2
3
4
5
6
7
8
9
public partial class ProductCategory:ValueObject
   {
       public ProductCategory(string categoryname,string description)
       {
           this.Id = base.Id;
           this.CategoryName = categoryname;
           this.Description = description;
       }
   }

 地址的值对象:

1
2
3
4
5
6
7
8
9
10
11
12
/// <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领域逻辑的部分类(继承聚合根):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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();
      }
  }

单元测试(添加引用):

单元测试:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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"));
       }

 

posted @   石shi  阅读(318)  评论(0编辑  收藏  举报
努力加载评论中...
点击右上角即可分享
微信分享提示