System.AddIn: Eventing zwischen Host und AddIn
Zum System.AddIn Namespace habe ich bereits das ein oder andere geschrieben. Das Beispiel das ich benutze SayHello() ist mal wieder einfach ein "Hello, world." Beispiel. Des Weiteren habe ich in diesem Beispiel lediglich im Add-In eine Funktion aufgerufen, das Add-In selbst hat keinerlei Mechanismus gehabt um sich beim Host entsprechend auf Events zu registrieren.
Ich habe von Jesse Kaplan ein Beispiel für eine Definition gefunden, wie man Eventing im Interface deklarieren kann. Leider hat Jesse kein lauffähiges Demo mit gepostet. Insofern habe ich einfach mein TechTalk Beispiel genommen und das Eventing in einem anderen Add-In implementiert.
Mein Add-In registriert sich einfach auf einen Host Event und wird jedesmal durch den Host notifiziert, wenn das Ereignis eintritt. Hier ist zuerst einmal die Interfacedefinition:
using System;
using System.AddIn.Contract;
using System.AddIn.Pipeline;
namespace Demo.Contracts
{
public interface HostEventsContract : IContract
{
void OnNotification( INotificationHandlerContract handler );
void StartNotifications( int numberOfNotifications );
}
[AddInContract]
public interface RetrieveHostEventsContract : IContract
{
void Initialize( HostEventsContract hostEvents );
void Shutdown();
}
public interface INotificationHandlerContract : IContract
{
void Handler( INotificationEventArgsContract args );
}
public interface INotificationEventArgsContract : IContract
{
string GetMessage();
}
}
Die verschiedenen Contracts definieren nun unsere Nachrichten die verschickt werden. Jetzt gilt es für jeden Contract noch einen View zu definieren. Der View muss jeweils auf der Add-In-Seite und auf der Host-Seite zur Verfügung stehen, obwohl er eigentlich identisch von der Signatur her ist. Hier als die entsprechenden View Basisklassen:
using System;
using System.AddIn.Pipeline;
namespace Demo.View.Addin
{
public abstract class HostEvents
{
public System.EventHandler<NotificationEventArgs> OnNotification;
public abstract void StartNotifications( int numberOfNotifications );
}
[AddInBase]
public abstract class RetrieveHostEvents
{
public abstract void Initialize( HostEvents hostEvents );
public abstract void Shutdown();
}
public abstract class NotificationEventArgs : System.EventArgs
{
public abstract string GetMessage();
}
}
Dies ist der View des Add-Ins. Der des Hosts sieht identisch aus, man muss lediglich das AddInBaseAttribute aus Zeile 12 entfernen.
Nun benötigt man noch entsprechende Adapter. Die Adapter sorgen dafür das sich View und Contract miteinander verbinden können und der jeweiligen anderen Seite der Pipeline sich valide ansprechen lassen. Kommt man vom Add-In zum Host so spricht man den Contract an, während die Implementierung auf Host-Seite mit dem View arbeitet. Der entsprechende Adapter sorgt einfach dafür das dies Reibungslos funktioniert. Das ist leider auch das Problem beim Schreiben von Adaptern und Views. Es ist richtig viel Fleißarbeit. Ich hoffe das sich bald jemand aus der Community erbarmt ein entsprechenden Code-Generator zur Verfügung zu stellen, der sich dann auch noch elegant steuern lässt.
Exemplarisch wird der Source des HostEvents-Adapters gezeigt.
using System;
namespace Demo.Adapter.Addin
{
public class HostEventsAddInAdapter
{
internal static Demo.View.Addin.HostEvents
ContractToViewAdapter( Demo.Contracts.HostEventsContract contract )
{
return new HostEventsContractToViewAddInAdapter( contract );
}
internal static Demo.Contracts.HostEventsContract
ViewToContractAdapter( Demo.View.Addin.HostEvents view )
{
return new HostEventsViewToContractAddInAdapter( view );
}
}
}
Der Adapter stellt je nach Richtung entsprechende Methoden zur Konvertierung der Schnittstelle zur Verfügung. Einmal von Contract nach View und dann noch von View nach Contract. Schaut man sich nun noch HostEventsContractToViewAddInAdapter an, wird man feststellen das hier weitere Adapter benötigt werden, nämlich jene, die die eigentlichen Events enthalten.
using System;
using System.AddIn.Pipeline;
namespace Demo.Adapter.Addin
{
public class HostEventsContractToViewAddInAdapter : Demo.View.Addin.HostEvents
{
private Demo.Contracts.HostEventsContract contract;
private ContractHandle handle;
public HostEventsContractToViewAddInAdapter(
Demo.Contracts.HostEventsContract contract )
{
this.contract = contract;
this.handle = new ContractHandle( contract );
this.contract.OnNotification(
new NotificationHandlerViewToContractAddInAdapter( this ) );
}
public override void StartNotifications( int numberOfNotifications )
{
contract.StartNotifications( numberOfNotifications );
}
internal Demo.Contracts.HostEventsContract GetSourceContract()
{
return this.contract;
}
}
}
Zu sehen in Zeile 17.
Und so geht es weiter und weiter und weiter. Deshalb lege ich ein funktionierendes Beispiel hier ab. Viel Spaß damit!