Konvertieren Sie eine Liste von Objekten mit einem Lambda-Ausdruck von einem Typ in einen anderen

Ich habe eine foreach-Schleife, die eine Liste von Objekten eines Typs liest und eine Liste von Objekten eines anderen Typs erstellt. Mir wurde gesagt, dass ein Lambda-Ausdruck das gleiche Ergebnis erzielen kann.

var origList = List<OrigType>(); // assume populated
var targetList = List<TargetType>(); 

foreach(OrigType a in origList) {
    targetList.Add(new TargetType() {SomeValue = a.SomeValue});
}

Jede Hilfe wäre dankbar - ich bin neu bei Lambda und Linq, danke, s

Versuche Folgendes

var targetList = origList
  .Select(x => new TargetType() { SomeValue = x.SomeValue })
  .ToList();

Hierbei wird eine Kombination aus Lambdas und LINQ verwendet, um die Lösung zu erzielen. Die Select-Funktion ist eine Projektionsmethode, bei der der übergebene Delegat (oder in diesem Fall Lambda) auf jeden Wert in der ursprünglichen Sammlung angewendet wird. Das Ergebnis wird in einem neuen zurückgegeben IEnumerable<TargetType>. Der Aufruf von .ToList ist eine Erweiterungsmethode, die dies IEnumerable<TargetType>in eine konvertiert List<TargetType>.

Wenn Sie wissen , Sie konvertieren möchten , List<T1>um List<T2>dann List<T>.ConvertAllwird etwas effizienter als Select/ ToListweil es die genaue Größe kennt , mit zu beginnen:

target = orig.ConvertAll(x => new TargetType { SomeValue = x.SomeValue });

Im allgemeineren Fall, wenn Sie nur die Quelle als kennen IEnumerable<T>, ist die Verwendung von Select/ ToListder richtige Weg. Man könnte auch argumentieren, dass es in einer Welt mit LINQ zunächst idiomatischer ist ... aber es lohnt sich zumindest, sich der ConvertAllOption bewusst zu sein .

var target = origList.ConvertAll(x => (TargetType)x);

List<target> targetList = new List<target>(originalList.Cast<target>());

Ich glaube, so etwas sollte funktionieren:

origList.Select(a => new TargetType() { SomeValue = a.SomeValue});

Hier ist ein einfaches Beispiel.

List<char> c = new List<char>() { 'A', 'B', 'C' };

List<string> s = c.Select(x => x.ToString()).ToList();

var list1 = new List<Type1>();
var list2 = new List<Type2>();

list1.ForEach(item => list2.Add(new Type2() { Prop1 = value1 }));

Angenommen, Sie haben mehrere Eigenschaften, die Sie konvertieren möchten.

public class OrigType{
    public string Prop1A {get;set;}
    public string Prop1B {get;set;}
}

public class TargetType{
    public string Prop2A {get;set;}
    public string Prop2B {get;set;}
}

var list1 = new List<OrigType>();
var list2 = new List<TargetType>();

list1.ConvertAll(x => new OrigType { Prop2A = x.Prop1A, Prop2B = x.Prop1B })

Oder mit einem constructor& linqmit Select:

public class TargetType {
  public string Prop1 {get;set;}
  public string Prop1 {get;set;}

  // Constructor
  public TargetType(OrigType origType) {
    Prop1 = origType.Prop1;
    Prop2 = origType.Prop2;
  }
}

var origList = new List<OrigType>();
var targetList = origList.Select(s=> new TargetType(s)).ToList();  

Die LinqLinie ist weicher! ;-);

Wenn Sie eine Funktion zum Wirken verwenden müssen:

var list1 = new List<Type1>();
var list2 = new List<Type2>();

list2 = list1.ConvertAll(x => myConvertFuntion(x));

Wo meine benutzerdefinierte Funktion ist:

private Type2 myConvertFunction(Type1 obj){
   //do something to cast Type1 into Type2
   return new Type2();
}

für ähnliche Typklasse.

List<targetlist> targetlst= JsonConvert.DeserializeObject<List<targetlist>>(JsonConvert.SerializeObject(<List<baselist>));

Wenn die Typen direkt gegossen werden können, ist dies der sauberste Weg, dies zu tun:

var target = yourList.ConvertAll(x => (TargetType)x);

Wenn die Typen nicht direkt umgewandelt werden können, können Sie die Eigenschaften vom ursprünglichen Typ dem Zieltyp zuordnen.

var target = yourList.ConvertAll(x => new TargetType { SomeValue = x.SomeValue });

Wir werden den ersten Listentyp als String betrachten und ihn in den Integer-Listentyp konvertieren wollen.

List<String> origList = new ArrayList<>(); // assume populated

Fügen Sie Werte in die ursprüngliche Liste ein.

origList.add("1");
origList.add("2");
    origList.add("3");
    origList.add("4");
    origList.add("8");

Zielliste vom Integer-Typ erstellen

List<Integer> targetLambdaList = new ArrayList<Integer>();
targetLambdaList=origList.stream().map(Integer::valueOf).collect(Collectors.toList());

Listenwerte mit forEach drucken:

    targetLambdaList.forEach(System.out::println);