标签: automapper-2

忽略ResolveUsing采用IValueResolver 的重载,并仅查看这两种方法:

void ResolveUsing(Func<TSource, object> resolver);
void MapFrom<TMember>(Expression<Func<TSource, TMember>> sourceMember);

这两者之间的主要区别似乎是ResolveUsinga Func<TSource, object>,而MapFrom需要a Expression<Func<TSource, TMember>>.

但是,在实际上使用lambda表达式的这些方法之一的客户端代码中,它们似乎是可互换的:

Mapper.CreateMap<SourceType, DestType>() // uses ResolveUsing
   .ForMember(d => d.DestPropX, o => o.ResolveUsing(s => s.SourcePropY));

Mapper.CreateMap<SourceType, DestType>() // uses MapFrom
   .ForMember(d => d.DestPropX, o => o.MapFrom(s => s.SourcePropY));

那么上述两种选择之间最终的区别是什么呢？一个比另一个快吗？一个是比另一个更好的选择,如果是,何时/为什么？

我有这些课程:

public class Person {
    public int Id{ get; set ;}
    public string FirstName{ get; set ;}
    public string LastName{ get; set ;}
}

public class PersonView {
    public int Id{ get; set ;}
    public string FirstName{ get; set ;}
    public string LastName{ get; set ;}
}

我定义了这个:

Mapper.CreateMap<Person, PersonView>();
Mapper.CreateMap<PersonView, Person>()
    .ForMember(person => person.Id, opt => opt.Ignore());

这是有用的:

PersonView personView = Mapper.Map<Person, PersonView>(new Person());

我想做同样但List<Person> to List<PersonView>但是我没有找到正确的语法.

谢谢

假设我有以下实体(类)

public class Target
{
    public string Value;
}


public class Source
{
    public string Value1;
    public string Value2;
}

现在我想配置自动映射,如果Value1以"A"开头,则将Value1映射到Value,否则我想将Value2映射到Value.

这是我到目前为止:

Mapper
    .CreateMap<Source,Target>()
    .ForMember(t => t.Value, 
        o => 
            {
                o.Condition(s => 
                    s.Value1.StartsWith("A"));
                o.MapFrom(s => s.Value1);
                  <<***But then how do I supply the negative clause!?***>>
            })

然而,我仍然不知道的部分是如果在早期条件失败时告诉AutoMapper 采取s.Value2措施.

在我看来,API的设计并不像它可能......但可能是我缺乏知识妨碍了.

我有以下型号:

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

我希望能够使用AutoMapper Name将Tag类型的属性映射到我的一个viewmodel中的字符串属性.

我使用以下代码创建了一个自定义解析器来尝试处理此映射:

public class TagToStringResolver : ValueResolver<Tag, string>
    {
        protected override string ResolveCore(Tag source)
        {
            return source.Name ?? string.Empty;
        }
    }

我使用以下代码进行映射:

Mapper.CreateMap<Tag, String>()
    .ForMember(d => d, o => o.ResolveUsing<TagToStringResolver>());

当我运行应用程序时,我收到错误:

仅对类型上的顶级单个成员支持成员的自定义配置.

我究竟做错了什么？

我希望能够使用automapper做这样的事情:

Mapper.CreateMap<Source, Destination>()
    .ForMember<d => d.Member, "THIS STRING">();

我希望d.Member始终是"这个字符串"而不是从源模型中的任何特定成员映射.将字符串字段放在源模型中并使用"THIS STRING"作为其值也不是一个选项.

AutoMapper是否以任何方式支持这些事情？

我今天从AutoMapper 2.0.0更新到2.2.0,并意识到更新破坏了一些代码.想要在automapper github网站上发布问题之前在这里问一下这个问题.

我的一个目标类型初始化一个集合属性,如下所示:

public class PageOf<TModel>
{
    public PageOf()
    {
        Items = Enumerable.Empty<TModel>();
    }

    public IEnumerable<TModel> Items { get; set; }
}

使用automapper 2.0.0,这很好.当我更新到2.2.0时,映射到此目标类型会导致NotSupportedException,并显示消息"Collection is a fixed size".(该异常包含在AutoMapperMappingException中.)

