Dieser Artikel wurde maschinell übersetzt.

Grundlagen

Router im Service Bus

JUVAL LOWY

In meinem vorherigen zwei Spalten beschriebenen das zentrale Problem lösen .NET Service Bus entwickelt wurde, der Internetkonnektivität und Verwandte Sicherheitsprobleme. Service Bus bietet jedoch viel mehr als nur Konnektivität und messaging Relay. Diese Spalte beginnt mit der Registrierung Service und beschreibt dann Aspekte von Routern. Meiner nächsten Kolumne ausschließlich für Warteschlangen in der Wolke verwendet werden. In beiden Spalten wird neue leistungsfähige Entwurfsmuster beschrieben, wie Router, Warteschlangen und Meine Helfer kombiniert Klassen und tools, um allgemeine Benutzerfreundlichkeit zu optimieren.

Die Registrierung Dienste

Der .NET Service Bus bietet einen ATOM-Feed der überwachten Dienste auf die Basisadresse Projektmappe oder eines seiner Sub-URIs. Sie können den Feed anzeigen, indem Navigieren zu der Projektmappe (oder den URI) mit einem Browser. Der Feed dient als eine Registrierung und ein Verzeichnis für die Dienste und Aspekte (z. B. Router und Warteschlangen) in der Projektmappe.

Der Dienst ist standardmäßig nicht im Browser sichtbar. Sie steuern Dienst Registrierung veröffentlichen, indem Sie die ServiceRegistrySettings Endpunkt Verhalten-Klasse wie folgt definiert:

public enum DiscoveryType
{
Public,
Private
}
public class ServiceRegistrySettings : IEndpointBehavior
{
public ServiceRegistrySettings();
public ServiceRegistrySettings(DiscoveryType discoveryType);
public DiscoveryType DiscoveryMode
{get;set;}
public string DisplayName
{get;set;}
}

Die Host muss dieses Verhalten programmgesteuert an jedem Endpunkt hinzufügen, Sie in der Registrierung veröffentlichen möchten. (Es gibt keine konfigurierbare Vergleichsverhalten.) Um alle Endpunkte in der Registrierung zu veröffentlichen, würden Sie z. B. den Code hier verwenden:

IEndpointBehavior registeryBehavior =
new ServiceRegistrySettings(DiscoveryType.Public);
ServiceHost host = new ServiceHost(typeof(MyService));
foreach(ServiceEndpoint endpoint in host.Description.Endpoints)
{
endpoint.Behaviors.Add(registeryBehavior);
}
host.Open();

Abbildung 1 die Services Bus Explorer

Damit Service Bus visualisieren, entwickelte ich der Service Bus-Explorer, im Abbildung 1 angezeigt. Das Tool akzeptiert den Namen der Lösung zu untersuchen und nach der Anmeldung den Feed, wird für Sie die ausgeführten Dienste darstellen. Der Explorer wird lediglich das ATOM-Feed zu analysieren und die Elemente in der Struktur auf der linken Seite. Können Sie mehrere Lösungen untersuchen und finden Sie im rechten Fensterbereich die Lösung Verwaltungsseiten. Das Tool zeigt die verfügbaren Router und Warteschlangen auch und ist sehr praktisch in verwalten diese.

Wolke als Interceptors

Service Bus wurde tatsächlich ursprünglich entwickelt, um die Akut Konnektivität von Anrufen über das Web Probleme. Es hat jedoch das Potenzial für vieles mehr. Vergleichen Sie die grundlegende Architektur Windows Communication Foundation (WCF) mit den Service Bus-Architektur. In beiden Fällen der Client nicht direkt mit dem Dienst interagieren, jedoch stattdessen die Aufrufe von Middleware abgefangen werden. Im Fall von regulären WCF ist der Middleware der Proxy und die Interpretation Kette führt, dass des Diensts, wie dargestellt in Abbildung 2.

Bei der die weitergeleitete Aufrufe besteht der Middleware regulären WCF-Middleware und den Service Bus selbst, wie in Abbildung 3 dargestellt. Aus Sicht der Architektur, dies ist die gleichen Design – abzufangen, die Aufrufe an zusätzlichen Nutzen bieten. In der aktuellen Version des Service Bus ist der zusätzliche Wert die Möglichkeit zum Installieren von Routern und Warteschlangen. In der Tat glauben ich Service Bus hat hervorragende Potenzial für leistungsfähige Interceptors, und zweifellos weitere Aspekte werden verfügbare Zeit.

Abbildung 2 reguläre WCF Aufrufe abgefangen

Abbildung 3 die Wolke als Interceptors

Verbindungen als Router

In den Service Bus ist jeder URI in der Projektmappe tatsächlich eine adressierbare messaging Abzweigungspunkte. Der Client kann eine Nachricht an die Abzweigungspunkte senden und die Abzweigungspunkte kann zu den Diensten relay. Jede Verbindung kann jedoch auch als Router verwendet werden. Die Router mehrere Dienste abonnieren können, und der Router kann dieselbe Client-Nachricht für alle oder nur einen einzigen, weiterleiten, wie in Abbildung 4 dargestellt.

Der Client wird von den Diensten hinter dem Router entkoppelt, und weit, wie der Client besorgt ist, gibt es möglicherweise nicht sogar alle Dienste hinter dem Router. Der Client muss wissen, ist, in dem der Router Nachrichten senden muss befindet. Diese Vertrauensstellungen des Router mit der entsprechenden Verteilung-Richtlinie konfiguriert werden. Wegen der Indirectness die Nachrichten sind grundsätzlich eine Möglichkeit, und in der Tat WCF erfordert, dass die vom Client und den abonnierenden Diensten verwendete Bindung die unidirektionale Relay-Bindung ist. Der Client hat keine Möglichkeit, der die Ergebnisse von den Diensten der empfängt oder wird eigentlich der Dienstseite Fehler. Dies wäre der Fall, selbst wenn die Bindung nicht eine Möglichkeit. Wenn die Client-Nachricht an mehrere Dienste wird befindet im Multiplexmodus, dann ist per Definition gibt es keine Bedeutung für Ergebnisse der Operation (aus dem Dienst?) oder Fehlern (von dem Dienst?). Es gibt auch keine Möglichkeit für die Dienste wieder zu Ihren Client aufrufen.

Abbildung 4 die Services Bus als Router

Richtlinie für Router

Der Lösung Administrator verwaltet die Router unabhängig von Diensten. Jeder Router muss eine Richtlinie, dessen Verhalten und Gültigkeitsdauer sein. Aus dem Feld muss der Lösung Administrator programmgesteuerte Aufrufe erstellen und Verwalten von Routern ausführen. Alle messaging Abzweigungspunkte Richtlinien Ableitung von der abstrakten-Klasse JunctionPolicy, im Abbildung 5 angezeigt.

Discoverability (Erkennbarkeit)-Verbindung-Eigenschaft ist eine Enumeration des Typs DiscoverabilityPolicy. Er steuert, ob die Verbindung in das ATOM enthaltene feed der Lösung. Discoverability (Auffindbarkeit) wird standardmäßig auf DiscoverabilityPolicy.Managers, d. h. eine private Richtlinie. Einstellen von DiscoverabilityPolicy.Public veröffentlicht den Feed. ExpirationInstant-Eigenschaft steuert die Lebensdauer der Verbindung. Nachdem die Richtlinie abgelaufen ist, wird die Verbindung entfernt. ExpirationInstant wird standardmäßig ein Tag. Natürlich, möglicherweise sein oder nicht ausreichend für Ihre Router (oder Warteschlangen) in der Regel benötigen Sie es auf den Wert gewünschten festlegen und Überwachen es. Die Verbindung ist in Kürze ablaufen, sollten Sie es erneuern, wenn die Verbindung verwendet wird. Aufgerufen, erneuern die “ Leasedauer eingeben von der Verbindung, und ich rufen Sie die Partei, die der Lease der “ Sponsor. eingeben erweitert Schließlich steuert die TransportProtection-Eigenschaft die die Nachricht an dem Schnittpunkt Sicherheit übertragen. Beim Buchen oder Abrufen von unformatierte WCF-Nachrichten an oder von den messaging Verknüpfungen, sind Sie der Wert der TransportProtectionPolicy.AllPaths mit Transportsicherheit beschränkt. Transportsicherheit ist die Standardeinstellung für alle Abzweigungspunkte Richtlinien und sollten Sie niemals auf einen anderen Wert festlegen.

Abbildung 5 die JunctionPolicy-Klasse

public enum DiscoverabilityPolicy
{
Managers,Public //More values
}
public enum TransportProtectionPolicy
{
None,AllPaths
}
[DataContract]
public abstract class JunctionPolicy
{
public JunctionPolicy();
public JunctionPolicy(JunctionPolicy policyToCopy);
public DateTime ExpirationInstant
{get;set;}
public DiscoverabilityPolicy Discoverability
{get;set;}
public TransportProtectionPolicy TransportProtection
{get;set;}
//More members
}

Abbildung 6 die RouterPolicy-Klasse

public enum MessageDistributionPolicy
{
AllSubscribers,
OneSubscriber
}
[DataContract]
public class RouterPolicy : JunctionPolicy,...
{
public RouterPolicy();
public RouterPolicy(RouterPolicy otherRouterPolicy);
public int MaxSubscribers
{get;set;}
public MessageDistributionPolicy MessageDistribution
{get;set;}
//More members
}

Jede Richtlinie Router wird mit der Klasse RouterPolicy, definiert in Abbildung 6 ausgedrückt. Hier die zwei wichtigsten Eigenschaften sind MaxSubscribers und MessageDistribution. Wie der Name schon sagt, ist MaxSubscribers die maximale Anzahl gleichzeitiger Abonnenten an den Router eine Verbindung herstellen. Der Standardwert ist 1 und der Maximalwert ist 50. Nach der Router überlastet-Out Fehlermeldung zusätzliche Dienste abonnieren möchten. MessageDistribution ist eine Enumeration des Typs MessageDistributionPolicy und MessageDistributionPolicy.OneSubscriber – d. h. nur eine den abonnierenden Diensten standardmäßig erhält die Nachricht. Einstellen von MessageDistributionPolicy.AllSubscribers übermittelt die Nachricht an alle Dienste.

Verwalten der Richtlinie für Router

Die RouterManagementClient-Klasse, hier, um Ihre Router Richtlinien verwalten können:

public static class RouterManagementClient
{
public static RouterClient CreateRouter(
TransportClientEndpointBehavior credential,
Uri routerUri,RouterPolicy policy);
public static void DeleteRouter(
TransportClientEndpointBehavior credential,
Uri routerUri);
public static RouterClient GetRouter(
TransportClientEndpointBehavior credential,
Uri routerUri);
public static RouterPolicy GetRouterPolicy(
TransportClientEndpointBehavior credential,
Uri routerUri);
public static DateTime RenewRouter(
TransportClientEndpointBehavior credential,
Uri routerUri,TimeSpan requestedExpiration);
}

RouterManagementClient ist eine statische Klasse und alle seine Methoden erfordern das Anmeldeinformationsobjekt (des Typs TransportClientEndpointBehavior, in meinem letzten Artikel beschrieben (siehe msdn.microsoft.com/magazine/dd942847.aspx). Der folgende Code veranschaulicht einen einfachen Router und eine Richtlinie erstellen:

Uri routerAddress =
new Uri(@"sb://MySolution.servicebus.windows.net/MyRouter/");
TransportClientEndpointBehavior credential = ...;
RouterPolicy policy = new RouterPolicy();
policy.ExpirationInstant = DateTime.UtcNow + TimeSpan.FromMinutes(5);
policy.MaxSubscribers = 4;
policy.MessageDistribution = MessageDistributionPolicy.AllSubscribers;
RouterManagementClient.CreateRouter(credential,routerAddress,policy);

Im Beispiel Sie ein Router Richtlinienobjekt instanziiert und die Richtlinie auf einige Werte, z. B. die Nachricht an alle teilnehmende Dienste verteilen und beschränken den Router von mehr als vier Abonnenten. Der Router ist konfiguriert, um eine kurze Lebensdauer nur fünf Minuten. Alle es dauert, den Router installieren, ist die CreateRouter-Methode des RouterManagementClient mit der Richtlinie und einige gültigen Anmeldeinformationen aufrufen.

Als Alternative zum programmgesteuerten aufrufen können Sie eigene Dienste Bus-Explorer anzeigen und Ändern von Routern. Sie können einen neuen Router erstellen, indem seine Adresse und verschiedene Eigenschaften der Richtlinie angeben. In nahezu identisch können Sie alle Router in der Projektmappe löschen.

Auch können überprüfen und ändern die Richtlinien von vorhandenen Routern indem Sie in der Struktur der Lösung und interagieren mit ihren Eigenschaften im rechten Bereich, wie in Abbildung 7.

Alles, was der Client benötigt zum Bereitstellen von Nachrichten an einen Router ist das Erstellen eines Proxys, dessen Adresse die Adresse des Routers ist, und rufen Sie den Proxy.

Abonnieren eines Routers

Für einen Dienst, Nachrichten von einem Router empfangen müssen Sie zuerst an den Router abonnieren, indem der Host hinzugefügt einen Endpunkt, dessen Adresse ’s Router-Adresse ist. Eine Möglichkeit, dies ist mithilfe der Helper-Klasse RouterClient, wie folgt definiert:

public sealed class RouterClient
{
public ServiceEndpoint AddRouterServiceEndpoint<T>(
ServiceHost serviceHost);
//More members
}

Die Methoden der RouterManagementClient, die erstellen oder erhalten einen Router, zurückgegeben eine Instanz des RouterClient. Sie müssen die AddRouterServiceEndpoint < T > aufrufenMethode mit einer Instanz Ihrem Dienst Host. Sie können auch einfach nur einen Endpunkt hinzufügen, um die Host (entweder programmgesteuert oder in einer Konfigurationsdatei) dessen Adresse ist die Adresse des Routers. Beispiel:

<service name = "MyService">
<endpoint
address = "sb://MySolution.servicebus.windows.net/MyRouter/"
binding = "netOnewayRelayBinding"
contract = "..."
/>
</service>

Abbildung 7 A Router in der Services Bus Explorer

Abbildung 8 Router zu Router abonnieren

Router verwenden

Router verfügen über drei verwendet. Der erste ist die gleiche Nachricht an mehrere Dienste übertragen. Der klassische Fall ist, Ereignisse zu abonnieren Dienste Service Bus als eine Ereignisse-Hub Middleware behandelt natürlich veröffentlichen. Wie in meinem Artikel in der Ausgabe April beschrieben (siehe msdn.microsoft.com/magazine/dd569756.aspx), es ist mehr zu veröffentlichen, als das Auge erfüllt, damit ich Diskussion Ereignisse an das Ende dieser Kolumne verzögern-Ereignis.

Die zweite Verwendung für einen Router ist als ein Lastenausgleich zwischen Diensten. Wenn Sie die Router-Richtlinie zum Verteilen von Nachrichten an nur einen einzelnen Abonnenten konfigurieren, agiert der Router in Kraft als ein Lastenausgleich zwischen den abonnierenden Diensten. Alle Systeme zum Lastenausgleich folgen einige Algorithmus entscheiden, welcher Dienst die nächste Nachricht behandelt. Häufige Algorithmen sind Round-Robin, zufällige, einige fair Scoreboard sowie Message queuing. Meine Tests gibt an, dass Service Bus ein Pseudo–round-Robin verwendet –, er fair Round-Robin einige 95 Prozent der Zeit war. Um einen Lastenausgleich Router erstellen zu optimieren, bietet Meine Hilfsklasse ServiceBusHelper eine Reihe überladener Methoden auf CreateLoadBalancingRouter, hier:

public static partial class ServiceBusHelper
{
//Uses CardSpace for credential
public static void CreateLoadBalancingRouter(string balancerAddress);
/* Additional CreateLoadBalancingRouter(...)
with different credentials */
}

CreateLoadBalancingRouter erstellt einen Router mit einer Richtlinie, die die Nachrichten an einen einzelnen Abonnenten verteilt. Es erkennt auch, ob der Router vorhanden, ist bevor Sie ihn erstellen und automatisch der Router Lease erneuert. Die Implementierung der CreateLoadBalancing-Router ist im Codedownload für den Artikel enthalten.

Alle öffentlichen Methoden der CreateLoadBalancingRouter werden unterschiedliche Anmeldeinformationen Typen (die Implementierung ich übermittle verwendet CardSpace), erstellen Sie eine Instanz der TransportClientEndpointBehavior und Aufruf einer internen CreateLoadBalancingRouter überladen. Die überladene Version erstellt eine Richtlinie für den Lastenausgleich, die auch den Router in der ATOM-feed veröffentlicht und ruft CreateRouter mit dem angegebenen Richtlinie und Anmeldeinformationen. CreateRouter wird zunächst mit die RouterExists-Methode überprüfen, ob der Router bereits erstellt wurde. Leider ist die einzige Möglichkeit, überprüfen Sie, ob ein Fehler, auftritt wenn Sie den Router Richtlinie erhalten.

Wenn der Router vorhanden ist, gibt CreateRouter seine entsprechende RouterClient zurück. Wird wenn der Router nicht vorhanden ist, CreateRouter zuerst ein Zeitgeber erstellt den Ablauf der Lease überwachen verwenden einen Lambda-Ausdruck als ein Sponsor. Die Gültigkeitsdauer der Lease Ende erreicht, ruft der Zeitgeber den Lambda-Ausdruck, der die Lease erneuern. CreateRouter erstellt dann den Router.

Router zu Router

Die dritte Router wird zum Weiterleiten von Nachrichten an andere Verbindungen, wie z. B. andere Router (oder Warteschlangen). Um einen Router an einen anderen zu abonnieren, verwenden Sie die SubscribeToRouter-Methode des RouterClient, hier dargestellt:

public sealed class RouterClient
{
public RouterSubscriptionClient SubscribeToRouter(
RouterClient routerClient,
TimeSpan requestedTimeout);
//More members
}
[Serializable]
public class RouterSubscriptionClient
{
public DateTime Expires {get;}
public DateTime Renew(TimeSpan requestedExpiration,
TransportClientEndpointBehavior credential);
public void Unsubscribe(TransportClientEndpointBehavior credential);
//More members
}

SubscribeToRouter akzeptiert der Router-Client des Routers Sie abonnieren möchten, und gibt eine Instanz der RouterSubscriptionClient zurück. Die wichtigsten Verwendungen von RouterSubscriptionClient ist, zu kündigen und Abonnement Lease zu erneuern.

Genommen Sie an, Sie sind Dienst A, Dienst B und c-Dienst Sie verlangen, dass jeder Clientaufruf immer Dienst A und B-Dienst oder Dienst c geht. (Genommen Sie an, Sie laden Saldo Dienst B und C-Dienst aber beibehalten auch einen Datensatz für alle Aufrufe in der Logbook-Dienst ein müssen). Die Router-Richtlinien an alle Abonnenten bzw. an einen einzelnen Abonnenten übertragen bisher beschriebenen sind unzureichend. Jedoch können Sie die Anforderungen erfüllen problemlos mithilfe von zwei Router wie in acht dargestellt.

Der Client übermittelt die Nachrichten an einen der obersten Ebene Router mit einer Richtlinie Verteilung an alle Dienste. Dienst A abonniert der obersten Ebene Router. Ein Subrouter mit einer Richtlinie Verteilung eines einzelnen Abonnenten abonniert auch der obersten Ebene Router. Beide Dienst B und C-Dienst abonnieren, Subrouter. Abbildung 9 gezeigt, die Konfiguration erforderlichen Router und wie Subrouter an den oberen Router abonnieren.

Wenn es an einen Dienst abonnieren einen abonnierenden Router stammt, ist eine wichtige Detail im Hinblick auf das Abonnement, das unterscheidet sich von der obersten Ebene Router abonnieren. Der Dienstendpunkt muss, dass es bereit, Nachrichten aus den abonnierenden Router empfangen ist, obwohl an der obersten Ebene Router die Nachrichten adressiert sind. Dieser Hinweis wird vorgenommen, indem Sie die listening URI-Eigenschaft des Endpunkts für den Dienst abonnieren während des Dienstendpunkts selbst den obersten Ebene Router adressieren. Die Adressen Adressen im Abbildung 9, beide Dienst B und Dienst C# müsste ihre Endpunkte wie folgt definieren:

<service name = "MyService">
<endpoint listenUri =
"sb://MySolution.servicebus.windows.net/MySubRouter/"
address = "sb://MySolution.servicebus.windows.net/MyTopRouter/"
binding = "netOnewayRelayBinding"
contract = "..."
/>
</service>

Sie können diese Einstellung mit der folgenden Service Host Erweiterung automatisieren:

public static partial class ServiceBusHelper
{
public static void SubscribeToRouter(this ServiceHost host,
string subRouterAddress)
{
for(int index = 0;
index < host.Description.Endpoints.Count;index++)
{
host.Description.Endpoints[index].ListenUri =
new Uri(subRouterAddress);
}
}
//More members
}

Angenommen, ein Router mehrere Router abonnieren kann, sollte die Dienste, die den abonnierenden Router abonnieren sehr beachten, welche Adresse--, der obersten Ebene Router--Sie Nachrichten empfangen möchten.

Beachten Sie, dass den obersten Ebene Router entfernen oder das Abonnement beenden die Subrouters von Clients Nachrichten abgeschnitten. Dies ist wiederum ein Feature von Sortierungen für Administratoren Lösung, diese Schritt zum effektiv Sie Dienste beenden, ohne Schließen Sie Ihre Hosts verwenden können.

Abbildung 9 Router zu Router abonnieren

Uri topRouterAddress =
new Uri(@”sb://MySolution.servicebus.windows.net/MyTopRouter/");
Uri subRouterAddress =
new Uri(@”sb://MySolution.servicebus.windows.net/MySubRouter/");
TransportClientEndpointBehavior credential = ...;
RouterPolicy topRouterPolicy = new RouterPolicy();
subRouterPolicy.MaxSubscribers = 20;
topRouterPolicy.MessageDistribution =
MessageDistributionPolicy.AllSubscribers;
RouterClient topRouterClient = RouterManagementClient.CreateRouter(
credential,topRouterAddress,topRouterPolicy);
RouterPolicy subRouterPolicy = new RouterPolicy();
subRouterPolicy.MaxSubscribers = 30;
subRouterPolicy.MessageDistribution =
MessageDistributionPolicy.OneSubscriber;
RouterClient subRouterClient = RouterManagementClient.CreateRouter(
credential,subRouterAddress,subRouterPolicy);
RouterSubscriptionClient subscription = subRouterClient.
SubscribeToRouter(topRouterClient,
TimeSpan.MaxValue);
//Sometime later
subscription.Unsubscribe(credential);

Verwenden von Routern für Ereignisse

Wie bereits erwähnt, kann messaging Abzweigungspunkte in Service Bus als Hub brutale Ereignisse und Broadcastmeldungen an Dienste abonnieren. Sie müssen eine Richtlinie für Router installieren, die maximiert die Anzahl der Abonnenten und alle Abonnenten benachrichtigt. Der Mängel dadurch sind so ähnlich wie Verwenden der Ereignisse binden (erwähnt in meinem Artikel im April um msdn.microsoft.com/magazine/dd569756.aspx). Kein Abonnement pro Vorgang und daher die Abonnenten (alle) immer erhalten alle Ereignisse auch Ereignisse, die Sie über (die) unwichtig, die einfach einen entsprechenden Endpunkt verfügen.

Die Lösung ist nicht um einen einzelnen Router alle Ereignisse behandelt, sondern erstellen Sie einen Router pro Ereignis zu erstellen. Dienste, die nur das Ereignis interessiert sind werden das Ereignis ’s bestimmte Router abonnieren. Als mit den Ereignissen binden, müssen einen Router pro Ereignis erfolgt durch jeden Abonnenten eine Instanz Host pro Vorgang, verwalten müssen, da eine einzelne Host, alle Router überwacht, nichts zum Filtern der Ereignisse wird. Der Abonnent muss öffnen und schließen Sie die entsprechenden Host zu abonnieren oder kündigen das Ereignis. Dafür ist mühsam und sich wiederholende Code erforderlich.

Die gute Nachricht ist, dass die Hilfsklasse EventsRelayHost, die ich in meinem letzten Artikel dargestellt genau bereits tut und mit ein wenig refactoring einer gemeinsamen Basisklasse EventsHost aufgerufen, es für die Verwendung mit Routern anstatt die Ereignisse Relay Bindung angepasst sein kann. (Für Router benötigen Sie nur die unidirektionale Relay-Bindung.)

Zuerst definiert die abstrakte Basisklasse, EventsHost, der hier gezeigten:

//Partial listing
public abstract class EventsHost
{
public EventsHost(Type serviceType,string baseAddress);
public EventsHost(Type serviceType,string[] baseAddresses);
public abstract void SetBinding(NetOnewayRelayBinding binding);
public abstract void SetBinding(string bindingConfigName)
protected abstract NetOnewayRelayBinding GetBinding();
public void Subscribe();
public void Subscribe(Type contractType);
public void Subscribe(Type contractType,string operation)
public void Unsubscribe();
public void Unsubscribe(Type contractType);
public void Unsubscribe(Type contractType,string operation);
}

Zwei Unterklassen, EventsRelayHost und EventsRouterHost, werden in EventsHost Implementierung .der Abbildung 10 definiert und EventsRelayHost wird in meinem letzten Artikel angezeigt.

Abbildung 10 EventsRelayHost definieren

//For use with the events binding, see previous column
public class EventsRelayHost : EventsHost
{...}
public class EventsRouterHost : EventsHost
{
public override void SetBinding(NetOnewayRelayBinding binding)
{
RelayBinding = binding;
}
public override void SetBinding(string bindingConfigName)
{
SetBinding(new NetOnewayRelayBinding(bindingConfigName));
}
protected override NetOnewayRelayBinding GetBinding()
{
return RelayBinding ?? new NetOnewayRelayBinding();
}
}

EventsRouterHost entspricht EventsRelayHost--beide verwalten eine Host pro Ereignis und es ist wichtig, nicht ist die Adresse, die Sie überwachen, die Adresse eines Endpunkts Ereignisse oder von einem Router. Der einzige Unterschied besteht darin, dass die EventsRouterHost die unidirektionale Bindung an die Ereignisse im Gegensatz zum Binden von EventsRelayHost verwendete Ereignisse empfangen Relay verwenden muss. Außer, sollten EventsRouterHost und EventsRelayHost identisch sein. Dies spiegelt sich in der Tatsache wider, dass beide von EventsHost, abgeleitet die Aufgaben werden der Verwaltung der Hosts. EventsRouterHost und EventsRelayHost überschreiben Sie lediglich die Bindung Management-Methode.

Abgesehen entspricht mit EventsRouterHost mit EventsRelayHost, wobei abonnieren und kündigen anstelle von öffnen und schließen die Host funktioniert:

EventsHost host = new EventsRouterHost(typeof(MyService),
"sb://MySolution.servicebus.windows.net/...");
host.Subscribe();
...
host.Unsubscribe(typeof(IMyEvents),"OnEvent2");

Der vorherige Code öffnet und schließt einen entsprechenden Host intern, nur das Ereignis überwacht.

Ereignis-Router erstellen

EventsRouterHost erfordert der Lösung Administrator die Router im Voraus zu konfigurieren, und es wird nicht versucht, die Router zu erstellen. Ich vorgenommen, Auswahl bewusst, Konfigurieren von den Routern und deren Richtlinien von den Abonnenten zu trennen. Alle der Client sieht ’s Abzweigungspunkte Adresse ist, und verwenden, um ein Ereignis über eine unidirektionale Relay Bindung auszulösen, können Sie die gleichen EventRelayClientBase in meinem letzten Artikel vorgestellten, um die Ereignisse zu veröffentlichen.

Um den Aufwand erstellen die Ereignis-Router zu optimieren, können meine ServiceBusHelper Sie um die Router zu erstellen:

public static partial class ServiceBusHelper
{
//Uses CardSpace for credential
public static RouterClient[] CreateEventRouters(string baseAddress,
Type contractType);
/* Additional CreateEventRouters(...) with different credentials */
}

CreateEventRouters akzeptiert die Router-Basisadresse. Es fügt an der Basisadresse, den Namen der der Vertrag und der Name des Vorgangs und öffnet einen einzelnen Router unter der Adresse. Betrachten Sie beispielsweise die folgende Basisadresse:

sb://MySolution.servicebus.windows.net/

und diese Vertragsdefinition:

[ServiceContract]
interface IMyEvents
{
[OperationContract(IsOneWay = true)]
void OnEvent1();
[OperationContract(IsOneWay = true)]
void OnEvent2(int number);
[OperationContract(IsOneWay = true)]
void OnEvent3(int number,string text);
}

CreateEventRouters erstellt die folgenden Router:

sb://MySolution.servicebus.windows.net/IMyEvents/OnEvent1/
sb://MySolution.servicebus.windows.net/IMyEvents/OnEvent2/
sb://MySolution.servicebus.windows.net/IMyEvents/OnEvent3/

Dies ist genau, was EventsRouterHost erwartet. In diesem Artikel Codedownload stellt eine partielle Liste der Implementierung von ServiceBusHelper.CreateEventRouters, ohne die Fehlerbehandlung und ein paar der überladenen Sicherheitsmethoden bereit.

Öffentliche CreateEventRouters, die keine Anmeldeinformationen akzeptiert standardmäßig über CardSpace, indem Sie ein TransportClientEndpointBehavior-Objekt erstellt und an die interne Methode zu übergeben. Diese Methode verwendet Reflektion, um die Auflistung der Vorgänge auf der Service-Vertragstyp abzurufen. Für jeden Vorgang ruft es die CreateEventRouter-Methode auf, übergeben Sie die Adresse des Routers und die Richtlinie. Die Richtlinie für jeden Router die Anzahl der Abonnenten maxes, übermittelt die Ereignisse an alle und den Router das ATOM-feed veröffentlicht.

Router Vs. die Ereignisse binden

Für den meisten Fällen der Cloud-basierten publish subscribe-Lösungen, empfehle ich die Ereignisse binden. Erstens finde ich das Limit die maximale Anzahl von Abonnenten eine schwerwiegende Handicap werden. Es ist möglich, dass 50 für Ihre Anwendung mehr als angemessen werden. Jedoch, was geschieht, wenn müssen über einen Zeitraum mehrere Abonnenten unterstützen? Keine solche Beschränkung ist für die Bindung Ereignisse auferlegt. Andere Probleme mit dem Router Ansatz werden die Anforderung die Routern im Voraus erstellen und Lease Förderung kümmern. Die Ereignisse binden, funktioniert die andererseits als brutale Ad-hoc-Router ohne diese Verbindlichkeiten.

Es gibt zwei speichern Graces für die Ereignisse routerbasierte Verwaltung. Der erste ist die Option für die Systemadministratoren mit Tools wie den Dienste-Bus-Explorer die Abonnenten verwalten auch indirekt durch den Router verwalten. Der zweite und weitere Ubstantial ist die Fähigkeit zum Kombinieren von Routern mit Warteschlangen in der Warteschlange Herausgeber und Warteschlangen Abonnenten Erstellen der Ansatz in meiner nächsten Kolumne beschrieben wird.

Juval Lowy * ist Softwarearchitekt mit IDesign WCF-Schulungen und Beratung Architektur bereitstellen. Sein neues Buch heißt “ Programming WCF Services, 2nd Edition eingeben (O’Reilly, 2008). Er ist außerdem der regionalen Microsoft Director für Silicon Valley. Erreichen Sie Juval unter idesign.net.*