AutoMapper vs ValueInjecter

Ogni volta che cerco cose di AutoMapper su StackOverflow, sto leggendo qualcosa su ValueInjecter .

Qualcuno può dirmi i pro ei contro tra loro (prestazioni, funzionalità, utilizzo dell’API, estensibilità, test)?

come creatore di ValueInjecter , posso dirti che l’ho fatto perché volevo qualcosa di semplice e molto flessibile

Non mi piace molto scrivere o scrivere un sacco di monkey code come:

 Prop1.Ignore, Prop2.Ignore etc. CreateMap(); CreateMap(); etc. 

ValueInjecter è qualcosa come mozilla con i suoi plugin, tu crei ValueInjections e li usi

ci sono iniezioni incorporate per l’appiattimento, l’appiattimento e alcune che sono destinate ad essere ereditate

e funziona di più in un tipo di aspetto , non devi specificare tutte le proprietà da 1 a 1, invece fai qualcosa del tipo:

prendi tutte le proprietà int dalla sorgente il cui nome termina con “Id”, trasforma il valore e assegna a una proprietà nell’object sorgente lo stesso nome senza il suffisso Id e il tipo è ereditato da Entity, cose del genere

quindi una differenza ovvia, ValueInjecter viene utilizzato anche in forms di windows con appiattimento e spianatura, ecco come è flessibile

(mapping da controlli object a modulo e ritorno)

Automapper, non utilizzabile in Windows Form, non è flettente, ma ha cose buone come la mapping delle collezioni, quindi nel caso in cui ne hai bisogno con ValueInjecter devi solo fare qualcosa del tipo:

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

puoi anche usare ValueInjecter per mappare da oggetti anonimi e dinamici

differenze:

  • automapper crea la configurazione per ogni possibilità di mapping CreateMap ()

  • valueinjecter si inietta da qualsiasi object a qualsiasi object (ci sono anche casi in cui si inietta da un object a un tipo di valore)

  • l’automapper lo ha appiattito e lo ha costruito solo per tipi semplici o dello stesso tipo, e non si è sbloccato

  • valueinjecter solo se ne hai bisogno lo fai target.InjectFrom(source); also target.InjectFrom(source); also e se vuoi da Foo.Bar.Name of type String a FooBarName of type Class1 erediti FlatLoopValueInjection e specifica questo

  • automapper mappa le proprietà con lo stesso nome per impostazione predefinita e per il resto è necessario specificarne uno alla volta e fare cose come Prop1.Ignore (), Prop2.Ignore () ecc.

  • valueinjecter ha un’iniezione predefinita. InjectFrom () che esegue le proprietà con lo stesso nome e tipo; per tutto il resto crei le tue preziose impostazioni personalizzate con regole / regole di mapping individuali, più come aspetti, ad esempio da tutti gli oggetti di scena di Type Foo a tutti gli oggetti di scena di tipo Bar

Dal momento che non ho mai usato nessuno degli altri strumenti, posso solo parlare di AutoMapper. Avevo in mente alcuni obiettivi per la costruzione di AutoMapper:

  • Supporto per l’appiattimento di oggetti DTO stupidi
  • Supporta scenari ovvi fuori dagli schemi (collezioni, elenchi, ecc.)
  • Essere in grado di verificare facilmente i mapping in un test
  • Consenti casi limite per la risoluzione di valori da altri luoghi (tipo personalizzato-> tipo mapping, mapping di singoli membri e alcuni casi limite veramente pazzi).

Se vuoi fare queste cose, AutoMapper funziona molto bene per te. Le cose che AutoMapper non fa bene sono:

  • Riempimento di oggetti esistenti
  • Unflattening

Il motivo è che non ho mai avuto bisogno di fare queste cose. Per la maggior parte, le nostre quadro non hanno setter, non espongono collezioni, ecc. Ecco perché non è lì. Utilizziamo AutoMapper per appiattire in DTO e mappare dai modelli dell’interfaccia utente per comandare messaggi e simili. È lì che funziona davvero, davvero bene per noi.

Ho provato entrambi e preferisco ValueInjecter perché è così semplice:

 myObject.InjectFrom(otherObject); 

Questo è tutto ciò che c’è da sapere per la stragrande maggioranza dei miei bisogni di iniezione. Non può essere più semplice ed elegante di questo.

Questa è una domanda che ho fatto anche io e, per il mio caso d’uso, sembra essere molto preziosa. Non richiede alcuna impostazione preliminare da utilizzare (potrebbe colpire le prestazioni, suppongo, anche se se implementato in modo intelligente potrebbe memorizzare nella cache le mappature per le chiamate future anziché riflettere ogni volta), quindi non è necessario predefinire eventuali mapping prima di utilizzarli.

Ancora più importante, tuttavia, consente la mapping inversa. Ora potrei mancare qualcosa qui come Jimmy dice che non vede nessun caso d’uso dove è necessario, quindi forse ho il modello sbagliato, ma il mio caso d’uso è che sto creando un object ViewModel dal mio ORM. Quindi lo visualizzo sulla mia pagina web. Una volta che l’utente ha finito, ho riavviato ViewModel come httppost, come viene convertito nelle classi ORM originali? Mi piacerebbe conoscere il modello con l’automapper. Con ValueInjector è banale e non si appiattisce nemmeno. es. Creazione di una nuova quadro

Il modello creato dal entityframework (prima il modello):

 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; } } 

Il ViewModel (che posso decorare con i validatori):

 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; } } 

Il 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(familyViewModel); db.Families.Add(family); db.SaveChanges(); return RedirectToAction("Index"); } catch { return View(); } } 

A mio parere, non è molto più semplice di così?

(Quindi questo fa sorgere la domanda, cosa c’è di sbagliato nel modello in cui mi imbatto in questo (e sembra che molti altri lo facciano), che non è considerato di valore per AutoMapper?)

Tuttavia, se questo modello come descritto, è uno che si desidera utilizzare, allora il mio voto è valueinjecter da un miglio paese.