AutoMapper - comment faire pour utiliser la valeur personnalisée de résolution à l'intérieur du convertisseur de type personnalisé

Comment puis-je utiliser la valeur personnalisée résolveurs à l'intérieur du convertisseur de type personnalisé?
Actuellement, il me semble difficile à réaliser. Connaissez-vous un moyen de comment je peux utiliser cette classe?

Personne converter

class PersonConverter : ITypeConverter<PersonData, Person>
{
    public Person Convert(ResolutionContext context)
    {
        var personData = context.SourceValue as PersonData;
        if (personData == null)
        {
            return null;
        }

        var person = new Person
        {
            Name = personData.Name
        };
        //person.Dic = //use here my DictionaryResolver

        return person;
    }
}

Modèle

class Person
{
    public string Name { get; set; }
    public Dictionary Dic { get; set; }
}

class PersonData
{
    public string Name { get; set; }
    public int DicId { get; set; }
}

class Dictionary
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Valeur de résolution

class DictionaryResolver : ValueResolver<int, Dictionary>
{
    protected override Dictionary ResolveCore(int source)
    {
        //do something
        return new Dictionary
        {
            Id = source,
            Name = "Name"
        };
    }
}

OriginalL'auteur Pawel Maga | 2015-10-15

  1. 9

    Valeur personnalisée résolveurs sont conçus pour annuler le mappage d'un membre en particulier, lorsque AutoMapper va mapper les objets:

    Mapper.CreateMap<PersonData, Person>()
                .ForMember(dest => dest.Dic, opt => opt.ResolveUsing<DictionaryResolver>());

    Toutefois, lorsque vous utilisez un type personnalisé de résolution, cela prend le contrôle complet de la cartographie: il n'existe aucun moyen de personnaliser la façon dont un membre en particulier est mappé:

    Mapper.CreateMap<TPersonData, Person>().ConvertUsing(PersonConverter ); //No ForMember here.

    Toutefois, étant donné que vous ont contrôle complet lors de la conversion de type, il n'y a rien de vous empêche de réutiliser la valeur convertisseur, il vous suffit de référence spécifiquement: cependant, vous aurez à ajouter une méthode qui retourne la méthode protégée ResolveCore:

    class DictionaryResolver : ValueResolver<int, Dictionary>
{
    public Dictionary Resolve(int source)
    {
        return ResolveCore(source);
    }

    protected override Dictionary ResolveCore(int source)
    {
        //do something
        return new Dictionary
        {
            Id = source,
            Name = "Name"
        };
    }
}

    Puis lors de la conversion de type de vous appeler pour résoudre cette propriété:

    var person = new Person
    {
        Name = personData.Name
    };

DictionaryResolver resolver = new DictionaryResolver();
person.Dic = resolver.Resolve(personData.IntValue); //whatever value you use
    Merci, c'est une grande réponse

    OriginalL'auteur stuartd