Alternativas a AutoMapper

¿Cuáles son los diferentes marcos alternativos disponibles para el mapeo objeto a objeto en .NET aparte de AutoMapper

Actualmente estamos planeando usar AutoMapper, pero antes de finalizar este marco, queremos entender que hay otros marcos disponibles.

Pasé por un proceso similar recientemente tratando de encontrar un mapeador que realmente cubra todos mis escenarios también. He encontrado que ValueInjecter es lo mejor de Automapper, Ememapper y algunos otros en Codeplex.

Elijo ValueInjector porque es el más flexible de todos. Tenía un requisito para mapear de entidad a viewmodel, y viewmodel a entidad, clonación profunda donde tiene customer -> projects -> project, situaciones recursivas como customer <-> project, y add / update / delete of children collections.

Fuera de la caja ValueInjector no es compatible con esto, pero su marco es lo suficientemente extensible como para admitir esto fácilmente. Puedes ver mi punto de extensión en esta convención que publiqué en su foro de discusión …

http://valueinjecter.codeplex.com/discussions/274484

Hay muchas alternativas como:

  • EmitMapper
  • AutoMapper
  • ValueInjecter
  • TinyMapper
  • OoMapper
  • Mapster

Pero también puedes usar Expressmapper . Es simple y está basado en árboles de expresiones que funcionan como códigos escritos a mano y cualquier asignación está altamente optimizada en toda la solución. También puede echar un vistazo a los hechos: los puntos de referencia que prueban que Expressmapper es lo mismo que el código escrito a mano. Posee casi el mismo conjunto de características que AutoMapper, otras serán compatibles en las versiones futuras. Y es extremadamente fácil de usar.

Una vieja pregunta, pero echa un vistazo a Mapster. Es mucho más rápido que AutoMapper (5-10X en los escenarios en los que lo he usado) si el rendimiento es crítico y es compatible con la mayoría de los escenarios de AutoMapper. Recuerde siempre realizar una prueba de rendimiento ya que los resultados varían según el escenario.
Hemos lanzado una nueva versión 3.x que funciona para .Net 4.0 / 4.5 / Core, es compatible con varias características nuevas y tiene grandes mejoras de rendimiento.

http://www.nuget.org/packages/Mapster/

https://github.com/eswann/Mapster

Divulgación … es uno de mis proyectos que se creó para un servicio de alta carga donde AutoMapper comenzó a aparecer como uno de nuestros cuellos de botella.

Si prefiere “hacer su propio” … Aquí hay una alternativa rápida y sucia a AutoMapper (es más fácil depurar problemas y 1 menos de dependencia del proyecto)

public static List QuickMapper(IList data) where TResult : new() { /* NB no DEEP copy - good for simple dto to View Model transfer etc ... classes will need to have a parameterless constructor 'where TResult : new()' by default - this will ignore cases where destination object does not have one of the source object's fields- common in ViewModels ... you could use a Dictionary param to handle cases where property names don't marry up.. to use : List lst2 = Helper.QuickMapper(lst1).ToList(); */ var result = new List(data.Count); PropertyDescriptorCollection propsSource = TypeDescriptor.GetProperties(typeof(TSource)); PropertyDescriptorCollection propsResult= TypeDescriptor.GetProperties(typeof(TResult)); TResult obj; Object colVal; string sResultFieldName = ""; string sSourceFieldName = ""; foreach (TSource item in data) { obj = new TResult(); for (int iResult = 0; iResult < propsResult.Count; iResult++) { PropertyDescriptor propResult = propsResult[iResult]; sResultFieldName = propResult.Name ; for (int iSource = 0; iSource < propsResult.Count; iSource++) { PropertyDescriptor propSource = propsSource [iSource ]; sSourceFieldName = propSource.Name; if (sResultFieldName == sSourceFieldName) { try { colVal = propSource.GetValue(item) ?? null; propResult.SetValue(obj, colVal); } catch (Exception ex) { string ss = "sResultFieldName = " + sResultFieldName + "\r\nsSourceFieldName = " + sSourceFieldName + "\r\n" + ex.Message + "\r\n" + ex.StackTrace; // do what you want here ... } } } } result.Add(obj); } return result; } 

Esta es una vieja pregunta, pero ahora también hay https://github.com/agileobjects/AgileMapper

¿Por qué no usar tales herramientas incluso si solo necesitas el 10% de sus funcionalidades? Esas herramientas generalmente están bien probadas y, con la práctica, nos gusta usarlas cada vez más, y luego comenzamos a utilizar sus otras posibilidades de lujo. Actualizar el producto siempre es riesgoso, pero para eso son las pruebas de la unidad.
Además, descubrí un nuevo mapeador que parece prometedor: Hmapper . Me gusta especialmente su rendimiento, su capacidad de elegir qué subobjetos se deben recuperar durante el mapeo y su forma fuertemente tipada de mapear tipos generics abiertos. Este asignador funciona bien hasta ahora, al menos en mi proyecto actual. Echa un vistazo aquí:

http://www.codeproject.com/Tips/1152752/H-Mapper

Por ejemplo, podemos especificar sub objetos usando Linq:

 Mapper.Map(source, x=>x.Subobject) 

De esta forma, no es necesario crear una clase DTO para información detallada y otra para listar (peso ligero).

Encuentro esto muy limpio.