DelphiEventBus

Delphiecentbus

Implémentation du modèle de bus d'événements pour Delphi XE

EventBus est conçu pour fournir une interaction entre les différents composants, sans augmenter la connectivité.

Caractéristiques

• Développement
  • Le type d'événement est déterminé par la classe.
  • Les événements sont hérités.
  • La classe de base pour tout événement est TBTKEventObject.
• Filtration
  • Les événements peuvent contenir des filtres.
  • Les valeurs du filtre sont sensibles à la casse.
  • Pour déclarer les filtres, des annotations des méthodes de classe d'événements sont utilisées.
  • En tant que filtre, les fonctions sans paramètres sont utilisées qui doivent renvoyer la valeur du filtre en tant que chaîne.
  • Les filtres sont identifiés par nom.
  • Le nom du filtre est spécifié dans l'annotation du filtre.
  • Les noms de filtre ne sont pas sensibles à la casse.
  • Les filtres utilisent deux modes:
    • Mode simple.
      • La valeur du filtre d'événement correspond aux valeurs de filtre de gestionnaire vides et correspondantes.
      • Ce mode est utilisé par défaut.
    • Mode hashable.
      • La valeur du filtre d'événement correspond uniquement à la même valeur de filtre de gestionnaire.
      • Le hachage accélère la formation de listes de gestionnaires à appeler.
  • Le mode filtre est spécifié dans l'annotation du filtre.
  • La classe de base contient un filtre de hachage nommé "Sujet"
• Gestionnaires
  • L'ajout de gestionnaires d'événements est effectué en enregistrant un auditeur dans le bus.
  • La suppression des gestionnaires d'événements est effectuée par le non-inscription de l'auditeur dans le bus.
  • Les valeurs de filtre des gestionnaires d'événements d'écoute sont définies après l'enregistrement.
  • Les valeurs de filtre sont liées au type d'événement et sont égales pour différents gestionnaires du même événement.
  • Pour déclarer les gestionnaires, des annotations des méthodes de l'auditeur sont utilisées.
  • Les gestionnaires doivent contenir un paramètre d'entrée avec le type de classe de l'événement traité.
  • Le type du paramètre du gestionnaire détermine les événements qu'il traitera.
  • Le gestionnaire est invoqué pour tous les héritiers de l'événement traité par celui-ci.
  • Deux types de gestionnaires d'événements sont utilisés:
    • Manipatives simples.
      • Lors de l'appel, les conditions de filtrage sont prises en compte.
      • L'ordre de l'appel n'est pas garanti.
    • Crochets.
      • Appelé avant d'appeler les gestionnaires simples.
      • Ignorer les conditions de filtrage.
      • L'ordre de l'appel correspond à l'ordre inverse de l'enregistrement.
  • Le type de gestionnaire sera déterminé par annotation.

Exemple d'utilisation

	// event class declaration
	Type
	  TFooEventObject = class (TbtkEventObject)
	  // ..........................
	  public
	    const sFooFilterName = ' FooFilter ' ;

	    constructor Create(ATopic: string; AFooFliter: string);

	    [EventFilter(sFooFilterName)] // filter parameter declaration
	    function FooFilter : string;

	  // ..........................
	  end ;

	// preparation of the listener
	  TFooEventListener = class
	  // ..........................
	  public

	    [EventHandler] // handler declaration
	    procedure FooHandler (AFooEvent: TFooEventObject);

	    [EventHook] // hook declaration
	    procedure FooHook (AEventObject: TFooEventObject);

	  // ..........................
	  end ;

	  EventBus := TbtkEventBus.GetEventBus( ' FooEventBus ' );

	  ListenerInfo := EventBus.Register(FooEventListener);

	// setting filter parameters
	  ListenerInfo.HandlerFilters[TFooEventObject][TFooEventObject.sEventFilterTopicName]. Value := ' TopicValue ' ;
	  ListenerInfo.HandlerFilters[TFooEventObject][TFooEventObject.sFooFilterName]. Value := ' FooFilterValue ' ;

	// creating and sending events
	  EventBus.Send(TFooEventObject.Create( ' TopicValue ' , ' FooFilterValue ' ));

	// listener unregistration
	  EventBus.Unregister(FooListener);

Exemple minimaliste d'utilisation Eventhook

	program EventHookExample;

        { $APPTYPE CONSOLE }

        uses
          System.SysUtils,
          btkEventBus;

        type
          TFooEventListener = class
          public
            [EventHook] // hook declaration
            procedure FooHook (EventObject: TbtkEventObject);
          end ;

        { TFooEventListener }

        // hook implementation
        procedure TFooEventListener.FooHook (EventObject: TbtkEventObject);
        begin
          Writeln(Format( ' ====== ' # 13 # 10 ' Event with topic "%s" sended ' , [EventObject.Topic]));
        end ;

        const
          ebFoo = ' FooEventBus ' ;
        var
          FooEventListener: TFooEventListener;
          FooTopicName: string;
        begin
          // register class for eventbus with name 'FooEventBus'
          RegisterEventBusClass(TbtkEventBus, ebFoo);

          FooEventListener := TFooEventListener.Create;
          try
            // register listener
            EventBus(ebFoo).Register(FooEventListener);

            Write( ' Write topic: ' );
            ReadLn(FooTopicName);

            // create and send event
            EventBus(ebFoo).Send(TbtkEventObject.Create(FooTopicName));
          finally
            FooEventListener.Free;
          end ;
          Readln;
        end .

Exemple minimaliste d'utilisation EventHandler

	program EventHookExample;

        { $APPTYPE CONSOLE }

        uses
          System.SysUtils,
          btkEventBus;

        type
          TFooEventListener = class
          public
            [EventHandler] // handler declaration
            procedure FooHandler (EventObject: TbtkEventObject);
          end ;

        { TFooEventListener }

        // handler implementation
        procedure TFooEventListener.FooHandler (EventObject: TbtkEventObject);
        begin
          Writeln(Format( ' Event with topic "%s" sended ' , [EventObject.Topic]));
        end ;

        const
          FooTopicName = ' FooTopic ' ;
        var
          FooEventListener: TFooEventListener;
          FooListenerInfo: TbtkListenerInfo;

        begin
          // register class for eventbus with empty name
          RegisterEventBusClass(TbtkEventBus);

          FooEventListener := TFooEventListener.Create;
          try
            // register listener and get listner info
            FooListenerInfo := EventBus.Register(FooEventListener);

            // set topicfilter for handler
            FooListenerInfo.HandlerFilters.Items[TbtkEventObject].Filters[TbtkEventObject.sEventFilterTopicName]. Value := FooTopicName;

            // create and send event
            EventBus.Send(TbtkEventObject.Create(FooTopicName));
          finally
            FooEventListener.Free;
          end ;
          Readln;
        end .