c# - AutoMapper vs ValueInjecter

.net object-object-mapping

Question

Cada vez que busco cosas de AutoMapper en StackOverflow, estoy leyendo algo sobre ValueInjecter .

¿Puede alguien decirme los pros y los contras entre ellos (rendimiento, características, uso de API, extensibilidad, pruebas)?

Answer 1

Como creador de ValueInjecter , puedo decirte que lo hice porque quería algo simple y muy flexible.

Realmente no me gusta escribir mucho o escribir muchos monkey code de monkey code como:

Prop1.Ignore, Prop2.Ignore etc.
CreateMap<Foo,Bar>(); CreateMap<Tomato, Potato>(); etc.

ValueInjecter es algo así como mozilla con sus complementos, crea ValueInjections y los usa

hay inyecciones incorporadas para aplanar, no aplanar, y algunas están destinadas a ser heredadas

y funciona más en un tipo de aspecto de manera , no tiene que especificar todas las propiedades 1 a 1, en lugar de hacer algo como:

tome todas las propiedades int de la fuente cuyo nombre termina con "Id", transforme el valor y establezca cada una en una propiedad en el objeto de origen con el mismo nombre sin el sufijo de identificación y su tipo se hereda de la Entidad, cosas como esas

por lo tanto, una diferencia obvia es que ValueInjecter se usa incluso en formas de ventanas con aplanamiento y sin suavidad, así de flexible es

(mapeo de objeto a formulario de controles y viceversa)

Automapper, no se puede usar en formularios de Windows, no es inflable, pero tiene cosas buenas como el mapeo de colecciones, así que en caso de que lo necesite con ValueInjecter, simplemente haga algo como:

foos.Select(o => new Bar().InjectFrom(o));

También puede usar ValueInjecter para mapear desde objetos anónimos y dinámicos

diferencias:

• automapper crear configuración para cada posibilidad de mapeo CreateMap ()

• valueinjecter inyecta desde cualquier objeto a cualquier objeto (también hay casos en los que se inyecta desde un objeto a un tipo de valor)

• automapper lo ha construido, y solo para tipos simples o del mismo tipo, y no tiene un efecto de aplanamiento.

• valueinjecter solo si lo necesita, lo hace target.InjectFrom<FlatLoopValueInjection>(source); also <UnflatLoopValueInjection> target.InjectFrom<FlatLoopValueInjection>(source); also <UnflatLoopValueInjection> y si desea de Foo.Bar.Name of type String a FooBarName of type Class1 , hereda FlatLoopValueInjection y lo especifica

• automapper asigna propiedades con el mismo nombre de forma predeterminada y, para el resto, debe especificar una por una, y hacer cosas como Prop1.Ignore (), Prop2.Ignore () etc.

• valueinjecter tiene una inyección predeterminada .InjectFrom () que realiza las propiedades con el mismo nombre y tipo; para todo lo demás, creará sus inyecciones de valor personalizadas con lógica / reglas de mapeo individuales, más aspectos similares, por ejemplo, desde todos los accesorios de Type Foo a todos los accesorios de tipo Bar

Answer 2

Como nunca he usado ninguna de las otras herramientas, solo puedo hablar sobre AutoMapper. Tenía algunos objetivos en mente para construir AutoMapper:

• Soporte de aplanamiento a objetos DTO tontos.
• Soporta escenarios obvios fuera de la caja (colecciones, enumeraciones, etc.)
• Ser capaz de verificar fácilmente las asignaciones en una prueba
• Permitir casos de borde para resolver valores de otros lugares (tipo personalizado-> mapeo de tipo, mapeo de miembros individuales y algunos casos de borde realmente locos).

Si quieres hacer estas cosas, AutoMapper funciona muy bien para ti. Las cosas que AutoMapper no hace bien son:

• Relleno de objetos existentes
• Descascarado

La razón es que nunca he necesitado hacer estas cosas. En su mayor parte, nuestras entidades no tienen definidores, no exponen colecciones, etc., por eso no están allí. Usamos AutoMapper para aplanar a DTO y mapear desde modelos de UI para mandar mensajes y similares. Ahí es donde funciona realmente, muy bien para nosotros.

Answer 3

Esta es una pregunta en la que he estado investigando también, y para mi caso de uso, parece ser un valioso investigador. No requiere una configuración previa para su uso (puede afectar al rendimiento, supongo, aunque si se implementa de forma inteligente podría almacenar en caché las asignaciones para futuras invocaciones en lugar de reflejarlas cada vez), por lo que no es necesario predefinir las asignaciones antes de usarlas.

Lo más importante sin embargo, permite el mapeo inverso. Ahora es posible que me falte algo aquí, ya que Jimmy menciona que no ve ningún caso de uso donde sea necesario, así que tal vez tenga un patrón incorrecto, pero mi caso de uso es que estoy creando un objeto ViewModel desde mi ORM. Entonces muestro esto en mi página web. Una vez que el usuario termina, obtengo el ViewModel de nuevo como un httppost, ¿cómo se vuelve a convertir a las clases ORM originales? Me encantaría conocer el patrón con automapper. Con ValueInjector es trivial, e incluso no será plano. por ejemplo, creando una nueva entidad

El modelo creado por la entidad de marco (modelo primero):

public partial class Family
{ 
    public int Id { get; set; }
    public string FamilyName { get; set; }

    public virtual Address Address { get; set; }
}

public partial class Address
{
    public int Id { get; set; }
    public string Line1 { get; set; }
    public string Line2 { get; set; }
    public string TownCity { get; set; }
    public string County { get; set; }
    public string Postcode { get; set; }

    public virtual Family Family { get; set; }
}

El ViewModel (que puedo decorar con validadores):

public class FamilyViewModel
{
    public int Id { get; set; }
    public string FamilyName { get; set; }

    public int AddressId { get; set; }
    public string AddressLine1 { get; set; }
    public string AddressLine2 { get; set; }
    public string AddressTownCity { get; set; }
    public string AddressCounty { get; set; }
    public string AddressPostcode { get; set; }
}

El ViewController:

    //
    // GET: /Family/Create

    public ActionResult Create()
    {
        return View();
    } 

    //
    // POST: /Family/Create

    [HttpPost]
    public ActionResult Create(FamilyViewModel familyViewModel)
    {
        try
        {
            Family family = new Family();
            family.InjectFrom<UnflatLoopValueInjection>(familyViewModel);
            db.Families.Add(family);
            db.SaveChanges();
            return RedirectToAction("Index");
        }
        catch
        {
            return View();
        }
    }

En mi opinión, no es mucho más simple que eso?

(Así que esto plantea la pregunta, ¿qué hay de malo en el patrón que me encuentro con esto (y parece que muchos otros lo hacen), que no se considera de valor para AutoMapper?)

Sin embargo, si este patrón, tal como se describe, es uno que usted desea usar, entonces mi voto es un valioso inversor por una milla de país.

Answer 4

Probé ambos y prefiero ValueInjecter porque es muy simple:

myObject.InjectFrom(otherObject);

Eso es todo lo que hay que saber para la gran mayoría de mis necesidades de inyección. No puede ser más simple y elegante que esto.