Func vs Function in VB - vb.net

Question

Would anyone be able to tell me what is the difference between a Func and a Function in VB.
For instance see the following:
Dim F As Func(Of String) = Function() As String
Return "B"
End Function
Dim F2 = Function() As String
Return "B"
End Function
F appears as a Func(Of String)
F2 as a Function() As String.
It looks like they do the same thing but given that the compiler sees them as having different types surely there must be a subtlity.
Best regards
Charles

Answer 1

Func(Of TResult)() is a specific delegate with the name Func. It is a type declared inside the System namespace as follows:
Public Delegate Function Func(Of TResult)() As TResult
It could have been named differently. For instance:
Public Delegate Function MyParameterLessFunction(Of TResult)() As TResult
So Func is really just the name given to a delegate. Since the type of F2 is not specified explicitly, VB does not know a name for this delegate. Is it Func or MyParameterLessFunction or something else? Instead, VB just displays its signature Function() As String, since F2 does also fit a non-generic delegate declared as
Public Delegate Function AnonymousParameterLessStringFunction() As String
In your comment you use .ToString() on F and F2. This returns the run-time types, i.e., the types of the values assigned to these variables. These types can be different from the static types of these variables, i.e., the type given to the variable name. Let's make a little test
Imports System.Reflection
Module FuncVsFunction
Dim F As Func(Of String) = Function() As String
Return "B"
End Function
Dim F2 = Function() As String
Return "B"
End Function
Sub Test()
Console.WriteLine($"Run-time type of F: {F.ToString()}")
Console.WriteLine($"Run-time type of F2: {F2.ToString()}")
Dim moduleType = GetType(FuncVsFunction)
Dim fields As IEnumerable(Of FieldInfo) = moduleType _
.GetMembers(BindingFlags.NonPublic Or BindingFlags.Static) _
.OfType(Of FieldInfo)
For Each member In fields
Console.WriteLine($"Static type of {member.Name}: {member.FieldType.Name}")
Next
Console.ReadKey()
End Sub
End Module
It displays
Run-time type of F: System.Func`1[System.String]
Run-time type of F2: VB$AnonymousDelegate_0`1[System.String]
Static type of F: System.Func`1[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]
Static type of F2: System.Object
Note that F2 is simply typed as Object. This is a surprise. I expected it to be a of a delegate type.
You also see this difference in the debugger. If you set a break point into the Test method and then hover over the Dim keywords of F and F2, a popup displays
'Dim of F (static type)
Delegate Function System.Func(Of Out TResult)() As String
'Dim of F2 (static type)
Class System.Object
If you hover over the variable names
'F (run-time type)
Method = {System.String _Lambda$__0-0()}
'F2 (run-time type)
<generated method>
For F you not only get type information but also the name of the generated method itself. Since F2 is an Object, Visual Studio obviously does not dig as deep as for F.

Answer 2

F appears as a Func(Of String) F2 as a Function() as string.
No, it doesn’t. In both cases the variable type is a delegate that’s equivalent to Func(Of String). Look at the code carefully again – both declarations have two parts; the declaration itself:
Dim F As Func(Of String)
' and
Dim F2
… and the initialisation:
Function() As String
Return "B"
End Function
' and
Function() As String
Return "B"
End Function
As you can see, the initialisation is identical. Merely the declaration is different because we omitted the explicit variable type in the second case. Thanks to Option Infer, the compiler can infer it for us.
In fact, the VB language specification has this to say (§8.4.2):
When an expression classified as a lambda method is reclassified as a value in a context where there is no target type (for example, Dim x = Function(a As Integer, b As Integer) a + b), the type of the resulting expression is an anonymous delegate type equivalent to the signature of the lambda method. [emphasis mine]
Finally, what, then, is the difference between Func and Function?
Function is a keyword that introduces a function – either anonymous function (lambda) as in your code, or a “normal” function having a name, as in this code:
Function F() As String
Return "B"
End Function
Func(Of T…) on the other hand is a generic type for a delegate. A lambda or a delegate can be bound to a variable declared with a fitting Func type. This is happening in your code.

Answer 3

Func is a delegate type - System.Func.
Function is a keyword used to create lambda expressions.
The above lambda expressions are of type System.Linq.Expression(Of System.Func(Of String)) and are indeed implicitly convertible to the delegate type Func(Of String).
The difference is that the expression is stored as an expression tree - describing the structure of the code. During the implicit conversion it is actually compiled into a delegate.