Implicit Conversion: Nullable(Of T) => T | VB.NET LINQ Query Syntax Vs Method Syntax

Question

The method syntax is blocking implicit conversions, but the query syntax is not. Option Strict is on. How can I force errors to appear when using the query syntax?

Whole (Completely Runnable) Program:

Option Strict On

Module Module1

Sub Main()

    Dim custList As New List(Of Cust)()
    custList.Add(New Cust() With {.Name = "Mr. Current", .Deleted = False})
    custList.Add(New Cust() With {.Name = "Mrs. Deleted", .Deleted = True})
    custList.Add(New Cust() With {.Name = "Miss Null", .Deleted = Nothing})

    Dim QuerySyntax =
        From c In custList
        Where c.Deleted = False 'no error (the problem)

    Dim MethodSyntax =
        custList _
        .Where(Function(c) c.Deleted = False) 'compiler error (desired effect)

    For Each c As Cust In QuerySyntax
        Console.WriteLine("Q: " & c.Name & " " & c.Deleted)
    Next

    For Each c As Cust In MethodSyntax
        Console.WriteLine("M: " & c.Name & " " & c.Deleted)
    Next

    Console.ReadKey(True)

End Sub

Class Cust
    Public Property Name() As String
    Public Property Deleted() As System.Nullable(Of Boolean)
End Class

End Module

Lines that are the crux of the question:

Where c.Deleted = False 'no error
.Where(Function(c) c.Deleted = False) 'compiler error

It's not the comparison that upsets the compiler, it's passing a lambda function that returns `Boolean?` to a method that accepts a lambda that returns `Boolean`. In the first case there is no function passing, so no error either. I doubt you can fix that. — GSerg, Jun 10 '15 at 19:15
I may be way off base here, but in the first syntax, could it be that an implicit boxing operation is occurring such that the compiler decides it doesn't have to recognize the implicit conversion? That is, if (for some reason) there's an implicit box in "where c.Deleted = False" takes place, the Nullable issue is (right or wrong) obviated, hence no compiler error.... — David W, Jun 10 '15 at 19:33
Thanks for the clarification @GSerg it does look like the comparison works, but returns a `Boolean?` I watched the debugger on this simplified example: `New Nullable(Of Boolean)(Nothing) = False` and it confirmed that it returned a `Boolean?` value of `False` — Vincent Saelzler, Jun 10 '15 at 21:31

score 2 · Answer 1 · edited May 23 '17 at 10:27

I'm going to go out at least a bit of a limb and offer that I've found an explanation for this behavior.

I took this code and changed 'c.Deleted = Nothing' in the QuerySyntax version and immediately got a "green squiggly" saying "This expression will always evaluate to Nothing due to null propagation of the equals operator." That led me to think about how the compiler is interpreting the expression, and so I did a bit more snooping, and found the following:

VB.Net Linq to Entities Null Comparison - 'Is Nothing' or '= Nothing'?

From that post, it appears that when a Nullable(Of T) is involved in the expression, the compiler is internally promoting (or, I suppose, more accurately, "lifting") the equality operator to Nullable(Of T) version, which I suppose is not, technically, an "implicit conversion." As a result, it doesn't generate the compile-time error. Because the element is passed as a parameter to the function in the MethodSyntax version, the lifting operator isn't being applied, and the compiler then traps the implicit conversion syntax.

Would using stricter compiler settings catch this weird behavior? — ryanyuyu, Jun 10 '15 at 20:44
I don't know about that. It would be a matter, I suppose, of whether this is an intentional difference; one could infer that the decision to use or not use the lifting operator should be the same in both cases, implying the first syntax being permitted is a parse tree that shouldn't really survive the option strict check. — David W, Jun 10 '15 at 21:40

score 2 · Answer 2 · answered Jun 10 '15 at 21:50

Thanks @David W for the comments, they helped a lot in pointing me to the answer!

Method Syntax:

The .Where method is specifically the System.Linq.Enumerable.Where method, and it specifies that the predicate parameter is a labmba function that returns a Boolean value. As @GSerg ponted out, the comparison will return a Boolean? value, hence the compiler throws an error.

MSDN: Extension Method

Query Syntax

In contrast, the Where clause of the query syntax accepts "an expression" as the condition parameter.

Regarding this condition paramater, MSDN goes on to say:

The expression that is used in a Where clause must evaluate to a Boolean or the equivalent of a Boolean, such as an Integer that evaluates to False when its value is zero.

MSDN: Where Clause

Conclusion

In other words, using the query syntax, the expression will always be evaluated. As a result, Option Strict will have no effect because the compiler is considering the result of the evaluated expression and not the data types of the expression itself.

Implicit Conversion: Nullable(Of T) => T | VB.NET LINQ Query Syntax Vs Method Syntax

2 Answers2