Appel de méthode s'il n'est pas nul en C #

Est-il possible de raccourcir d'une manière ou d'une autre cette déclaration?

if (obj != null)
    obj.SomeMethod();

parce que j'écris beaucoup ça et ça devient assez ennuyeux. La seule chose à laquelle je peux penser est d'implémenter le modèle Null Object , mais ce n'est pas ce que je peux faire à chaque fois et ce n'est certainement pas une solution pour raccourcir la syntaxe.

Et problème similaire avec les événements, où

public event Func<string> MyEvent;

puis invoquez

if (MyEvent != null)
    MyEvent.Invoke();

À partir de C # 6, vous pouvez simplement utiliser:

MyEvent?.Invoke();

ou:

obj?.SomeMethod();

Le ?.est l'opérateur de propagation de null, et provoquera le .Invoke()court-circuit du lorsque l'opérande est null. L'opérande n'est accessible qu'une seule fois, il n'y a donc aucun risque de problème de "changement de valeur entre la vérification et l'appel".

===

Avant C # 6, non: il n'y a pas de magie sans valeur nulle, à une exception près; méthodes d'extension - par exemple:

public static void SafeInvoke(this Action action) {
    if(action != null) action();
}

maintenant c'est valable:

Action act = null;
act.SafeInvoke(); // does nothing
act = delegate {Console.WriteLine("hi");}
act.SafeInvoke(); // writes "hi"

Dans le cas des événements, cela a l'avantage de supprimer également la condition de concurrence, c'est-à-dire que vous n'avez pas besoin d'une variable temporaire. Donc normalement vous auriez besoin de:

var handler = SomeEvent;
if(handler != null) handler(this, EventArgs.Empty);

mais avec:

public static void SafeInvoke(this EventHandler handler, object sender) {
    if(handler != null) handler(sender, EventArgs.Empty);
}

on peut utiliser simplement:

SomeEvent.SafeInvoke(this); // no race condition, no null risk

Qu'est - ce que vous cherchez est la condition Null (non « coalescent ») opérateur: ?.. Il est disponible à partir de C # 6.

Votre exemple serait obj?.SomeMethod();. Si obj est nul, rien ne se passe. Lorsque la méthode a des arguments, par exemple, obj?.SomeMethod(new Foo(), GetBar());les arguments ne sont pas évalués si objest nul, ce qui est important si l'évaluation des arguments aurait des effets secondaires.

Et le chaînage est possible: myObject?.Items?[0]?.DoSomething()

Une méthode d'extension rapide:

    public static void IfNotNull<T>(this T obj, Action<T> action, Action actionIfNull = null) where T : class {
        if(obj != null) {
            action(obj);
        } else if ( actionIfNull != null ) {
            actionIfNull();
        }
    }

exemple:

  string str = null;
  str.IfNotNull(s => Console.Write(s.Length));
  str.IfNotNull(s => Console.Write(s.Length), () => Console.Write("null"));

Ou bien:

    public static TR IfNotNull<T, TR>(this T obj, Func<T, TR> func, Func<TR> ifNull = null) where T : class {
        return obj != null ? func(obj) : (ifNull != null ? ifNull() : default(TR));
    }

exemple:

    string str = null;
    Console.Write(str.IfNotNull(s => s.Length.ToString());
    Console.Write(str.IfNotNull(s => s.Length.ToString(), () =>  "null"));

Les événements peuvent être initialisés avec un délégué par défaut vide qui n'est jamais supprimé:

public event EventHandler MyEvent = delegate { };

Aucun contrôle nul nécessaire.

[ Mise à jour , merci à Bevan pour l'avoir signalé]

Soyez conscient de l'impact possible sur les performances, cependant. Un micro benchmark rapide que j'ai fait indique que la gestion d'un événement sans abonné est 2 à 3 fois plus lente lors de l'utilisation du modèle "délégué par défaut". (Sur mon ordinateur portable double cœur 2,5 GHz, cela signifie 279 ms: 785 ms pour augmenter 50 millions d'événements non abonnés.). Pour les points chauds d'application, cela peut être un problème à prendre en compte.

Oui, dans C # 6.0 - https://msdn.microsoft.com/en-us/magazine/dn802602.aspx .

object?.SomeMethod()

Cet article d'Ian Griffiths donne deux solutions différentes au problème qui, selon lui, sont des astuces intéressantes que vous ne devriez pas utiliser.

La méthode d'extension de cérémonie comme celle suggérée ne résout pas vraiment les problèmes de conditions de course, mais les cache plutôt.

public static void SafeInvoke(this EventHandler handler, object sender)
{
    if (handler != null) handler(sender, EventArgs.Empty);
}

Comme indiqué, ce code est l'équivalent élégant de la solution avec une variable temporaire, mais ...

Le problème avec les deux est qu'il est possible que le sous-système de l'événement puisse être appelé APRÈS qu'il se soit désabonné de l'événement . Cela est possible car la désinscription peut se produire après que l'instance de délégué a été copiée dans la variable temporaire (ou passée en paramètre dans la méthode ci-dessus), mais avant que le délégué ne soit appelé.

En général, le comportement du code client est imprévisible dans ce cas: l'état du composant ne peut pas permettre déjà de gérer la notification d'événement. Il est possible d'écrire du code client de manière à le gérer, mais cela impliquerait une responsabilité inutile sur le client.

Le seul moyen connu de garantir la sécurité des threads consiste à utiliser l'instruction de verrouillage pour l'expéditeur de l'événement. Cela garantit que tous les abonnements \ désabonnements \ invocation sont sérialisés.

Pour être plus précis, le verrouillage doit être appliqué au même objet de synchronisation utilisé dans les méthodes d'accès aux événements add \ remove, qui est par défaut «this».

Je suis d'accord avec la réponse de Kenny Eliasson. Allez avec les méthodes d'extension. Voici un bref aperçu des méthodes d'extension et de la méthode IfNotNull requise.

Méthodes d'extension (méthode IfNotNull)

Peut-être pas mieux mais à mon avis plus lisible est de créer une méthode d'extension

public static bool IsNull(this object obj) {
 return obj == null;
}

Il existe un opérateur nul peu connu en C # pour cela, ??. Peut être utile:

http://weblogs.asp.net/scottgu/archive/2007/09/20/the-new-c-null-coalescing-operator-and-using-it-with-linq.aspx