Nongeneric interfaces and collection classes
In "C#12 In A Nutshell", they say:
"As with the interfaces we discussed previously, you usually have a choice of generic or nongeneric versions of each type. In terms of flexibility and performance, the generic classes win, making their nongeneric counterparts redundant except for backward compatibility. This differs from the situation with collection interfaces, for which the nongeneric versions are still occasionally useful."
But the only example they gave was for type unification (since you can't cast IEnumerable<int> to IEnumerable<object> for example). Why is that that type unification is useful just for interfaces and not for collection classes themselves? As far as I understand you can't cast int[] to object[] either.
Do you have scenarios in mind for which Nongeneric interfaces are useful and nongeneric collection classes are not?
28 Replies
There's no non-generic
List type
But e.g. List<T> does implement both IEnumerable<T> and IEnumerableisn't
ArrayList the non generic List type?List<T> doesn't inherit from ArrayList
Ah so you can't use ArrayList for type unification?
You have to use
IEnumerable?
Which is what the authors were hinting at maybe?You could take a
List<T> and copy all elements to an ArrayList if you really wanted to, but there's no point. You could just use an IEnumerable, as List<T> already implements IEnumerable, and there's no copying requiredtheres no reason to use the non generic IEnumerable 99% of the time, if ever
Yeah, it's rare, and to be fair the question does say that
Yeah of course, they just say 1% of the time you use the non generic IEnumerable and 0% for the non generic List/Queue/Stack/Dict for example
So I was wondering why there was a difference
iirc the only reason the System.Collections (non generic) namespace exists is because generics werent a thing from the start
Can you implement that without non generics?
I sort of agree with the authors for type unification purposes it feels very practical
Not as it's written, no
thats not very safe
since you don't need to copy you can just cast
but you could always use
IEnumerable<object>pretty sure you can't cast a List<int> to that?
its covariant
Yeah, but if you're inspecting an arbitrary collection, it won't implement
IEnumerable<object>
Covariance only applies to reference types
covariance doesn't apply to value types
wdym?
why wouldnt it
You can't do
IEnumerable<object> foo = some IEnumerable<int> because int is not a reference typeohh
right
good point
so that's like the 1% where nongeneric interfaces are useful?
I'd say it's quite a bit less than 1%, but sure, that's one case
or is it more complicated than that
ok cool
yeah it threw 1 percent out there it's probably 0.01% idk
It's normally when you need to start inspecting some collection of <stuff>, but you don't have much information on it
i dont think ive ever used non generic
IEnumerable or any non generic collectionit's clearer now thanks!!!