La bonne façon de lever des événements à partir de C++/CLI?

Je me demandais quelle est la bonne façon de lever des événements à partir de C++/CLI. En C# on should d'abord faire une copie de la gestionnaire, vérifier si elle n'est pas null, et ensuite l'appeler. Est-il une pratique similaire pour le C++/CLI?

OriginalL'auteur Filip Frącz | 2009-01-20

  1. 18

    C++/CLI permet de remplacer raise dans événement personnalisé gestionnaires de sorte que vous n'avez pas à tester pour null ou de copie lors de la récolte de l'événement. Bien sûr, à l'intérieur de votre personnalisé raise vous avez encore à faire.

    Exemple, adapté de la MSDN pour la correction:

    public delegate void f(int);

public ref struct E {
   f ^ _E;
public:
   void handler(int i) {
      System::Console::WriteLine(i);
   }

   E() {
      _E = nullptr;
   }

   event f^ Event {
      void add(f ^ d) {
         _E += d;
      }
      void remove(f ^ d) {
        _E -= d;
      }
      void raise(int i) {
         f^ tmp = _E;
         if (tmp) {
            tmp->Invoke(i);
         }
      }
   }

   static void Go() {
      E^ pE = gcnew E;
      pE->Event += gcnew f(pE, &E::handler);
      pE->Event(17);
   }
};

int main() {
   E::Go();
}

    OriginalL'auteur Konrad Rudolph

  2. 28

    Ce n'est pas toute l'histoire! Vous n'avez pas à vous soucier null gestionnaires d'événements en C++/CLI. Le code de ces contrôles est généré pour vous. Considérez les points suivants trivial C++/CLI classe.

    public ref class MyClass
{
public:
    event System::EventHandler ^ MyEvent;
};

    Si vous compiler cette classe, et de le démonter à l'aide de Réflecteur, vous obtenez le code c# suivant.

    public class MyClass
{
    //Fields
    private EventHandler <backing_store>MyEvent;

    //Events
    public event EventHandler MyEvent
    {
        [MethodImpl(MethodImplOptions.Synchronized)] add
        {
            this.<backing_store>MyEvent = (EventHandler) Delegate.Combine(this.<backing_store>MyEvent, value);
        }
        [MethodImpl(MethodImplOptions.Synchronized)] remove
        {
            this.<backing_store>MyEvent = (EventHandler) Delegate.Remove(this.<backing_store>MyEvent, value);
        }
        raise
        {
            EventHandler <tmp> = null;
            <tmp> = this.<backing_store>MyEvent;
            if (<tmp> != null)
            {
                <tmp>(value0, value1);
            }
        }
    }
}

    Les contrôles habituels sont en train d'être fait dans la méthode raise. Sauf si vous voulez vraiment un comportement personnalisé, vous devez vous sentir à l'aise déclarer votre événement dans la classe ci-dessus, et en le soulevant sans crainte d'une valeur null gestionnaire.

    Mon problème avec cette approche est que la "relance" de la méthode n'est pas privé (comme en C#) et des spectacles dans l'intellisense.
    Alors, allez avec un événement personnalisé et de mettre private: en face.

    OriginalL'auteur IV.

  3. 7

    Si votre problème est que élever n'est pas privé, puis les implémenter explicitement comme les docs disent:

    http://msdn.microsoft.com/en-us/library/5f3csfsa.aspx

    En résumé:

    Si vous venez d'utiliser la événement mot-clé, vous créez un "trivial" de l'événement. Le compilateur génère ajouter/supprimer/élever et le délégué membre pour vous. L'généré élever fonction (comme les docs disent) vérifie nullptr. Événements triviaux sont documentées ici:

    http://msdn.microsoft.com/en-us/library/4b612y2s.aspx

    Si vous voulez plus de contrôle", par exemple pour faire élever privé, alors vous devez implémenter explicitement les membres, comme indiqué dans le lien. Vous devez déclarer explicitement un membre de données pour le type de délégué. Ensuite, vous utilisez la événement mot clé de déclarer les événements liés membres, comme dans l'exemple de Microsoft:

    //event keyword introduces the scope wherein I'm defining the required methods
//"f" is my delegate type
//"Event" is the unrealistic name of the event itself
event f^ Event
{
      //add is public (because the event block is public)
      //"_E" is the private delegate data member of type "f"
      void add(f ^ d) { _E += d; }

   //making remove private
   private:
      void remove(f ^ d) { _E -= d; }

   //making raise protected
   protected:
      void raise(int i)
      { 
         //check for nullptr
         if (_E)
         {
            _E->Invoke(i);
         }
      }
}//end event block

    Verbeux, mais il est.

    -reilly.

    OriginalL'auteur Reilly