Perché questo metodo di estensione genera una NullReferenceException in VB.NET?

Question

Dall'esperienza precedente avevo avuto l'impressione che fosse perfettamente legale (anche se forse non consigliabile) chiamare i metodi di estensione su un'istanza nulla. Quindi, in C#, questo codice viene compilato ed eseguito:

// code in static class 
static bool IsNull(this object obj) { 
    return obj == null; 
} 

// code elsewhere 
object x = null; 
bool exists = !x.IsNull(); 

Tuttavia, stavo solo mettendo insieme una piccola suite di codice di esempio per gli altri membri del mio team di sviluppo (siamo appena trasferiti in .NET 3.5 e ho stato assegnato il compito di ottenere il team su alcune delle nuove funzionalità a nostra disposizione), e ho scritto quello che ho pensato era l'equivalente VB.NET del codice sopra, solo per scoprire che in realtà getta un NullReferenceException . Il codice che ho scritto era questo:

' code in module ' 
<Extension()> _ 
Function IsNull(ByVal obj As Object) As Boolean 
    Return obj Is Nothing 
End Function 

' code elsewhere ' 
Dim exampleObject As Object = Nothing 
Dim exists As Boolean = Not exampleObject.IsNull() 

Il debugger si ferma proprio lì, come se avessi chiamato un metodo di istanza. Sto facendo qualcosa di sbagliato (ad esempio, c'è una sottile differenza nel modo in cui ho definito il metodo di estensione tra C# e VB.NET)? È in realtà non legale legale chiamare un metodo di estensione su un'istanza null in VB.NET, sebbene sia legale in C#? (Avrei pensato che si trattasse di una cosa .NET rispetto a una cosa specifica della lingua, ma forse mi sbagliavo.)

Qualcuno può spiegarmelo?

Answer 1

Non è possibile estendere il tipo di oggetto in VB.NET.

Principalmente, non permettiamo i metodi di estensione di essere chiamato fuori di ogni espressione che viene digitato in modo statico come "Oggetto". Questo era necessario per impedire che eventuali codici esistenti in ritardo che potresti aver scritto fossero stati interrotti dai metodi di estensione.

Riferimento:

• http://blogs.msdn.com/vbteam/archive/2007/01/24/extension-methods-and-late-binding-extension-methods-part-4.aspx

• http://johnwest.spaces.live.com/Blog/cns!EBA860160D5F5D75!463.entry

Answer 2

Sembra che il problema sia che l'oggetto è nullo. Inoltre, se si cerca qualcosa di simile a quanto segue, si otterrà un'eccezione dicendo che String non ha un metodo di estensione chiamato IsNull

Dim exampleObject As Object = "Test" 
Dim text As String = exampleObject.IsNull() 

Penso che qualsiasi valore che si sta mettendo in exampleObject, il quadro sa che tipo è. Eviterei personalmente metodi estensioni sulla classe Object, non solo in VB, ma anche in CSharp

Answer 3

Aggiornamento:

La risposta qui sotto sembra essere specifico per il caso del System.Object è esteso. Quando si estendono altre classi, non c'è NullReferenceException in VB.

Questo comportamento è di progettazione per la ragione previsto nel presente Connect issue:

VB consente di chiamare metodi di estensione definiti su oggetti, ma solo se la variabile non è staticamente digitato come oggetto.

Il motivo è VB supporta anche late-binding, e se ci leghiamo ad un metodo di interno quando si effettua una chiamata fuori una variabile dichiarata come oggetto, allora è ambiguo o meno si sta cercando di chiamare un metodo di estensione o un diverso metodo tardivo con lo stesso nome.

Teoricamente ci potrebbe consentire a questo con Strict On, ma uno dei principi della Option Strict è che non dovrebbe cambiare la semantica di codice. Se ciò è stato consentito, è possibile modificare Option Strict con in modo da eseguire una riconciliazione silenziosa con un metodo diverso , determinando un comportamento di runtime totalmente diverso.

Esempio:

Imports System.Runtime.CompilerServices 

Module Extensions 
    <Extension()> _ 
    Public Function IsNull(ByVal obj As Object) As Boolean 
     Return obj Is Nothing 
    End Function 

    <Extension()> _ 
    Public Function IsNull(ByVal obj As A) As Boolean 
     Return obj Is Nothing 
    End Function 

    <Extension()> _ 
    Public Function IsNull(ByVal obj As String) As Boolean 
     Return obj Is Nothing 
    End Function 

End Module 

Class A 
End Class 

Module Module1 

    Sub Main() 
     ' works 
     Dim someString As String = Nothing 
     Dim isStringNull As Boolean = someString.IsNull() 

     ' works 
     Dim someA As A = Nothing 
     Dim isANull As Boolean = someA.IsNull() 

     Dim someObject As Object = Nothing 
     ' throws NullReferenceException 
     'Dim someObjectIsNull As Boolean = someObject.IsNull() 

     Dim anotherObject As Object = New Object 
     ' throws MissingMemberException 
     Dim anotherObjectIsNull As Boolean = anotherObject.IsNull() 
    End Sub 

End Module 

Infatti, il compilatore VB crea una chiamata vincolante in ritardo nel caso in cui la variabile è staticamente tipizzato come Object:

.locals init ([0] object exampleObject, [1] bool exists) 
    IL_0000: ldnull 
    IL_0001: stloc.0 
    IL_0002: ldloc.0 
    IL_0003: ldnull 
    IL_0004: ldstr  "IsNull" 
    IL_0009: ldc.i4.0 
    IL_000a: newarr  [mscorlib]System.Object 
    IL_000f: ldnull 
    IL_0010: ldnull 
    IL_0011: ldnull 
    IL_0012: call  
    object [Microsoft.VisualBasic]Microsoft.VisualBasic. 
     CompilerServices.NewLateBinding::LateGet(
     object, 
     class [mscorlib]System.Type, 
     string, 
     object[], 
     string[], 
     class [mscorlib]System.Type[], 
     bool[]) 
    IL_0017: call  object [Microsoft.VisualBasic]Microsoft.VisualBasic.CompilerServices.Operators::NotObject(object) 
    IL_001c: call  bool [Microsoft.VisualBasic]Microsoft.VisualBasic.CompilerServices.Conversions::ToBoolean(object) 
    IL_0021: stloc.1 

Answer 4

Sembra essere qualcosa di eccentrico con L'oggetto, possibilmente un bug in VB o una limitazione nel compilatore, potrebbe aver bisogno di commentare la sua Holiness Jon Skeet!

In genere sembra che si stia tentando di associare in ritardo la chiamata IsNull in fase di esecuzione, anziché chiamare il metodo di estensione, che causa NullReferenceException. Se attivi Option Strict lo vedrai in fase di progettazione con gli scarabocchi rossi.

Cambiare exampleObject in qualcosa di diverso da Object stesso consentirà al codice di esempio di funzionare, anche se il valore di tale tipo è Nothing.