我能够通过将上面的构造函数代码更改为此来解决此问题:

public PageOf()
{
    Items = new List<TModel>();
}

似乎AutoMapper 2.0.0正在丢弃Items属性中的任何值并使用setProperty访问器,而AutoMapper 2.2.0只是使用get属性访问器并尝试修改现有的IEnumerable.它看起来Enumerable.Empty<TModel>()只是替换一个零长度数组,这将解释异常.

这是一个错误吗？AutoMapper在2.0.0和2.2.0之间的变化会导致它忽略目标属性设置器,而是尝试修改现有的集合？

更新:

根据要求,这是CreateMap调用:

public class PagedQueryResultToPageOfItemsProfiler : Profile
{
    protected override void Configure()
    {
        CreateMap<PagedQueryResult<EstablishmentView>, PageOfEstablishmentApiModel>();
    }
}

将PageOfEstablishmentApiModel类从继承PageOf<EstablishmentApiModel>.

这是Mapper.Map代码:

var query = Mapper.Map<EstablishmentViewsByKeyword>(input);
var results = _queryProcessor.Execute(query);
var …

我是第一次使用自动映射.

我正在研究c#应用程序,我想使用自动映射器.

(我只是想知道如何使用它,所以我没有asp.net应用程序既没有MVC应用程序.)

我有三个类库项目.

我想在服务项目中编写转移过程.

所以我想知道如何以及在哪里配置自动映射器？

今天我使用AutoMapper v1.1升级了一个功能齐全的应用程序,现在使用AutoMapper v2.1,我遇到了一些我以前从未遇到的问题.

这是我的代码映射的示例从后DTO到域对象

public class TypeOne
{
   public TypeOne()
   {
   }

   public TypeOne(TypeTwo two)
   {
      //throw ex if two is null
   }

   public TypeOne(TypeTwo two, TypeThree three)
   {
      //throw ex if two or three are null
   }

   public TypeTwo Two {get; private set;}

   public TypeThree Three {get; private set;}
}

public class TypeOneDto
{
   public TypeOneDto()
   {
   }

   public TypeTwoDto Two {get; set;}

   public TypeThreeDto Three {get; set;}
}

...

Mapper.CreateMap<TypeThreeDto, TypeThree>();
Mapper.CreateMap<TypeTwoDto, TypeTwo>();
Mapper.CreateMap<TypeOneDto, …

我正在使用automapper来映射源和目标对象.当我映射它们时,我得到以下错误.

表达式必须解析为顶级成员.参数名称:lambdaExpression

我无法解决问题.

我的源和目标对象是:

public partial class Source
{
        private Car[] cars;

        public Car[] Cars
        {
            get { return this.cars; }
            set { this.cars = value; }
        }
}

public partial class Destination
{
        private OutputData output;

        public OutputData Output
        {            
            get {  return this.output; }
            set {  this.output= value; }
        }
}

public class OutputData
{
        private List<Cars> cars;

        public Car[] Cars
        {
            get { return this.cars; }
            set { this.cars = value; }
        }
}

我必须Source.Cars用 …

假设我有一个源类:

public class Source
{
    //Several properties that can be mapped to DerivedBase and its subclasses
}

还有一些目的地类:

public class DestinationBase
{
     //Several properties
}

public class DestinationDerived1 : DestinationBase
{
     //Several properties
}

public class DestinationDerived2 : DestinationBase
{
     //Several properties
}

然后我希望派生的目标类继承baseclass的automapper配置,因为我不想重复它,有没有办法实现这个？

Mapper.CreateMap<Source, DestinationBase>()
    .ForMember(...)
    // Many more specific configurations that should not have to be repeated for the derived classes
    .ForMember(...);

Mapper.CreateMap<Source, DestinationDerived1 >()
    .ForMember(...);
Mapper.CreateMap<Source, DestinationDerived2 >()
    .ForMember(...);

当我像这样写它时根本不使用基本映射,包含似乎对我没有帮助.

编辑:这是我得到的:

public class Source
{
    public string …