c# reversemap - Ignora mappare una proprietà con Automapper





ignore unmapped (8)


C'è ora (AutoMapper 2.0) un attributo IgnoreMap, che userò piuttosto che la sintassi fluente che è un po 'pesante IMHO.

Sto usando Automapper e ho il seguente scenario: Class OrderModel ha una proprietà chiamata 'ProductName' che non è nel database. Quindi quando provo a fare la mappatura con:

Mapper.CreateMap<OrderModel, Orders>(); 

Genera un'eccezione:

"Le seguenti proprietà 1 su Project.ViewModels.OrderModel non sono mappate: 'ProductName'

Ho letto su Wiki di AutoMapper per Proiezioni il caso opposto (l'attributo extra è sulla destinazione, non nella fonte che è in realtà il mio caso)

Come posso evitare che l'automapper effettui la mappatura di questa proprietà?




Quando si effettua il mapping di un modello di vista su un modello di dominio, può essere molto più semplice convalidare semplicemente l'elenco dei membri di origine anziché l'elenco dei membri di destinazione

Mapper.CreateMap<OrderModel, Orders>(MemberList.Source); 

Ora la convalida della mia mappatura non fallisce, richiedendo un altro Ignore() , ogni volta che aggiungo una proprietà alla mia classe di dominio.




Ho apprezzato un'estensione aggiunta da Steve Rukuts, quindi ho deciso di aggiungere un altro metodo di estensione basato sul suo esempio. Spero che possa aiutare qualcuno:

    public static IMappingExpression<TSource, TDestination> Map<TSource, TDestination>(
        this IMappingExpression<TSource, TDestination> map,
        Expression<Func<TSource, object>> src,
        Expression<Func<TDestination, object>> dst)
    {
        map.ForMember(dst, opt => opt.MapFrom(src));
        return map;
    }

Uso:

    Mapper.Initialize(cfg => cfg.CreateMap<UserModel, UserDto>()
        .Map(src => src.FirstName + " " + src.LastName, dst => dst.UserName));



Ciao a tutti Si prega di usare questo sta funzionando bene ... per auto mapper utilizzare più .ForMember in C #

        if (promotionCode.Any())
        {
            Mapper.Reset();
            Mapper.CreateMap<PromotionCode, PromotionCodeEntity>().ForMember(d => d.serverTime, o => o.MapFrom(s => s.promotionCodeId == null ? "date" : String.Format("{0:dd/MM/yyyy h:mm:ss tt}", DateTime.UtcNow.AddHours(7.0))))
                .ForMember(d => d.day, p => p.MapFrom(s => s.code != "" ? LeftTime(Convert.ToInt32(s.quantity), Convert.ToString(s.expiryDate), Convert.ToString(DateTime.UtcNow.AddHours(7.0))) : "Day"))
                .ForMember(d => d.subCategoryname, o => o.MapFrom(s => s.subCategoryId == 0 ? "" : Convert.ToString(subCategory.Where(z => z.subCategoryId.Equals(s.subCategoryId)).FirstOrDefault().subCategoryName)))
                .ForMember(d => d.optionalCategoryName, o => o.MapFrom(s => s.optCategoryId == 0 ? "" : Convert.ToString(optionalCategory.Where(z => z.optCategoryId.Equals(s.optCategoryId)).FirstOrDefault().optCategoryName)))
                .ForMember(d => d.logoImg, o => o.MapFrom(s => s.vendorId == 0 ? "" : Convert.ToString(vendorImg.Where(z => z.vendorId.Equals(s.vendorId)).FirstOrDefault().logoImg)))
                .ForMember(d => d.expiryDate, o => o.MapFrom(s => s.expiryDate == null ? "" : String.Format("{0:dd/MM/yyyy h:mm:ss tt}", s.expiryDate))); 
            var userPromotionModel = Mapper.Map<List<PromotionCode>, List<PromotionCodeEntity>>(promotionCode);
            return userPromotionModel;
        }
        return null;






Solo per chiunque cerchi di farlo automaticamente, è possibile utilizzare tale metodo di estensione per ignorare le proprietà non esistenti sul tipo di destinazione:

public static IMappingExpression<TSource, TDestination> IgnoreAllNonExisting<TSource, TDestination>(this IMappingExpression<TSource, TDestination> expression)
{
    var sourceType = typeof(TSource);
    var destinationType = typeof(TDestination);
    var existingMaps = Mapper.GetAllTypeMaps().First(x => x.SourceType.Equals(sourceType)
        && x.DestinationType.Equals(destinationType));
    foreach (var property in existingMaps.GetUnmappedPropertyNames())
    {
        expression.ForMember(property, opt => opt.Ignore());
    }
    return expression;
}

essere usato come segue:

Mapper.CreateMap<SourceType, DestinationType>().IgnoreAllNonExisting();

grazie a Can Gencer per la punta :)

fonte: http://cangencer.wordpress.com/2011/06/08/auto-ignore-non-existing-properties-with-automapper/




Puoi farlo:

conf.CreateMap<SourceType, DestinationType>()
   .ForSourceMember(x => x.SourceProperty, y => y.Ignore());



Il mio approccio qui sarebbe quello di usare new per ri-dichiarare i PageResults ed esporre la T come Type :

public interface IPagedList
{
    int CurrentPageIndex { get; }
    int TotalRecordCount { get; }
    int TotalPageCount { get; }        
    int PageSize { get; }

    Type ElementType { get; }
    IEnumerable PageResults { get; }
}   

public interface IPagedList<T> : IPagedList
{
    new IEnumerable<T> PageResults { get; }
}  

Ciò richiederà tuttavia "esplicita implementazione dell'interfaccia", ad es

class Foo : IPagedList<Bar>
{
    /* skipped : IPagedList<Bar> implementation */

    IEnumerable IPagedList.PageResults {
        get { return this.PageResults; } // re-use generic version
    }
    Type IPagedList.ElementType {
        get { return typeof(Bar); }
    }
}

Questo approccio rende l'API completamente utilizzabile tramite API generiche e non generiche.





c# model viewmodel automapper object-object-mapping