Question

In the following code,

For Each item in MyCollection
...
Next

What does the compiler use to determine the type of item?

For example let say I have this class, which is inheriting a non generic collection,

Public Class BaseDataObjectGenericCollection(Of T)
    Inherits BaseDataObjectCollection
End Class

A for each loop still infers the Item type as Object. How would I have to modify the above class to make the type inference work?

Edit: Per Beatles1692’s answer, Implementing IEnumerator(Of T) kinda works. The base class already has a GetEnumerator function, inherited from CollectionBase, so I my implementation looked like this,

    Public Function GetEnumerator1() As System.Collections.Generic.IEnumerator(Of T) Implements System.Collections.Generic.IEnumerable(Of T).GetEnumerator
        Return MyBase.Cast(Of T)().GetEnumerator
    End Function

However, the for loop still infers the type as object. But, if I change the interface implementation to this,

    Public Shadows Function GetEnumerator() As System.Collections.Generic.IEnumerator(Of T) Implements System.Collections.Generic.IEnumerable(Of T).GetEnumerator
        Return MyBase.Cast(Of T)().GetEnumerator
    End Function

That works, the for loop gets the type inference correct. So I guess the question is now, does For Each just look for a function called GetEnumerator ?

Answer 1

Well, there’s only one place to go for a question like this. The spec!

Section 10.9.3 discusses For Each statements. According to it:

[if] local variable type inference is being used, then the identifier defines a new local variable whose scope is the entire For loop and whose type is the element type of the collection (Object if the enumerator expression is typed as Object).

“collection” here seems vague, but it’s precisely defined on the next page. Essentially, the type must have a GetEnumerator() call, and this enumerator must (a) have a MoveNext() method that returns a boolean type, and (b) have a Current property. The type of the Current property is the type that will be inferred by the compiler. Note it actually has nothing to do with IEnumerator or IEnumerable…you just have to fit the prescribed pattern. Consider this code:

Option Infer On

Public Module M
    Sub Main()
        For Each x In New SomeClass()

        Next
    End Sub
End Module

Public Class SomeClass
    Public Function GetEnumerator() As MyEnumerator
        Return New MyEnumerator()
    End Function
End Class


Public Class MyEnumerator
    Public ReadOnly Property Current As Integer
        Get
            Return 42
        End Get
    End Property

    Public Function MoveNext() As Boolean
        Return True
    End Function
End Class

The type of “x” in the Sub Main() is Integer, since the Current property returns Integer.