Question

我有链表那种情况。我的DTO看起来像这样 -

public class DTOItem
{
    public string ID
    {
        get;
        set;
    }

    public int? UniqueId
    {
        get;
        set;
    }

    public string Payload
    {
        get;
        set;
    }

    //How do I map this guy? It is list of same type.
    public List<DTOItem> RelatedItems
    {
        get;
        set;
    }
}

如何使用AutoMapper映射此人？我能够映射班上的其他成员。数据是从另一个类的集合对象映射的，该集合对象具有与此类不同的不同成员集。

public List<DTOItem> RelatedItems
{
    get;
    set;
}

提前致谢。

更新：这是代码 - 拉斐尔，这是代码：

源对象：

public class ResultsSet
{
    public int? ResultId
    {
        get;
        set;
    }

    public int UID
    {
        get;
        set;
    }

    //Returns large XML string
    public string ResultBlob
    {
        get;
        set;
    }

    public RelatedItems[] RelatedSet
    {
        get;
        set;
    }
}

public class RelatedItems
{
    public int Item_ID
    {
        get;
        set;
    }

    public int Relationship_ID
    {
        get;
        set;
    }

    public string Description
    {
        get;
        set;
    }
}

要在此处映射代码：

Mapper.CreateMap<ResultSet, DTOItem>()
            .ForMember(dest => dest.ID, opt => opt.MapFrom(src => src.ResultID.GetValueOrDefault(0)))
            .ForMember(dest => dest.UniqueId, opt => opt.MapFrom(src => src.UID))
            .ForMember(dest => dest.Payload, opt => opt.MapFrom(src => src.ResultBlob));

            /*
                How do I map RelatedSet to RelatedItems here?
            */

Mapper.Map(result, returnResult);

再次感谢。

Answer 1

无需使用AutoMapper。对于非循环，相对平坦的数据，这应该做：

static Func<RelatedItems, DTOItem> MapRelated(IEnumerable<ResultsSet> all) {
    var map = MapResultSet(all);
    return relatedItem => map(all.First(x => x.UID == relatedItem.Item_ID));
}

static Func<ResultsSet, DTOItem> MapResultSet(IEnumerable<ResultsSet> all) {
    return s => 
        new DTOItem {
            ID = s.ResultId.GetOrElse(0).ToString(),
            UniqueId = s.UID,
            Payload = s.ResultBlob,
            RelatedItems = (s.RelatedSet ?? new RelatedItems[0]).Select(MapRelated(all)).ToList()
        };
}

样本用法：

var data = new[] { 
    new ResultsSet {
        UID = 1,
        RelatedSet = new[] {
            new RelatedItems { Item_ID = 2 },
            new RelatedItems { Item_ID = 3 },
        },
    },
    new ResultsSet {
        UID = 2,
    },
    new ResultsSet {
        UID = 3,
    },
};
var items = data.Select(MapResultSet(data)).ToList();
Debug.Assert(items.Count == 3);
Debug.Assert(items[0].UniqueId == 1);
Debug.Assert(items[1].UniqueId == 2);
Debug.Assert(items[2].UniqueId == 3);
Debug.Assert(items[0].RelatedItems.Count == 2);
Debug.Assert(items[0].RelatedItems[0].UniqueId == items[1].UniqueId);
Debug.Assert(items[0].RelatedItems[1].UniqueId == items[2].UniqueId);

我假设Item_ID是UID的'关键'，否则只需调整MapRelated。

一般来说，我认为只有在必须将无类型数据映射到类型化数据时，AutoMapper才有用，即使在这种情况下，在使用它之前我也会认为很难。否则，一些LINQ代码更简单，更安全。

使用AutoMapper映射“LinkedList”

1 个答案: