Hallo,

ich hoffe, dass ich nicht eine Frage zum x-ten male stelle, aber auf die
schnelle hab ich keine Postings gefunden.
Ich wuerde gerne eine generische Liste casten. Bsp:
List<Klasse1> soll in List<Klasse2> gecastet werden.
Klar kann ich eine Foreach-Schleife benutzen, aber vielleicht gibt es dafuer
eine bessere Lösung?

Danke schon mal und viele Gruesse,

Stefan

Hallo Stefan,

> Klar kann ich eine Foreach-Schleife benutzen, aber vielleicht gibt es
> dafuer
> eine bessere Lösung?

ja, C# 4.0 :-)

Gruß
Joachim
--

Dr. Joachim Fuchs - Autor - Dozent - Softwarearchitekt
http://www.fuechse-online.de/beruflich/index.html -
http://vbnet.codebooks.de

Hallo Stefan,

Stefan Borst wrote:
> ich hoffe, dass ich nicht eine Frage zum x-ten male stelle, aber auf die
> schnelle hab ich keine Postings gefunden.
> Ich wuerde gerne eine generische Liste casten. Bsp:
> List<Klasse1> soll in List<Klasse2> gecastet werden.
> Klar kann ich eine Foreach-Schleife benutzen, aber vielleicht gibt es dafuer
> eine bessere Lösung?

schau dir mal die ConvertAll-Methode an (Link für das Framework 2.0):
http://msdn.microsoft.com/de-de/libr...wf(VS.80).aspx

Hab ich grad vor ein paar Minuten verwendet, z.B. zum Umwandeln einer
List<User> nach List<string>:

List<string> users = m_api.UserList.ConvertAll(
new Converter<User, string>(
delegate(User user)
{
return user.UserName;
}
)
)

hth,
Gerald

Hallo Stefan,

> ich hoffe, dass ich nicht eine Frage zum x-ten male stelle, aber auf die
> schnelle hab ich keine Postings gefunden.
> Ich wuerde gerne eine generische Liste casten. Bsp:
> List<Klasse1> soll in List<Klasse2> gecastet werden.
> Klar kann ich eine Foreach-Schleife benutzen, aber vielleicht gibt es dafuer
> eine bessere Lösung?

Es ist zwar nicht viel besser als die Foreach-Schleife, da es im Grunde das
gleiche macht, ist aber zumindest optisch schöner:

List<Klasse1> listeMitKlasse1 = [...];
List<Klasse2> listeMitKlasse2;
listeMitKlasse2 = listeMitKlasse1.ConvertAll(item => (Klasse2)item);

Grüße
André

Hallo Joachim,

> ja, C# 4.0 :-)

Nein, etwas bidirektionales wie List<T> kannst du damit auch nicht casten.
Entweder "in" oder "out", aber nicht beides.

Du kannst zwar ein IEnumerable casten:
IEnumerable<Animal> animals = new Elefant[];

Aber wenn du dir dasselbe mit List<T> vorstellst:
var elefants = new List<Elefant>();
List<Animal> animals = elefants;
animals.Add(new Ape());
foreach(var elefant in elefants) [..]

Schöne Elefanten, nich?

--
/\/\arkus.

Markus Springweiler wrote:

> Hallo Joachim,
>
> > ja, C# 4.0 :-)
>
> Nein, etwas bidirektionales wie List<T> kannst du damit auch nicht
> casten. Entweder "in" oder "out", aber nicht beides.
>
> Du kannst zwar ein IEnumerable casten:
> IEnumerable<Animal> animals = new Elefant[];
>
> Aber wenn du dir dasselbe mit List<T> vorstellst:
> var elefants = new List<Elefant>();
> List<Animal> animals = elefants;
> animals.Add(new Ape());
> foreach(var elefant in elefants) [..]
>
> Schöne Elefanten, nich?

Du hast zwar Recht, aber in der Praxis könnte man die meisten Methoden,
die derzeit ein List<Something> entgegen nehmen auf ein IE<Something>
ändern. Wenn man z.B. den ReSharper verwendet, nervt er schon geradezu
mit Hinweisen dieser Art.

Allerdings kann man auch schon mit .NET 3.5 eine ganze Menge machen:

List<Apple> appleList = ...
List<Fruit> fruitList = appleList.Cast<Fruit>.ToList();

OK, jetzt hat man zwar eine temporäre Liste erstellt, aber man musste
den Casting Code nicht mehr von Hand schrauben.

In den meisten Fällen habe ich aber kein gutes Bachgefühl, wenn ich
erst einen Up-Cast machen muss, aber die Methode wirklich eine List<T>
haben will (also potentiell Daten zur Liste hinzufügen kann). Das würde
ich mal in der Kategorie "Bad Smell" einsortieren...

--
Immo Landwerth

Hallo Stefan,

> ich hoffe, dass ich nicht eine Frage zum x-ten male stelle, aber
> auf die schnelle hab ich keine Postings gefunden.
> Ich wuerde gerne eine generische Liste casten. Bsp:
> List<Klasse1> soll in List<Klasse2> gecastet werden.
> Klar kann ich eine Foreach-Schleife benutzen, aber vielleicht gibt
> es dafuer eine bessere Lösung?

Das wäre (auch ohne C# 4.0) möglich mit impliziter
Typ-Konvertierung. Dazu kann man u.a. seine eigene Listen-Klassen
definieren, die das foreach/ConvertAll in die darunterliegende
Implementierung verschieben. Letztlich im Prinzip das Thema
Ko- und Kontravarianz, das ich hier schon des öfteren beschrieben
habe.

Ein automatisches implizites Casting ginge etwa so:

private void Form1_Load(object sender, EventArgs e)
{
List<Klasse2> listeK2 = new List<Klasse2>(){
new Klasse2(){Prop1=42,Prop2=43},
new Klasse2(){Prop1=44,Prop2=45}};
ListK1 listeK1 = listeK2;
}

class Klasse1
{
public int Prop1 { get; set; }
public int Prop2 { get; set; }
}

class Klasse2
{
public int Prop1 { get; set; }
public int Prop2 { get; set; }
}

class ListK1 : List<Klasse1>
{
public ListK1() : base() { } // Konstruktoren je nach Notwendigkeit ...
public ListK1(IEnumerable<Klasse1> collection) : base(collection) { }

public static implicit operator ListK1(List<Klasse2> liste)
{
ListK1 k1Liste = new ListK1();
foreach (Klasse2 k2 in liste)
k1Liste.Add(new Klasse1(){
Prop1 = k2.Prop1, Prop2 = k2.Prop2});
return k1Liste;
}
}


ciao Frank
--
Dipl.Inf. Frank Dzaebel [MCP/MVP C#]
http://Dzaebel.NET