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

Question

I currently have a List<OriginalItem> that i need to convert to a List<NewItem> .

Here are the classes

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;
      }
   }
}

I know using a select statement i can create a new object from a list ie

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

but how do i create the list within the list? It doesnt have to use recursion, if there is another way to do it.

Answer 1

Thanks,

from the above i managed to get what i need with minor changes:

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();
   }
}

and then in the main class where i had the List<OriginalItem> originalItems I did the following:

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

Answer 2

You can't get by without a recursion with recursive properties. This operation is essentially recursive.

One possible implementation:

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

And here is how to use it:

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

It also could be implemented as a copy constructor, but no reason to cople the two classes.

Also it's more convenient to use as a method group (just ToNew , not i => ToNew(i) ).

Answer 3

Here's how I would do it:

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();

So, given this input:

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,
    },
};

I get this output: