In C #, cosa succede quando si chiama un metodo di estensione su un oggetto null?

Il metodo viene chiamato con un valore null o fornisce un'eccezione di riferimento null?

MyObject myObject = null;
myObject.MyExtensionMethod(); // <-- is this a null reference exception?

In questo caso non dovrò mai controllare il mio parametro 'this' per null?

Funzionerà benissimo (nessuna eccezione). I metodi di estensione non utilizzano chiamate virtuali (ovvero utilizza l'istruzione "call" il, non "callvirt"), pertanto non esiste un controllo null a meno che non venga scritto da solo nel metodo di estensione. Questo è effettivamente utile in alcuni casi:

public static bool IsNullOrEmpty(this string value)
{
    return string.IsNullOrEmpty(value);
}
public static void ThrowIfNull<T>(this T obj, string parameterName)
        where T : class
{
    if(obj == null) throw new ArgumentNullException(parameterName);
}

eccetera

Fondamentalmente, le chiamate alle chiamate statiche sono molto letterali, vale a dire

string s = ...
if(s.IsNullOrEmpty()) {...}

diventa:

string s = ...
if(YourExtensionClass.IsNullOrEmpty(s)) {...}

dove ovviamente non c'è nessun controllo nullo.

Aggiunta alla risposta corretta di Marc Gravell.

È possibile che venga visualizzato un avviso dal compilatore se è ovvio che questo argomento è null:

default(string).MyExtension();

Funziona bene in fase di esecuzione, ma produce l'avviso "Expression will always cause a System.NullReferenceException, because the default value of string is null".

Come hai già scoperto, poiché i metodi di estensione sono semplicemente metodi statici glorificati, saranno chiamati con nullriferimenti passati, senza NullReferenceExceptionessere lanciati. Ma dal momento che sembrano chiamanti metodi di istanza per il chiamante, dovrebbero anche comportarsi come tali. Dovresti quindi, il più delle volte, controllare il thisparametro e generare un'eccezione se lo è null. Va bene non farlo se il metodo si occupa esplicitamente dei nullvalori e il suo nome lo indica debitamente, come negli esempi seguenti:

public static class StringNullExtensions { 
  public static bool IsNullOrEmpty(this string s) { 
    return string.IsNullOrEmpty(s); 
  } 
  public static bool IsNullOrBlank(this string s) { 
    return s == null || s.Trim().Length == 0; 
  } 
}

Ho anche scritto un post su questo blog qualche tempo fa.

Un valore null verrà passato al metodo di estensione.

Se il metodo tenta di accedere all'oggetto senza verificare che sia nullo, quindi sì, genererà un'eccezione.

Un ragazzo qui ha scritto i metodi di estensione "IsNull" e "IsNotNull" che controllano che il riferimento sia passato o meno. Personalmente penso che questa sia un'aberrazione e non avrei dovuto vedere la luce del giorno, ma è perfettamente valida c #.

Come altri hanno sottolineato, la chiamata di un metodo di estensione su riferimento null fa sì che questo argomento sia nullo e non accadrà nulla di speciale. Questo dà l'idea di usare metodi di estensione per scrivere clausole di guardia.

Puoi leggere questo articolo per esempi: Come ridurre la complessità ciclomatica: clausola di protezione La versione breve è questa:

public static class StringExtensions
{
    public static void AssertNonEmpty(this string value, string paramName)
    {
        if (string.IsNullOrEmpty(value))
            throw new ArgumentException("Value must be a non-empty string.", paramName);
    }
}

Questo è il metodo di estensione della classe stringa che può essere chiamato su riferimento null:

((string)null).AssertNonEmpty("null");

La chiamata funziona correttamente solo perché il runtime chiamerà correttamente il metodo di estensione su riferimento null. Quindi è possibile utilizzare questo metodo di estensione per implementare clausole di protezione senza sintassi disordinata:

    public IRegisteredUser RegisterUser(string userName, string referrerName)
    {

        userName.AssertNonEmpty("userName");
        referrerName.AssertNonEmpty("referrerName");

        ...

    }

Il metodo di estensione è statico, quindi se non fai nulla per questo MyObject non dovrebbe essere un problema, un test rapido dovrebbe verificarlo :)

Ci sono alcune regole d'oro quando vuoi che sia leggibile e verticale.

• vale la pena dire che Eiffel dice che il codice specifico incapsulato in un metodo dovrebbe funzionare contro alcuni input, che il codice è praticabile se vengono soddisfatte alcune condizioni preliminari e garantisce un risultato atteso

Nel tuo caso - DesignByContract non funziona ... eseguirai una logica su un'istanza nulla.