Hablar primero de DTO

DTO es qué cosas?

DTO (transferencia de datos de objetos) es un objeto de transferencia de datos, significa que un objeto, pero todo el interior de los datos de la misma.

¿Por qué utilizar DTO?

1, DTO prestar más atención a los datos sobre el paquete razonable objeto de dominio, a fin de no sobre-exponer el comportamiento del objeto de campo a la capa de presentación

2, DTO está diseñado para las necesidades de la interfaz de usuario, y el modelo de dominio orientado a los negocios está diseñado. Por lo tanto más adecuado para DTO y la capa de presentación interactiva por DTO nosotros para lograr la desvinculación entre la capa de presentación y el campo Modelo, y por lo tanto los cambios no afectarán el campo capa de interfaz de usuario Modelo

3, DTO que significa datos sólo, no contiene ninguna lógica de negocio, son de tipo delgado de objeto que puede ser flexible dependiendo de los requisitos de la aplicación cuando se utiliza la interfaz de usuario

Las carpetas de auto

Ahora que sabemos que los beneficios del uso de DTO, entonces ciertamente queremos usarlo de inmediato, pero esto implicará un problema: cómo lograr la conversión entre DTO y el campo Modelo?

Hay dos ideas, ya sea convertir a escribir su propio código o utilizar una herramienta. Sino en la aplicación, sigo pensando que el uso de la herramienta relativamente simple y rápido, a continuación, utilizar la barra de herramientas. De hecho, muchas de estas herramientas de conversión, pero decidí usar AutoMapper, porque es lo suficientemente ligero, sino también, grandes ganado extranjeros muy populares fueron todos usando. Uso AutoMapper puede alcanzar fácilmente la conversión entre la DTO y el campo Modelo, es una poderosa herramienta de mapeo de objetos a objetos.

En primer lugar, cómo agregar AutoMapper al proyecto?

En el uso de abierta vs Herramientas - Gestor de paquetes de Bibliotecas - Consola de Gestión de paquetes, introduzca el comando "AutoMapper-instalación de paquetes", puede agregar AutoMapper en el proyecto -

En segundo lugar, comer castañas

Castaña 1 (la asignación entre los dos tipos)

1 Mapper.CreateMap <AddressDto, direcciones> ();
2               AddressDto dto = nueva AddressDto
 3                {
 4                    País = " china " ,
 5                    Ciudad = " Shanghai " ,
 6                    Calle = " Jinzhong calle " 
7                };
8 Dirección Dirección = Mapper.Map <AddressDto, direcciones> (Dto);

Castaña 2 (parte dos objetos asignan nombres de campo no son los mismos)

mapeo de direcciones a AddressDto, AddressDto countryName campo corresponde al campo Dirección País:

1 Mapper.CreateMap <AddressDto, Dirección> (). ForMember (d => d.Country, opt => opt.MapFrom (s => s.CountryName));

Castaño (mapeo entre el tipo de lista) 3

Fuente Lista de tipos de <Dirección>, la lista de tipo de destino <AddressDto>:

AutoMapper.Mapper.CreateMap <Dirección, AddressDto> ();
var addressDtoList = AutoMapper.Mapper.Map <Lista <Dirección>, List <AddressDto >> (AddressList);

4 castaño (asignada por la aplicación de cambio de búsqueda)

1  pública  clase ProductBll
 2  
3  {
 4          IProductRepository Pública productRepository { conjunto ; obtener ; }
 5          pública ProductDTO CreateProduct (ProductDTO productDTO)
 6          {
 7              Mapper.CreateMap <ProductDTO, producto> ();
8              producto = Mapper.Map <ProductDTO, producto> (productDTO);
9              productRepository.AddProduct (producto);
10              de retorno productDTO;
11          }
 12  
13          públicaLista <ProductDTO> obtenerProducto ()
 14          {
 15              Mapper.CreateMap <Producto, ProductDTO> ();
16              Lista <ProductDTO> arr = nuevo List <ProductDTO> ();
17              . ProductRepository.GetProduct () ForEach (i =>
 18              {
 19                  arr.Add (Mapper.Map <Producto, ProductDTO> (i));
 20              });
21              de retorno arr;
22          }
 23  
24           pública ProductDTO ModifyProduct (ProductDTO productDTO)
 25          {
 26             Mapper.CreateMap <ProductDTO, producto> ();
27              Producto producto = Mapper.Map <ProductDTO, producto> (productDTO);
28              productRepository.ModifyProduct (producto);
29              de retorno productDTO;
30          }
 31 }

