您的位置:首页 > 移动开发

DDD领域模型AutoMapper实现DTO(七)

2017-11-18 20:33 190 查看
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);
}
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: