Reliable Services-értesítések

Az értesítések lehetővé teszik az ügyfelek számára, hogy nyomon kövessék azokat a módosításokat, amelyek egy olyan objektumon történnek, amely iránt érdeklődnek. Kétféle objektum támogatja az értesítéseket: Reliable State Manager és Reliable Dictionary.

Az értesítések használatának gyakori okai a következők:

• Materializált nézetek létrehozása, például másodlagos indexek vagy a replika állapotának összesített szűrt nézetei. Ilyen például a Reliable Dictionary összes kulcsának rendezett indexe.
• Figyelési adatok küldése, például az elmúlt órában hozzáadott felhasználók száma.

Az értesítések a műveletek alkalmazásának részeként aktiválódnak. Elsődleges replikán a műveletek a kvórum nyugtázása után lesznek alkalmazva a vagy this.StateManager.GetOrAddAsync()a transaction.CommitAsync() részeként. A másodlagos replikákon a replikációs várólista adatfeldolgozási műveleteit alkalmazza a rendszer. Emiatt az értesítéseket a lehető leggyorsabban kell kezelni, és a szinkron események nem tartalmazhatnak költséges műveleteket. Ellenkező esetben negatív hatással lehet a tranzakciófeldolgozási időre és a replika-buildekre.

Reliable State Manager-értesítések

A Reliable State Manager a következő eseményekről biztosít értesítéseket:

• Tranzakció
  • Véglegesítés
• Állapotkezelő
  • Újraépítés
  • Megbízható állapot hozzáadása
  • Megbízható állapot eltávolítása

A Reliable State Manager nyomon követi az aktuális biztonsági tranzakciókat. A tranzakció állapotának egyetlen olyan változása, amely az értesítés aktiválását okozza, egy tranzakció véglegesítése.

A Reliable State Manager olyan megbízható állapotok gyűjteményét tartja fenn, mint a Reliable Dictionary és a Reliable Queue. A Reliable State Manager értesítéseket küld, ha ez a gyűjtemény megváltozik: a rendszer megbízható állapotot ad hozzá vagy távolít el, vagy a teljes gyűjtemény újraépül. A Reliable State Manager gyűjtemény három esetben újjáépül:

• Helyreállítás: Amikor egy replika elindul, visszaállítja az előző állapotát a lemezről. A helyreállítás végén a NotifyStateManagerChangedEventArgs használatával aktivál egy eseményt, amely a helyreállított megbízható állapotok készletét tartalmazza.
• Teljes másolás: Mielőtt egy replika csatlakozni tud a konfigurációs csoporthoz, létre kell készíteni. Néha ehhez a Reliable State Manager állapotának teljes másolatát kell alkalmazni az elsődleges replikából a tétlen másodlagos replikára. A másodlagos replikán található Reliable State Manager a NotifyStateManagerChangedEventArgs használatával aktivál egy olyan eseményt, amely az elsődleges replikából beszerzett megbízható állapotkészletet tartalmazza.
• Visszaállítás: Vészhelyreállítási forgatókönyvekben a replika állapota visszaállítható egy biztonsági mentésből a RestoreAsync használatával. Ilyen esetekben a Reliable State Manager az elsődleges replikán a NotifyStateManagerChangedEventArgs használatával aktivál egy olyan eseményt, amely a biztonsági másolatból visszaállított megbízható állapotokat tartalmazza.

Ha tranzakcióértesítésekre és/vagy állapotkezelői értesítésekre szeretne regisztrálni, regisztrálnia kell a Reliable State Manager TransactionChanged vagy StateManagerChanged eseményeivel. Az eseménykezelőkkel való regisztrálás gyakori helye az állapotalapú szolgáltatás konstruktora. Amikor regisztrál a konstruktorra, nem fog lemaradni az IReliableStateManager élettartama során bekövetkező változásról.

public MyService(StatefulServiceContext context)
    : base(MyService.EndpointName, context, CreateReliableStateManager(context))
{
    this.StateManager.TransactionChanged += this.OnTransactionChangedHandler;
    this.StateManager.StateManagerChanged += this.OnStateManagerChangedHandler;
}

A TransactionChanged eseménykezelő a NotifyTransactionChangedEventArgs használatával adja meg az esemény részleteit. Tartalmazza a módosítás típusát meghatározó művelettulajdonságot (például NotifyTransactionChangedAction.Commit). A tranzakció tulajdonságot is tartalmazza, amely a módosított tranzakcióra hivatkozik.

Megjegyzés

Ma a TransactionChanged események csak akkor jönnek létre, ha a tranzakció véglegesítve van. A művelet ekkor megegyezik a NotifyTransactionChangedAction.Commit műveletével. A jövőben azonban más típusú tranzakcióállapot-változások esetén is előfordulhatnak események. Javasoljuk, hogy ellenőrizze a műveletet, és csak akkor dolgozza fel az eseményt, ha az a várt.

Íme egy példa a TransactionChanged eseménykezelőre.

private void OnTransactionChangedHandler(object sender, NotifyTransactionChangedEventArgs e)
{
    if (e.Action == NotifyTransactionChangedAction.Commit)
    {
        this.lastCommitLsn = e.Transaction.CommitSequenceNumber;
        this.lastTransactionId = e.Transaction.TransactionId;

        this.lastCommittedTransactionList.Add(e.Transaction.TransactionId);
    }
}

A StateManagerChanged eseménykezelő a NotifyStateManagerChangedEventArgs használatával adja meg az esemény részleteit. A NotifyStateManagerChangedEventArgs két alosztályt tartalmaz: NotifyStateManagerRebuildEventArgs és NotifyStateManagerSingleEntityChangedEventArgs. A NotifyStateManagerChangedEventArgs művelettulajdonságával a NotifyStateManagerChangedEventArgs parancsot a megfelelő alosztályba állíthatja:

• NotifyStateManagerChangedAction.Rebuild: NotifyStateManagerRebuildEventArgs
• NotifyStateManagerChangedAction.Add and NotifyStateManagerChangedAction.Remove: NotifyStateManagerSingleEntityChangedEventArgs

Az alábbiakban egy példa látható a StateManagerChanged értesítéskezelőre.

public void OnStateManagerChangedHandler(object sender, NotifyStateManagerChangedEventArgs e)
{
    if (e.Action == NotifyStateManagerChangedAction.Rebuild)
    {
        this.ProcessStateManagerRebuildNotification(e);

        return;
    }

    this.ProcessStateManagerSingleEntityNotification(e);
}

Megbízható szótárértesítések

A Reliable Dictionary az alábbi eseményekről biztosít értesítéseket:

• Újraépítés: Akkor hívható meg, ha a ReliableDictionary helyreállította az állapotát egy helyreállított vagy másolt helyi állapotból vagy biztonsági mentésből.
• Clear: Akkor hívható meg, ha a ReliableDictionary állapota a ClearAsync metódussal lett törölve.
• Hozzáadás: Akkor hívható meg, ha egy elemet hozzáadtak a ReliableDictionaryhoz.
• Frissítés: Az IReliableDictionary egyik elemének frissítésekor hívható meg.
• Eltávolítás: Akkor hívható meg, ha az IReliableDictionary egyik elemét törölték.

A megbízható szótárértesítések beszerzéséhez regisztrálnia kell a DictionaryChanged eseménykezelővel az IReliableDictionary webhelyen. Ezekkel az eseménykezelőkkel való regisztrálás gyakori helye a ReliableStateManager.StateManagerChanged hozzáadási értesítés. Az IReliableDictionaryIReliableStateManagerhez való hozzáadásakor történő regisztráció biztosítja, hogy ne maradjon le az értesítésekről.

private void ProcessStateManagerSingleEntityNotification(NotifyStateManagerChangedEventArgs e)
{
    var operation = e as NotifyStateManagerSingleEntityChangedEventArgs;

    if (operation.Action == NotifyStateManagerChangedAction.Add)
    {
        if (operation.ReliableState is IReliableDictionary<TKey, TValue>)
        {
            var dictionary = (IReliableDictionary<TKey, TValue>)operation.ReliableState;
            dictionary.RebuildNotificationAsyncCallback = this.OnDictionaryRebuildNotificationHandlerAsync;
            dictionary.DictionaryChanged += this.OnDictionaryChangedHandler;
        }
    }
}

Megjegyzés

A ProcessStateManagerSingleEntityNotification az a mintametódus, amelyet az előző OnStateManagerChangedHandler-példa meghív.

Az előző kód beállítja az IReliableNotificationAsyncCallback felületet, valamint a DictionaryChanged elemet. Mivel a NotifyDictionaryRebuildEventArgs egy IAsyncEnumerable interfészt tartalmaz – amelyet aszinkron módon kell számba venni – az újraépítési értesítések a RebuildNotificationAsyncCallback használatával aktiválódnak az OnDictionaryChangedHandler helyett.

public async Task OnDictionaryRebuildNotificationHandlerAsync(
    IReliableDictionary<TKey, TValue> origin,
    NotifyDictionaryRebuildEventArgs<TKey, TValue> rebuildNotification)
{
    this.secondaryIndex.Clear();

    var enumerator = e.State.GetAsyncEnumerator();
    while (await enumerator.MoveNextAsync(CancellationToken.None))
    {
        this.secondaryIndex.Add(enumerator.Current.Key, enumerator.Current.Value);
    }
}

Megjegyzés

Az előző kódban az újraépítési értesítés feldolgozása során először a fenntartott összesített állapot törlődik. Mivel a megbízható gyűjteményt új állapotban újjáépítették, az összes korábbi értesítés irreleváns.

A DictionaryChanged eseménykezelő a NotifyDictionaryChangedEventArgs használatával adja meg az esemény részleteit. A NotifyDictionaryChangedEventArgs öt alosztályt tartalmaz. A NotifyDictionaryChangedEventArgs művelettulajdonságával a NotifyDictionaryChangedEventArgst a megfelelő alosztályba öntötte:

• NotifyDictionaryChangedAction.Rebuild: NotifyDictionaryRebuildEventArgs
• NotifyDictionaryChangedAction.Clear: NotifyDictionaryClearEventArgs
• NotifyDictionaryChangedAction.Add: NotifyDictionaryItemAddedEventArgs
• NotifyDictionaryChangedAction.Update: NotifyDictionaryItemUpdatedEventArgs
• NotifyDictionaryChangedAction.Remove: NotifyDictionaryItemRemovedEventArgs

public void OnDictionaryChangedHandler(object sender, NotifyDictionaryChangedEventArgs<TKey, TValue> e)
{
    switch (e.Action)
    {
        case NotifyDictionaryChangedAction.Clear:
            var clearEvent = e as NotifyDictionaryClearEventArgs<TKey, TValue>;
            this.ProcessClearNotification(clearEvent);
            return;

        case NotifyDictionaryChangedAction.Add:
            var addEvent = e as NotifyDictionaryItemAddedEventArgs<TKey, TValue>;
            this.ProcessAddNotification(addEvent);
            return;

        case NotifyDictionaryChangedAction.Update:
            var updateEvent = e as NotifyDictionaryItemUpdatedEventArgs<TKey, TValue>;
            this.ProcessUpdateNotification(updateEvent);
            return;

        case NotifyDictionaryChangedAction.Remove:
            var deleteEvent = e as NotifyDictionaryItemRemovedEventArgs<TKey, TValue>;
            this.ProcessRemoveNotification(deleteEvent);
            return;

        default:
            break;
    }
}

Javaslatok

• Végezze el a lehető leggyorsabban az értesítési eseményeket.
• Ne végezzen költséges műveleteket (például I/O-műveleteket) a szinkron események részeként.
• Az esemény feldolgozása előtt ellenőrizze a művelet típusát. A jövőben új művelettípusok is hozzáadhatók.

Íme néhány dolog, amit szem előtt kell tartani:

• Az értesítések a művelet végrehajtásának részeként aktiválódnak. Például egy visszaállítási művelet utolsó lépéseként aktiválódik egy visszaállítási értesítés. A visszaállítás csak az értesítési esemény feldolgozásáig fejeződik be.
• Mivel az értesítések az alkalmazásműveletek részeként aktiválódnak, az ügyfelek csak a helyileg véglegesített műveletekre vonatkozó értesítéseket látják. És mivel a műveletek csak helyileg lesznek véglegesítve (más szóval naplózva), előfordulhat, hogy a jövőben visszavonják őket.
• Az újraműveleti útvonalon minden egyes alkalmazott művelethez egyetlen értesítés lesz aktiválva. Ez azt jelenti, hogy ha a T1 tranzakció tartalmazza a Létrehozás(X), a Delete(X) és a Create(X) tranzakciót, akkor egy értesítést kap az X létrehozásáról, egyet a törlésről, egyet pedig ismét a létrehozásról ebben a sorrendben.
• A több műveletet tartalmazó tranzakciók esetében a műveletek abban a sorrendben lesznek alkalmazva, amelyben azokat a felhasználótól az elsődleges replikán megkapták.
• A hamis állapot feldolgozásának részeként egyes műveletek visszavonhatók a másodlagos replikákon. A rendszer értesítéseket küld az ilyen visszavonási műveletekről, és visszaállítja a replika állapotát egy stabil pontra. A visszavonási értesítések egyik fontos különbsége, hogy az ismétlődő kulcsokkal rendelkező események összesítve lesznek. Ha például a T1 tranzakció visszavonása folyamatban van, egyetlen értesítés jelenik meg a Delete(X) műveletről.

Következő lépések

• Reliable Collections
• Reliable Services – gyors üzembe helyezés
• Reliable Services biztonsági mentés és visszaállítás (vészhelyreállítás)
• Fejlesztői referencia a Reliable Collectionshez