converte un elenco di oggetti da un tipo a un altro usando l'espressione lambda

Ho un ciclo foreach che legge un elenco di oggetti di un tipo e produce un elenco di oggetti di un tipo diverso. Mi è stato detto che un'espressione lambda può ottenere lo stesso risultato.

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

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

Qualsiasi aiuto sarebbe apprezzato. Sono nuovo di Lambda e Linq grazie, s

Prova quanto segue

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

Questo sta usando una combinazione di Lambdas e LINQ per ottenere la soluzione. La funzione Seleziona è un metodo di stile di proiezione che applicherà il delegato passato (o lambda in questo caso) a ogni valore nella raccolta originale. Il risultato verrà restituito in un nuovo IEnumerable<TargetType>. La chiamata .ToList è un metodo di estensione che lo convertirà IEnumerable<TargetType>in a List<TargetType>.

Se si sa che si desidera convertire da List<T1>a List<T2>allora List<T>.ConvertAllsarà leggermente più efficiente di Select/ ToListperché conosce l'esatta dimensione di iniziare con:

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

Nel caso più generale quando si conosce la fonte solo come IEnumerable<T>, usare Select/ ToListè la strada da percorrere. Si potrebbe anche sostenere che in un mondo con LINQ, è più idiomatico per cominciare ... ma vale la pena almeno essere consapevoli ConvertAlldell'opzione.

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

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

Credo che qualcosa del genere dovrebbe funzionare:

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

Ecco un semplice esempio ..

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

Supponiamo di avere più proprietà che si desidera convertire.

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

O con un constructor& linqcon 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();  

La Linqlinea è più morbida! ;-)

Se devi usare una funzione per trasmettere:

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

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

Dove si trova la mia funzione personalizzata:

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

per classe di tipo simile.

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

Se i tipi possono essere lanciati direttamente, questo è il modo più pulito per farlo:

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

Se non è possibile eseguire il cast diretto dei tipi, è possibile mappare le proprietà dal tipo originale al tipo di destinazione.

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

Prenderemo in considerazione il primo tipo di elenco come String e vogliamo convertirlo in tipo intero di elenco.

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

Aggiungi valori nell'elenco originale.

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

Crea un elenco di destinazione di tipo intero

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

Stampa i valori dell'elenco usando forEach:

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