zoukankan      html  css  js  c++  java
  • 平坦化

    Flattening

    One of the common usages of object-object mapping is to take a complex object model and flatten it to a simpler model. You can take a complex model such as:

        public class Order
        {
        	private readonly IList<OrderLineItem> _orderLineItems = new List<OrderLineItem>();
        
        	public Customer Customer { get; set; }
        
        	public OrderLineItem[] GetOrderLineItems()
        	{
        		return _orderLineItems.ToArray();
        	}
        
        	public void AddOrderLineItem(Product product, int quantity)
        	{
        		_orderLineItems.Add(new OrderLineItem(product, quantity));
        	}
        
        	public decimal GetTotal()
        	{
        		return _orderLineItems.Sum(li => li.GetTotal());
        	}
        }
        
        public class Product
        {
        	public decimal Price { get; set; }
        	public string Name { get; set; }
        }
        
        public class OrderLineItem
        {
        	public OrderLineItem(Product product, int quantity)
        	{
        		Product = product;
        		Quantity = quantity;
        	}
        
        	public Product Product { get; private set; }
        	public int Quantity { get; private set;}
        
        	public decimal GetTotal()
        	{
        		return Quantity*Product.Price;
        	}
        }
        
        public class Customer
        {
        	public string Name { get; set; }
        }
    

    We want to flatten this complex Order object into a simpler OrderDto that contains only the data needed for a certain scenario:

        public class OrderDto
        {
        	public string CustomerName { get; set; }
        	public decimal Total { get; set; }
        }
    

    When you configure a source/destination type pair in AutoMapper, the configurator attempts to match properties and methods on the source type to properties on the destination type. If for any property on the destination type a property, method, or a method prefixed with "Get" does not exist on the source type, AutoMapper splits the destination member name into individual words (by PascalCase conventions).

        // Complex model
        
        var customer = new Customer
        	{
        		Name = "George Costanza"
        	};
        var order = new Order
        	{
        		Customer = customer
        	};
        var bosco = new Product
        	{
        		Name = "Bosco",
        		Price = 4.99m
        	};
        order.AddOrderLineItem(bosco, 15);
        
        // Configure AutoMapper
        
        Mapper.Initialize(cfg => cfg.CreateMap<Order, OrderDto>());
        
        // Perform mapping
        
        OrderDto dto = Mapper.Map<Order, OrderDto>(order);
        
        dto.CustomerName.ShouldEqual("George Costanza");
        dto.Total.ShouldEqual(74.85m);
    

    We configured the type map in AutoMapper with the CreateMap method. AutoMapper can only map type pairs it knows about, so we have explicitly register the source/destination type pair with CreateMap. To perform the mapping, we use the Map method.

    On the OrderDto type, the Total property matched to the GetTotal() method on Order. The CustomerName property matched to the Customer.Name property on Order. As long as we name our destination properties appropriately, we do not need to configure individual property matching.

  • 相关阅读:
    数据结构:数组、链表、栈、队列的理解
    JVM学习记录-JVM的内存结构管理和运行时数据区理解
    线程池ThreadPoolExecutor的一种扩展办法
    四级地址插件升级改造(京东商城地址选择插件)city-picker
    java8在Collection中新增加的方法removeIf
    使用lambda编程之延迟执行
    JSP的内置对象以及作用域。
    Netty 异步的、事件驱动的网络应用程序框架和工具
    Zookeeper 服务注册和发现
    Jetty 发布web服务
  • 原文地址:https://www.cnblogs.com/Leman/p/5774347.html
Copyright © 2011-2022 走看看