zoukankan      html  css  js  c++  java
  • DDD领域模型AutoMapper实现DTO(七)

    DTO的应用场景:

    定义产品类:

     public class Product
        {
            public string ProductName { get; set; }
            public decimal ProductUnitPrice { get; set; }
        }
    

     NueGet 添加AutoMapper映射组件。

    定义ProductDTO对象:

     public class ProductDTO
        {
            public string ProductName { get; set; }
            public decimal ProductUnitPrice { get; set; }
        }
    

     定义两个类:

     public class Address
        {
            public string AddressState { get; set; }
            public string AddressCity { get; set; }
            public string AddressStreet { get; set; }
        }
    public class Customer
        {
            public string CustomerName { get; set; }
            public string CustomerMobile { get; set; }
            public Address CustomerAddress { get; set; }
        }

     多个对象的映射类:

      public class CustomerDTO
        {
            public string Name { get; set; }
            public string Mobile { get; set; }
            public string State { get; set; }
            public string City { get; set; }
            public string Street { get; set; }
        }
    

     映射的代码:

      public class  Mapping
        {
            public static ProductDTO CreateProductMapping()
            {
               var map=Mapper.CreateMap<Product, ProductDTO>();
               Product p = new Product
                {
                    ProductName = "P1",
                    ProductUnitPrice = 100
                };
    
                var pdto = Mapper.Map<Product, ProductDTO>(p);
                return pdto;
               
            }
           
            public static CustomerDTO CreateCustomerMapping()
            {
                //创建映射关系
                var map = Mapper.CreateMap<Customer, CustomerDTO>();
                map.ForMember(ppt => ppt.Name, p => p.MapFrom(s => s.CustomerName));
                map.ForMember(ppt => ppt.Mobile, p => p.MapFrom(s => s.CustomerMobile));
                map.ForMember(ppt => ppt.State, p => p.MapFrom(s => s.CustomerAddress.AddressState));
                map.ForMember(ppt => ppt.City, p => p.MapFrom(s => s.CustomerAddress.AddressCity));
                map.ForMember(ppt => ppt.Street, p => p.MapFrom(s => s.CustomerAddress.AddressStreet));
    
                Customer customer = new Customer
                {
                    CustomerName = "sun",
                    CustomerMobile = "135933",
                    CustomerAddress =
                          new Address
                          {
                              AddressState = "山西",
                              AddressCity = "孝义",
                              AddressStreet = "三贤路"
                          }
                };
                var customerdto = Mapper.Map<Customer, CustomerDTO>(customer);
                return customerdto;
            }
            //简单
            public static CustomerDTO CreateCustomerMapppingNew()
            {
                var map = Mapper.CreateMap<Customer, CustomerDTO>();
                map.ConstructProjectionUsing(s => new CustomerDTO
                {
                    Name = s.CustomerName,
                    Mobile = s.CustomerMobile,
                    State = s.CustomerAddress.AddressState,
                    City = s.CustomerAddress.AddressCity,
                    Street = s.CustomerAddress.AddressStreet
                });
                Customer customer = new Customer
                {
                    CustomerName = "sun",
                    CustomerMobile = "13458629365",
                    CustomerAddress =
                          new Address
                          {
                              AddressState = "山西",
                              AddressCity = "孝义",
                              AddressStreet = "三贤路"
                          }
                };
                var customerdto = Mapper.Map<Customer, CustomerDTO>(customer);
                return customerdto;
            }
          
        }
    

     在上下文接口中(IRepositoryContext)中定义DTO的支持:

      //添加DTO对象
            void RegisterCreateDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
               where TAggreateRoot :
               class, IAggreateRoot;
    
            void RegisterUpdate<TAggreateRoot>(TAggreateRoot aggreateroot) where TAggreateRoot :
                class, IAggreateRoot;
            void RegisterUpdateDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto) where TAggreateRoot :
       class, IAggreateRoot;
    

     仓储接口的调整:

     void Create<TDTO>(TDTO tdto);
    
      TDTO GetByID<TDTO>(Guid id);
    
      List<TDTO> GetByCondition<TDTO>(Expression<Func<TAggreateRoot, bool>> condition);
    
       void Update<TDTO>(TDTO tdto);    
    
      void Remove<TDTO>(TDTO tdto);
    

     上下文DTO定义:(让EF上下文实现)

      public abstract void RegisterCreateDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
            where TAggreateRoot : class, IAggreateRoot;
    
     public abstract void RegisterUpdateDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
       where TAggreateRoot : class, IAggreateRoot; 
    
      public abstract void RegisterRemoveDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
       where TAggreateRoot : class, IAggreateRoot;
    

     EF上下文中实现:

      public override void RegisterCreateDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
            {
               
                    if (processdto != null)
                        processdto(tdto);
                    var aggreateroot = Mapper.Map<TDTO, TAggreateRoot>(tdto);
                    RegisterCreate(aggreateroot);
              
            }
    
      public override void RegisterUpdateDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
            {
                if (processdto != null)
                    processdto(tdto);
                var aggreateroot = Mapper.Map<TDTO, TAggreateRoot>(tdto);
                RegisterUpdate(aggreateroot);
            }
    
            public override void RegisterRemoveDTO<TDTO, TAggreateRoot>(TDTO tdto, Action<TDTO> processdto)
            {
                if (processdto != null)
                    processdto(tdto);
                var aggreateroot = Mapper.Map<TDTO, TAggreateRoot>(tdto);
                RegisterUpdate(aggreateroot);
            }
    

     EFRepository EF 仓储中的实现:

     public void Create<TDTO>(TDTO tdto)
            {
                base.RegisterCreateDTO<TDTO, TAggreateRoot>(tdto, null);
            }
    
      public List<TDTO> GetByCondition<TDTO>(Expression<Func<TAggreateRoot, bool>> condition)
            {
                //找到聚合根
                var aggreatroots = orderdbcontext.Set<TAggreateRoot>().Where(condition).ToList();
                //转黄成TDTO列表
                var tdtos = new List<TDTO>();
                if (aggreatroots.Count > 0)
                {
                    foreach (var aggreateroot in aggreatroots)
                    {
                        var tdto = Mapper.Map<TAggreateRoot, TDTO>(aggreateroot);
                        tdtos.Add(tdto);
                    }
                }
                return tdtos;
            }
    
     public TDTO GetByID<TDTO>(Guid id)
            {
                //得到聚合根
                var aggreateroot = orderdbcontext.Set<TAggreateRoot>().Where(p => p.Id == id).SingleOrDefault();
                //进行类型转换
                var tdto = Mapper.Map<TAggreateRoot, TDTO>(aggreateroot);
                //返回对象
                return tdto;
            }
    
       public void Remove<TDTO>(TDTO dto)
            {
                RegisterRemoveDTO<TDTO, TAggreateRoot>(dto, null);
            }
    
      public void Update<TDTO>(TDTO dto)
            {
                RegisterUpdateDTO<TDTO, TAggreateRoot>(dto, null);
            }
    

       定义产品DTO类:

      public class ProductDTO
        {
            public Guid Id { get; set; }
            public string Name { get; set; }
            public string Color { get; set; }
            public string Size { get; set; }
            public int Amount { get; set; }
            public decimal UnitPrice { get; set; }
            public string PCategoryName { get; set; }
            public string PDescription { get; set; }
        }
    

     在ProductCategory中实现构造函数:

      public ProductCategory()
            { }
    

     在Product中实现DTO:

        public Product(IRepository<Product> irepository)
            {
                this.irepository = irepository;
                //完成映射的创建
                ProductMapping();
            }
           
            //在调用构造函数的时候完成映射的创建
            private void ProductMapping()
            {
                //从界面的DTO持久化领域对象
                var mapin = Mapper.CreateMap<ProductDTO, Product>();
                //指定属性的对应关系
                mapin.ConstructProjectionUsing(p => new Product
                {
                    ProductName = p.Name,
                    Size = p.Size,
                    Color = p.Color,
                    Count = p.Amount,
                    UnitPrice = p.UnitPrice,
                    ProductCategory = new ProductCategory
                    {
                        Id = Guid.NewGuid(),
                        CategoryName = p.PCategoryName,
                        Description = p.PDescription
                    }
                });
                //返回界面的东西
                var mapout = Mapper.CreateMap<Product, ProductDTO>();
                mapout.ConstructProjectionUsing(p => new ProductDTO
                {
                    Name = p.ProductName,
                    Size = p.Size,
                    Color = p.Color,
                    UnitPrice = p.UnitPrice,
                    PCategoryName = p.ProductCategory.CategoryName,
                    PDescription = p.ProductCategory.Description,
                    Amount = p.Count
                });
            }
    

     得到产品DTO 的方法:

     /// <summary>
            /// 得到产品DTO
            /// </summary>
            /// <param name="productname"></param>
            /// <returns></returns>
            public Product GetProducyByName(string productname)
            {
                return irepository.GetByCondition(p => p.ProductName == productname)
                    .FirstOrDefault();
            }
    

     通过DTO 创建Product:

         /// <summary>
                /// 通过DTOCreate
                /// </summary>
                /// <param name="productdto"></param>
            public void CreateProduct(ProductDTO productdto)
            {
                productdto.Id = Guid.NewGuid();
                irepository.Create(productdto);
            }
    

    服务 DTO 的创建:

     /// <summary>
                /// 服务DTO的创建
                /// </summary>
                /// <param name="productdto"></param>
            public void Createproduct(ProductDTO productdto)
            {
                product.CreateProduct(productdto);
                context.Commit();
            }
     /// <summary>
            /// DTO的查询
            /// </summary>
            /// <param name="productname"></param>
            /// <returns></returns>
            public ProductDTO GetProductDTOByName(string productname)
            {
                return product.GetProductDTOByName(productname);
            }

     通过DTO创建测试:

      [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", "运动类产品");
                ProductDTO productdto = new ProductDTO();
                productdto.Name = "P3";
                productdto.Color = "Blue";
                productdto.Size = "Middle";
                productdto.Amount = 5000;
                productdto.UnitPrice = 10;
                productdto.PCategoryName = "C3";
                productdto.PDescription = "正装";
                product.Createproduct(productdto);
                context.Commit();
                Assert.IsNotNull(product.GetProductByName("P3"));          
    
            }
    
     [TestMethod]
            public void GetproductDTOByName()
            {
                ProductAppService productappservice =
                    new ProductAppService();
                var productdto = productappservice.GetProductDTOByName("P3");
                Assert.AreEqual("P3", productdto.Name);
                Assert.AreEqual("C3", productdto.PCategoryName);
            }
    
  • 相关阅读:
    时间安排还是很不合理
    ZOJ Problem Set
    ZOJ Problem Set
    ZOJ Problem Set
    ZOJ Problem Set
    还是很水啊!!!
    pragma mark
    IOS应用发布NSLog的如何注释
    设定时间让应用从后台回来是否重新启动应用
    Mac 上SVN上传.a文件
  • 原文地址:https://www.cnblogs.com/sunliyuan/p/7857855.html
Copyright © 2011-2022 走看看