Question

我目前有List<OriginalItem>我需要转换为List<NewItem>。

以下是课程

public class OriginalItem
{
   public int ItemIndex {get;set;}

   public string Name {get;set;}

   private OriginalItem[] itemsList;

   public OriginalItem[] ItemsList
   {
        get
        {
            return itemsList;
        }
        set
        {
            itemsList= value;
        }
   }

}

public class NewItem
{
  public int NewItemIndex {get;set;}
  public string NewName {get;set;}

  private NewItem[] itemsList;

  public NewItem[] ItemsList
  {
      get
      {
          return itemsList;
      }
      set
      {
         itemsList= value;
      }
   }
}

我知道使用select语句我可以从列表中创建一个新对象，即

List<NewItem> newItems = originalItems.Select(x=> new NewItem(){
                                                            NewItemIndex = x.ItemIndex,
                                                            NewItemName = x.Name
                                                           }).ToList();

但是如何在列表中创建列表？如果还有其他方法可以使用递归，那就不必使用递归。

Answer 1

谢谢，

从上面我设法得到我需要的微小变化：

public class OriginalItem
{
.
.
.
   //add new method to convert the originalItem to newItem
   public NewItem createNewItem()
   {
      NewItem item = new NewItem();
      item.NewName = this.Name;
      item.NewItemIndex = this.ItemIndex;
      item.ItemsList = this.ItemsList.Select(x =>x.createNewItem()).ToList();
   }
}

然后在我拥有List<OriginalItem> originalItems的主要课程中，我做了以下工作：

List<NewItem> newItems = originalItems.Select(x=>x.createNewItem()).ToList();

Answer 2

如果没有递归属性的递归，你就无法实现。这个操作基本上是递归的。

一种可能的实施方式：

NewItem ToNew(OriginalItem item)
{
    return new NewItem() { NewItemIndex = item.ItemIndex, NewName = item.Name, ItemsList = item.ItemsList == null ? null : item.ItemsList.Select(ToNew).ToArray()};
}

以下是如何使用它：

var newItems = originalItems.Select(ToNew).ToList();

它也可以作为复制构造函数实现，但没有理由同时使用这两个类。

使用方法组（仅ToNew，而非i => ToNew(i)）也更方便。

Answer 3

我将如何做到这一点：

Func<OriginalItem, NewItem> convert = null;
convert = oi =>
    new NewItem()
    {
        NewName = oi.Name,
        NewItemIndex = oi.ItemIndex,
        ItemsList = oi.ItemsList == null
            ? null
            : oi.ItemsList.Select(x => convert(x)).ToArray(),
    };

var newItems = originalItems.Select(oi => convert(oi)).ToList();

所以，鉴于此输入：

var originalItems = new List<OriginalItem>()
{
    new OriginalItem()
    {
        Name = "0", ItemIndex = 0,
        ItemsList = new []
        {
            new OriginalItem()
            {
                Name = "1", ItemIndex = 1, ItemsList = null,
            },
            new OriginalItem()
            {
                Name = "2", ItemIndex = 2, ItemsList = null,
            },
        },
    },
    new OriginalItem()
    {
        Name = "3", ItemIndex = 3, ItemsList = null,
    },
};

我得到了这个输出：

linq lambda将具有相同类型的对象列表的对象转换为另一个对象

3 个答案: