convertir une liste d'objets d'un type à un autre à l'aide de l'expression lambda

J'ai une boucle foreach qui lit une liste d'objets d'un type et produit une liste d'objets d'un type différent. On m'a dit qu'une expression lambda peut obtenir le même résultat.

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

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

Toute aide serait appréciée - je suis nouveau sur lambda et linq merci, s

Essayez ce qui suit

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

Cela utilise une combinaison de Lambdas et LINQ pour parvenir à la solution. La fonction Select est une méthode de style de projection qui appliquera le délégué passé (ou lambda dans ce cas) à chaque valeur de la collection d'origine. Le résultat sera retourné dans un nouveau IEnumerable<TargetType>. L'appel .ToList est une méthode d'extension qui le convertira IEnumerable<TargetType>en un List<TargetType>.

Si vous savez que vous souhaitez convertir à partir List<T1>de, List<T2>alors List<T>.ConvertAllsera légèrement plus efficace que Select/ ToListcar il connaît la taille exacte pour commencer:

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

Dans le cas plus général, lorsque vous ne connaissez la source qu'en tant que IEnumerable<T>, l'utilisation de Select/ ToListest la voie à suivre. Vous pourriez également faire valoir que dans un monde avec LINQ, c'est plus idiomatique pour commencer ... mais cela vaut au moins la peine d'être au courant de l' ConvertAlloption.

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

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

Je crois que quelque chose comme ça devrait fonctionner:

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

Voici un exemple simple ..

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

Supposons que vous ayez plusieurs propriétés à convertir.

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

Ou avec un constructor& linqavec 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 Linqligne est plus douce! ;-)

Si vous devez utiliser une fonction pour caster:

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

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

Où est ma fonction personnalisée:

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

pour une classe de type similaire.

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

Si les types peuvent être directement convertis, c'est la façon la plus simple de le faire:

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

Si les types ne peuvent pas être directement castés, vous pouvez mapper les propriétés du type d'origine au type cible.

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

Nous considérerons que le premier type de List est String et nous voulons le convertir en type Integer de List.

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

Ajoutez des valeurs dans la liste d'origine.

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

Créer une liste cible de type entier

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

Imprimer les valeurs de liste à l'aide de forEach:

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