En tercer lugar, hacen que sea fácil de usar AutoMapper

el castaño comido anteriormente, ¿qué opinas de ella? Si quieres seguir comiendo, y luego ir a ver la documentación específica API AutoMapper él! Si el proyecto realmente aprovechar el tiempo, creo que debe haber algún tipo de AutoMapper método, lo mejor es empaquetarlo, aquí estoy en forma de métodos de extensión empaquetados como AutoMapperHelper, por lo que el futuro uso AutoMapper se convierte en el TAN FÁCIL el ~

. 1  el uso de los System.Collections;
 2  el uso de la System.Collections.Generic;
 . 3  el uso de la System.Data;
 . 4  el uso de AutoMapper;
 . 5  espacio de nombres Infrastructure.Utility
 6.  
7.  {
 8.      ///  <Resumen> 
9.      /// AutoMapper extensión helper
 10      // /  </ resumen> 
. 11      pública  estática  clase AutoMapperHelper
 12 es      {
 13 es          ///  <Resumen> 
14          ///   tipo de mapeado
 15          ///  </ resumen> 
16         pública  estática T MapTo <T> ( este  objeto obj)
 17          {
 18              si (obj == nula ) de retorno  predeterminado (T);
19              Mapper.CreateMap (obj.GetType (), typeof (T));
20              de retorno Mapper.Map <T> (obj);
21          }
 22          ///  <summary> 
23          /// 集合列表类型映射
 24          ///  </ summary> 
25          pública  estática Lista <TDestination> MapToList <TDestination> ( esta fuente de IEnumerable)
26          {
 27              foreach ( var primero en la fuente)
 28              {
 29                  var type = first.GetType ();
30                  Mapper.CreateMap (tipo, typeof (TDestination));
31                  descanso ;
32              }
 33              de retorno Mapper.Map <List <TDestination >> (fuente);
34          }
 35          ///  <summary> 
36          /// 集合列表类型映射
 37          ///  </ summary> 
38          pública  estáticaLista <TDestination> MapToList <TSource, TDestination> ( este IEnumerable <TSource> fuente)
 39          {
 40              // IEnumerable <T>类型需要创建元素的映射
41              Mapper.CreateMap <TSource, TDestination> ();
42              de retorno Mapper.Map <Lista <TDestination >> (fuente);
43          }
 44          ///  <summary> 
45          /// 类型映射
 46          ///  </ summary> 
47          pública  estática TDestination MapTo <TSource, TDestination> ( esta fuente TSource,
             TSource: clase 
49              , donde TDestination: clase 
50          {
 51             si (fuente == nula ) de retorno de destino;
52              Mapper.CreateMap <TSource, TDestination> ();
53              de retorno Mapper.Map (origen, destino);
54          }
 55          ///  <summary> 
56          /// DataReader映射
 57          ///  </ summary> 
58          pública  estática IEnumerable <T> DataReaderMapTo <T> ( este lector IDataReader)
 59         {
 60              Mapper.Reset ();
61              Mapper.CreateMap <IDataReader, IEnumerable <T >> ();
62              de retorno Mapper.Map <IDataReader, IEnumerable <T >> (lector);
63          }
 64      }
 65 }

Se puede utilizar esta castañas como la siguiente:

// 对象Utsui 
ShipInfoModel ShipInfoModel = ShipInfo.MapTo <ShipInfoModel> ();
 // tabla de cadenas Utsui 
Lista <ShipInfoModel> shipInfoModellist = ShipInfoList.MapToList < ShipInfoModel> ();

resumen

Más uso en el proyecto DTO desacoplar la capa de presentación y el campo Modelo, con AutoMapper para lograr la conversión DTO y el campo Modelo, por lo AutoMapper volar por un tiempo en su proyecto

Uso AutoMapper para el mapeo físico en el Proyecto Core ASP.NET