List(Of clsClass) = List(Of clsSubClass)

  • Thread starter Thread starter Pieter
  • Start date Start date
P

Pieter

Hi,

I have a class clsSubClass which inherits from clsClass.

When I instantiate an object of clsClass (MyClass), and I instantiate an
object from clsSubclass (MySubClass) I can do an "MyClass = MySubclass".

But when I declare two generic list of them ("Dim MyList1 as List(Of
clsClass)" and "Dim MyList2 as List(Of clsSubClass)"), I can't do an
"MyList1 = MyList2".

Why is this exactly, and is there a way to implement this behaviour?


Thanks a lot in advance,


Pieter
 
I have a class clsSubClass which inherits from clsClass.

When I instantiate an object of clsClass (MyClass), and I instantiate an
object from clsSubclass (MySubClass) I can do an "MyClass = MySubclass"..

But when I declare two generic list of them ("Dim MyList1 as List(Of
clsClass)" and "Dim MyList2 as List(Of clsSubClass)"), I can't do an
"MyList1 = MyList2".
Click to expand...

Indeed. That's because generics don't exhibit variance.
Why is this exactly, and is there a way to implement this behaviour?
Click to expand...

Brief answer: consider this code.
List<Banana> bananaBunch = new List<Banana>();
List<Fruit> fruitbowl = bananaBunch;
fruitbowl.Add(new Apple());

Suppose this were legal - then bananaBunch would contain an Apple,
which is clearly invalid.

For a lot of detail, see Eric Lippert's series of blog articles:
http://blogs.msdn.com/ericlippert/archive/tags/Covariance+and+Contravariance/default.aspx

Jon
 
Oh yes indeed you're right :-S I should have thought about that :-)

Although: An Import doesn't work neither, which should work in my opnion?
Because clsSubClass is also an clsClass: it shoudl be able to import these
items...


On Jul 15, 9:34 am, "Pieter" <[email protected]> wrote:
 
Oh yes indeed you're right :-S I should have thought about that :-)

Although: An Import doesn't work neither, which should work in my opnion?
Because clsSubClass is also an clsClass: it shoudl be able to import these
items...
Click to expand...

What exactly would you expect an import to do? You just can't treat a
list of bananas as if it's a general list of fruit. You can create a
new list of fruit and copy the contents of a list of bananas into it,
of course.

Jon
 
Well, what are you meaning by "import"? Any example code?

One good trick here is to use a generic method; I'll use C# syntax for
[my] familiarity:

public void DoSomething<T>(List<T> list) where T : clsClass
{

}

you can now pass a List<clsClass> or a List<clsSubClass>, but you
ideally want to talk about "T" inside the method. You are saying "I
have a list of [something], where that [something] is, or is derived
from, clsClass".

Marc
 
Hi,

I have a class clsSubClass which inherits from clsClass.

When I instantiate an object of clsClass (MyClass), and I instantiate an
object from clsSubclass (MySubClass) I can do an "MyClass = MySubclass"..

But when I declare two generic list of them ("Dim MyList1 as List(Of
clsClass)" and "Dim MyList2 as List(Of clsSubClass)"), I can't do an
"MyList1 = MyList2".

Why is this exactly, and is there a way to implement this behaviour?
Click to expand...

It has already been explained why it doesn't work like that, but there
are workarounds, depending on what exactly you're trying to do.
Typically, you don't want variance on variables - you want it on
function arguments. In this case, you can use generics yourself. For
example, say, you have a function that should take an arbitrary
IEnumerable(Of BaseClass). You could write it like that:

Public Sub PrintAll(items As IEnumerable(Of BaseClass)
For Each item In items ...
End Sub

But then you won't be able to pass IEnumerable(Of DerivedClass) to
this function. The workaround is to do this:

Public Sub PrintAll(Of TItem As BaseClass)(items As IEnumerable(Of
TItem))
For Each item In Items ...
End Sub

Now that the function is explicitly declared as taking IEnumerable of
_any_ TItem which inherits from BaseClass, it can take IEnumerable(Of
DerivedClass) just fine.

Unfortunately, this workaround is for covariance only; you cannot do
usage-site contravariance with it (e.g. write a method that works on
any IList(Of TItem) such that it would support method Add(BaseClass)).
 
Yes but I should be able to Import a list of Bananas into a list of Fruits?
But it doesn't work?

What exactly would you expect an import to do? You just can't treat a
list of bananas as if it's a general list of fruit. You can create a
new list of fruit and copy the contents of a list of bananas into it,
of course.

Jon
 
Ooops: The Import function is one we created ourselves: It takes a
BaseList(Of T) as argument.
 
Ooops: The Import function is one we created ourselves: It takes a
BaseList(Of T) as argument.
Click to expand...

And what does it do, exactly? It's hard to say why something doesn't
work without seeing it...

Jon
 
This code should do it. MyList1 will be a different List to MyList2, but the
elements inside will be the same. Changes to the membership of MyList2 will
not be reflected in MyList1, but changes to properties of the members in each
should be:

Dim MyList1 as New List(Of clsClass)
Dim MyList2 as New List(Of clsSubClass)
....
'Copy MyList2 into MyList1
MyList1.Clear
For i As Integer = 0 To MyList2.Count -1
MyList1.Add MyList2.Item(i)
Next i
 
Ooops: The Import function is one we created ourselves: It takes a
BaseList(Of T) as argument.
Click to expand...

So the generic method approach can be used (see below, again, using C#
syntax). Alternatively, in .NET 3.5 the LINQ "Cast" method can be used
as a one-liner, even with a regular List<T>:

fruits.AddRange(bananas.Cast<Fruit>());

Marc

== code ===

public class MyList<T> : List<T> {
public void Import<TOther>(IEnumerable<TOther> list)
where TOther : T {
foreach (TOther other in list) {
Add(other);
}
}
}
abstract class Fruit { }
class Banana : Fruit { }
class Tomato : Fruit { }

static void Main() {
MyList<Banana> bananas = new MyList<Banana>();
bananas.Add(new Banana());
bananas.Add(new Banana());

MyList<Fruit> fruits = new MyList<Fruit>();
fruits.Add(new Tomato());
fruits.Import(bananas);
}
 
Back
Top