En C #, que se passe-t-il lorsque vous appelez une méthode d'extension sur un objet nul?

La méthode est-elle appelée avec une valeur nulle ou donne-t-elle une exception de référence nulle?

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

Si tel est le cas, je n'aurai jamais besoin de vérifier la valeur null de mon paramètre «this»?

Cela fonctionnera bien (sans exception). Les méthodes d'extension n'utilisent pas d'appels virtuels (c'est-à-dire qu'elles utilisent l'instruction "call" il, pas "callvirt") donc il n'y a pas de vérification nulle à moins que vous ne l'écriviez vous-même dans la méthode d'extension. Ceci est en fait utile dans quelques cas:

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);
}

etc

Fondamentalement, les appels aux appels statiques sont très littéraux - c.-à-d.

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

devient:

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

où il n'y a évidemment pas de contrôle nul.

Ajout à la bonne réponse de Marc Gravell.

Vous pouvez obtenir un avertissement du compilateur s'il est évident que l'argument this est nul:

default(string).MyExtension();

Fonctionne bien à l'exécution, mais génère l'avertissement "Expression will always cause a System.NullReferenceException, because the default value of string is null".

Comme vous l'avez déjà découvert, puisque les méthodes d'extension sont simplement des méthodes statiques glorifiées, elles seront appelées avec des nullréférences passées, sans NullReferenceExceptionêtre lancées. Mais, puisqu'elles ressemblent à des méthodes d'instance pour l'appelant, elles devraient également se comporter comme telles. Vous devriez alors, la plupart du temps, vérifier le thisparamètre et lever une exception si c'est le cas null. Il est normal de ne pas le faire si la méthode prend explicitement en charge les nullvaleurs et que son nom l'indique dûment, comme dans les exemples ci-dessous:

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; 
  } 
}

J'ai également écrit un article à ce sujet il y a quelque temps.

Un null sera transmis à la méthode d'extension.

Si la méthode essaie d'accéder à l'objet sans vérifier qu'il est nul, alors oui, il lèvera une exception.

Un gars ici a écrit les méthodes d'extension "IsNull" et "IsNotNull" qui vérifient si la référence est nulle ou non. Personnellement, je pense que c'est une aberration et n'aurait pas dû voir le jour, mais c'est parfaitement valide c #.

Comme d'autres l'ont souligné, l'appel d'une méthode d'extension sur une référence null entraîne la nullité de cet argument et rien d'autre de spécial ne se produit. Cela donne lieu à une idée d'utiliser des méthodes d'extension pour écrire des clauses de garde.

Vous pouvez lire cet article pour des exemples: Comment réduire la complexité cyclomatique: Clause de garde La version courte est la suivante:

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);
    }
}

Il s'agit de la méthode d'extension de classe de chaîne qui peut être appelée sur une référence nulle:

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

L'appel fonctionne correctement uniquement parce que le runtime appellera avec succès la méthode d'extension sur la référence null. Ensuite, vous pouvez utiliser cette méthode d'extension pour implémenter des clauses de garde sans syntaxe compliquée:

    public IRegisteredUser RegisterUser(string userName, string referrerName)
    {

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

        ...

    }

La méthode d'extension est statique, donc si vous ne faites rien à ce MyObject, cela ne devrait pas être un problème, un test rapide devrait le vérifier :)

Il y a peu de règles d'or lorsque vous voulez que votre fichier soit lisible et vertical.

• celui qui vaut la peine d'être dit d'Eiffel dit que le code spécifique encapsulé dans une méthode devrait fonctionner contre certaines entrées, que le code est réalisable s'il est satisfait à certaines conditions préalables et assure une sortie attendue

Dans votre cas - DesignByContract est cassé ... vous allez effectuer une logique sur une instance nulle.