Est l'aide de l'Action.Invoquer considéré comme une bonne pratique?

Si j'ai le code ci-dessous, je dois appeler l'Action, ou doit-elle appeler à l'Action.Invoquer?

public class ClassA
{
  public event Action<string> OnAdd;

  private void SomethingHappened()
  {
    if (OnAdd != null)
     OnAdd("It Happened"); //Should it be OnAdd.Invoke("It Happened") ???????
  }
}

public class ClassB
{

  public ClassB()
  {
    var myClass = new ClassA();
    myClass.OnAdd += Add;
  }

  private void Add(string Input)
  {
    //do something
  }  
}
  • En c# 6, il peut finir par être de plus en plus populaire à utiliser le nouveau OnAdd?.Invoke("It Happened"); syntaxe
  • Un peu plus de détails pour le commentaire ci-dessus. Cet exemple utilise une fonction de C# 6, le Null-Opérateur Conditionnel. L' ? opérateur empêche l'appel de Invote méthode si OnAdd est null empêchant ainsi une exception. Cela permet à l'écriture de code qui annule la valeur null explicite de la vérification montrent les réponses ci-dessous. Voir msdn.microsoft.com/en-us/magazine/dn802602.aspx pour plus de détails.
  • À titre de comparaison ici: jacksondunstan.com/articles/3283 .
InformationsquelleAutor Jon | 2012-02-13
  1. 37

    Les deux sont équivalents, le compilateur convertit OnAdd("It Happened"); en OnAdd.Invoke("It Happened"); pour vous.

    Je suppose que c'est une question de préférence, mais je préfère personnellement le terser forme.

    En aparté, il est généralement préférable de prendre une copie locale d'un niveau de classe délégué avant de l'appeler à éviter une situation de concurrence en vertu de laquelle OnAdd n'est pas nulle à l'heure qu'il est vérifié, mais est au moment où elle est invoquée:

    private void SomethingHappened()
{
  Action<string> local = OnAdd;
  if (local != null)
  {
    local("It Happened");
  }
}
    • Je ne vois pas la différence dans la course exemple, désolé
    • Penser si il y a deux fils, et que l'un ensembles de fil OnAdd null après de l'autre thread a testé pour qu'il soit nul mais avant de l'appeler... dans votre code, vous finirais avec un NullReferenceException
    • Gotcha! Cette pratique est recommandée dans tous les cas le code appelant, comme cela?
    • Si c'est censé être thread-safe, alors oui.
    • Lol! Bon point. Merci
    InformationsquelleAutor Rich O'Kelly
  2. 11

    Les deux constructions sont parfaitement équivalentes.

    OnAdd("It Happened");

    est juste sucre syntaxique. Derrière les coulisses, le compilateur émet un appel à Action<T>.Invoke dans la MSIL. Donc, utiliser l'un qui est plus lisible pour vous (pour moi OnAdd("It Happened"); est assez lisible).

    InformationsquelleAutor Darin Dimitrov
  3. 10

    Quelque chose que j'ai remarqué avec le dernier C# 6 de presse comme il peut encourager Invoke à être utilisé de plus et j'ai pensé ajouter à cette vieille question, au cas où il permet à quelqu'un:

    "Vieux" chemin:

    Action<string> doSomething = null; //or not null
if (doSomething != null)
    doSomething("test");

    Possible pragmatique (similaire à vide délégué d'événement pattern):

    Action<string> doSomethingPragmatic = s => { }; //empty - might be overwritten later
doSomethingPragmatic("test");

    C# 6:

    Action<string> doSomethingCs6 = null; //or not null
doSomethingCs6?.Invoke("test");

//Not valid C#:
//doSomethingCs6?("test")
//doSomethingCs6?.("test")
    • ReSharper encourage cette nouvelle C# 6 style.
    • Aaaahhh. Intéressant.+1
    InformationsquelleAutor jamespconnor
  4. 6

    Ils sont exactement équivalentes sauf si vous exécutez dans un très étrange bogue autour de fonctions anonymes.

    Personnellement, je généralement utiliser le raccourci forme, mais juste de temps en temps, il finit par n'être plus lisible pour appeler explicitement Invoke. Par exemple, vous pourriez avoir:

    if (callAsync)
{
    var result = foo.BeginInvoke(...);
    //...
}
else
{
    foo.Invoke(...);
    //...
}

    Ici l'utilisation explicite de Invoke est utile pour la symétrie.

    Voir l'article 15.4) de la C# 4 spec pour plus de détails de délégué invocation, bien que ce ne soit pas le spécifier explicitement dans les termes de l'appel de la Invoke méthode.

    InformationsquelleAutor Jon Skeet