List(Of ChildType) Cannot be converted to List(Of BaseType)

  • Thread starter Thread starter DippyDog
  • Start date Start date
D

DippyDog

My problem is the subject line. Basically, my thinking was that, given
class TestSpec1 inherits from class TestBase, since I can do this...


Dim tst As TestBase = GetTestObj()

Function GetTestObj() As TestSpec1
Return New TestSpec1
End Function

I thought I could do this...

Dim lst As List(Of TestBase) = GetTestList()

Function GetTestList() As List(Of TestSpec1)
Return New List(Of TestSpec1)
End Function

But I can't. Anyway to go about doing this type of setup or am I
barking up the wrong tree?

Thanks as always for any input.
 
DippyDog said:
My problem is the subject line. Basically, my thinking was that,
given class TestSpec1 inherits from class TestBase, since I can do
this...


Dim tst As TestBase = GetTestObj()

Function GetTestObj() As TestSpec1
Return New TestSpec1
End Function

I thought I could do this...

Dim lst As List(Of TestBase) = GetTestList()

Function GetTestList() As List(Of TestSpec1)
Return New List(Of TestSpec1)
End Function

But I can't. Anyway to go about doing this type of setup or am I
barking up the wrong tree?

Thanks as always for any input.
Click to expand...

The two types of the items in the list are derived from each other
whereas the lists themselves are not derived from each other.

In other words,
TestSpec1 is derived from TestBase => works
List(Of TestSpec1) is not derived from List(Of TestBase) => doesn't work


Armin
 
Hi ,

There's no generic variance supported in VB or C# at this point in time.
There is variance with arrays which some view as a good thing, some as bad
;)

Let's say you have base class A, and derived types B and C, such that B
inherits A and C inherits A. Now if you declare a list as a List(Of B) and
could cast that to a List(Of A) as such you could then add items of type C
to the List(Of A) which is not really meant to be allowed because the list
is a List(Of B) .

So in a nutshell, that's why it isn't there. The best rule for dealing with
generics is to propagate the generic parameter, e.g:

Function GetTestList(Of T) ()As List(Of T)
 
Hello Bill,
Let's say you have base class A, and derived types B and C, such that
B inherits A and C inherits A.
Ok

Now if you declare a list as a List(Of B) and could cast that to a List(Of A) as such you could then add
items of type C to the List(Of A) which is not really meant to be allowed
Click to expand...
because the list is a List(Of B).

I'm not sure if your example is what was required by the OP. (Perhaps a mistype?)

I would like to be able to ...
....cast a List(Of B) to a List(Of A) (Since all B's contain data nessecary
to qualifiy as an A)
....cast a List(Of C) to a List(Of A) (Since all C's contain data nessecary
to qualifiy as an A)

But would understand not being able to ...
....cast List(Of A) to List(Of B)
....cast List(Of A) to List(Of C)
....cast List(Of C) to List(Of B)
....cast List(Of B) to List(Of C)

While I appreciate that this is not currently allowed, Is this percieved
as something that will arrive in some hypothetical vlanguage variation down
the line, or is there a technical reason why we shouldn't do this?
 
Hi Rory,

<inline>

Rory Becker said:
Hello Bill,

because the list is a List(Of B).

I'm not sure if your example is what was required by the OP. (Perhaps a
mistype?)
Click to expand...

Nope, not a mistype.

I would like to be able to ...
...cast a List(Of B) to a List(Of A) (Since all B's contain data
nessecary to qualifiy as an A)
...cast a List(Of C) to a List(Of A) (Since all C's contain data
nessecary to qualifiy as an A)
Click to expand...


If you have a List(Of A), you can insert or add items to it that are of type
B or type C, because B and C both derive from A. So soon as you cast a
list(Of B) to a list(Of A) you have removed the type safety, allowing
objects of type C to be added to the list.

Now with a List(Of...) class, this issue isn't that big because the backing
store is an array, and because arrays do allow variance, they have to do
type checking at runtime, so an exception will be thrown. But if you were
to write your own collection class and used a different storage mechanism,
the exception might not occur on add, it might only occur later on read
when, inside your collection class, you try to cast to the desired type.

So variance comes at a cost, and it's for that reason we don't have generic
variance at present.

But would understand not being able to ...
...cast List(Of A) to List(Of B)
...cast List(Of A) to List(Of C)
...cast List(Of C) to List(Of B)
...cast List(Of B) to List(Of C)

While I appreciate that this is not currently allowed, Is this percieved
as something that will arrive in some hypothetical vlanguage variation
down the line, or is there a technical reason why we shouldn't do this?
Click to expand...


See above as to the costs. As to will languages go in this direction, yes
I believe so. VB today in 2008 now allows certain types do delegate
variance it didn't allow before. And the CLR itself allows for variance.
The question is how do we surface that in a type safe way that in itself
doesn't become more onerous than the problem we are seeking to solve ;)
Some of the C# team have been blogging about variance in C#.Next (4). If
you look at the complexities that arise from it, it raises the question is
it just simpler to propagate the generic variable instead of requiring the
variance ? For example, given Item_Get is safe, yet Item_Set is not in the
case of casting List(of B) to List(of A), you could imagine defining an
interface that specifies only the Item_Get part and using that, perhaps as a
dynamic interface. In any case, today those thoughts are still "out there",
and in code today in practice the best option is to either use non generic
interfaces or preferably, propagate the generic parameters throughout.
 
Hello Bill,
Now if you declare a list as a List(Of B) and could cast that to a
List(Of A) as such you could then add items of type C to the List(Of A)
Click to expand...
which is not really meant to be
allowed because the list is a List(Of B).
Click to expand...

ok... yeah... sure :)

I got it now.

Totally agree.

I really must stop replying to posts before my caffine level has reached
the correct level :)
 
Excellent postings, y'all! Thanks a heap. Special thanks to Bill. It
took me a few passes to get what you were saying in your first post,
but it was exactly what I needed. In particular was your suggestion
about passing the list type along. I think my coworker and I are going
with a function returning List(Of T As IInterface), using the
interface to keep type safety, if this works.
Thanks again!
 
Back
Top