AutoMapper vs ValueInjecter [fechado]

Sempre que estou procurando coisas sobre o AutoMapper no StackOverflow, estou lendo algo sobre o ValueInjecter .

Alguém pode me dizer os prós e os contras entre eles (desempenho, recursos, uso da API, extensibilidade, teste)?

como criador do ValueInjecter , posso dizer que o fiz porque queria algo simples e muito flexível

Eu realmente não gosto de escrever muito ou escrever muito monkey codecomo:

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

ValueInjecter é algo como o mozilla com seus plugins, você cria ValueInjections e os usa

existem injeções embutidas para achatamento, desatamento e algumas que devem ser herdadas

e funciona mais de um tipo de aspecto , você não precisa especificar todas as propriedades 1 para 1; em vez disso, faz algo como:

pegue todas as propriedades int da fonte cujo nome termina com "Id", transforme o valor e defina cada uma como uma propriedade no objeto de origem com o mesmo nome sem o sufixo Id e seu tipo seja herdado da Entity, coisas assim

portanto, uma diferença óbvia, o ValueInjecter é usado mesmo em formulários de janelas com aplainamento e desatamento, é assim que flexível

(mapeamento do objeto para formar controles e voltar)

Automapper, não utilizável em formulários do Windows, sem desperdício, mas possui coisas boas, como o mapeamento de coleções, por isso, caso você precise dele com o ValueInjecter, basta fazer algo como:

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

você também pode usar o ValueInjecter para mapear objetos anônimos e dinâmicos

diferenças:

• automapper criar configuração para cada possibilidade de mapeamento CreateMap ()

• injetor de valor injetar de qualquer objeto para qualquer objeto (também existem casos em que você injeta do objeto para o tipo de valor)

• O automapper construiu o achatamento, e apenas para tipos simples ou do mesmo tipo, e não possui desatamento

• valueinjecter somente se você precisar dele você faz target.InjectFrom<FlatLoopValueInjection>(source); also <UnflatLoopValueInjection> e se você quiser a partir Foo.Bar.Name of type Stringde FooBarName of type Class1você herda FlatLoopValueInjection e especificar este

• O automapper mapeia propriedades com o mesmo nome por padrão e, no restante, você deve especificar uma por uma e executar ações como Prop1.Ignore (), Prop2.Ignore () etc.

• valueinjecter tem uma injeção padrão .InjectFrom () que faz as propriedades com o mesmo nome e tipo; para todo o resto, você cria suas injeções de valor personalizadas com regras / lógica de mapeamento individuais, mais como aspectos, por exemplo, de todos os adereços do Type Foo a todos os adereços do tipo Bar

Como nunca usei nenhuma das outras ferramentas, só posso falar sobre o AutoMapper. Eu tinha alguns objetivos em mente para criar o AutoMapper:

• Suporte ao achatamento para objetos DTO burros
• Suporte cenários óbvios prontos para uso (coleções, enumerações etc.)
• Poder verificar facilmente os mapeamentos em um teste
• Permitir casos de borda para resolver valores de outros locais (tipo personalizado-> mapeamento de tipo, mapeamento de membro individual e alguns casos de borda realmente malucos).

Se você deseja fazer essas coisas, o AutoMapper funciona muito bem para você. As coisas que o AutoMapper não faz bem são:

• Preenchendo Objetos Existentes
• Desinteressante

A razão é que eu nunca precisei fazer essas coisas. Na maioria das vezes, nossas entidades não têm criadores, não expõem coleções, etc. é por isso que não existe. Usamos o AutoMapper para achatar para DTOs e mapear a partir de modelos de interface do usuário para comandar mensagens e similares. É aí que funciona muito, muito bem para nós.

Eu tentei os dois e prefiro o ValueInjecter porque é muito simples:

myObject.InjectFrom(otherObject);

Isso é tudo o que há para saber sobre a grande maioria das minhas necessidades de injeção. Não pode ficar mais simples e elegante que isso.

Essa é uma pergunta que eu tenho pesquisado também e, para o meu caso de uso, parece ser um injetor de valor. Ele não requer configuração prévia para usar (acho que pode atingir o desempenho, embora, se implementado com inteligência, poderia armazenar em cache os mapeamentos para futuras invocações em vez de refletir a cada vez), portanto, você não precisa predefinir nenhum mapeamento antes de usá-los.

Mais importante ainda, ele permite o mapeamento reverso. Agora, posso estar faltando alguma coisa aqui, pois Jimmy menciona que ele não vê nenhum caso de uso quando necessário, então talvez eu tenha o padrão errado, mas meu caso de uso é que estou criando um objeto ViewModel a partir do meu ORM. Eu exibo isso na minha página da web. Depois que o usuário termina, recupero o ViewModel como um httppost, como isso é convertido novamente nas classes ORM originais? Eu adoraria conhecer o padrão com o automapper. Com o ValueInjector, é trivial e até desatento. por exemplo, criando uma nova entidade

O modelo criado pela entidadeframework (primeiro modelo):

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

O ViewModel (que eu posso decorar com 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; }
}

O 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();
        }
    }

Na minha opinião, não fica muito mais simples que isso?

(Então isso levanta a questão: o que há de errado com o padrão que eu me deparo com isso (e parece que muitos outros fazem), que não é visto como de valor para o AutoMapper?)

No entanto, se esse padrão, conforme descrito, for o que você deseja usar, meu voto será aplicado por milha do país.