Megosztás a következőn keresztül:

Reliable Collection objektum szerializálása az Azure Service Fabricben

  • Cikk

A megbízható gyűjtemények replikálják és megőrzik az elemeket, hogy biztosan tartósak legyenek a géphibák és az áramkimaradások között. Az elemek replikálásához és megőrzéséhez a Reliable Collectionsnek szerializálnia kell őket.

A Reliable Collections egy adott típushoz megfelelő szerializálót kap a Reliable State Managertől. A Reliable State Manager beépített szerializálókat tartalmaz, és lehetővé teszi az egyéni szerializálók regisztrálását egy adott típushoz.

Beépített szerializálók

A Reliable State Manager beépített szerializálót tartalmaz néhány gyakori típushoz, így alapértelmezés szerint hatékonyan szerializálhatók. Más típusok esetén a Reliable State Manager visszalép a DataContractSerializer használatára. A beépített szerializálók hatékonyabbak, mivel tudják, hogy a típusuk nem módosítható, és nem kell a típussal kapcsolatos információkat, például a típus nevét megadniuk.

A Reliable State Manager beépített szerializálóval rendelkezik a következő típusokhoz:

  • GUID
  • logikai
  • bájt
  • sbyte
  • bájt[]
  • bejárónő
  • húr
  • tizedes
  • double
  • float
  • egész
  • uint
  • hosszú
  • ulong
  • rövid
  • ushort

Egyéni szerializálás

Az egyéni szerializálókat általában a teljesítmény növelésére vagy az adatok vezetéken és lemezen keresztüli titkosítására használják. Más okokból az egyéni szerializálók általában hatékonyabbak, mint az általános szerializálók, mivel nem kell szerializálniuk a típussal kapcsolatos információkat.

Az IReliableStateManager.TryAddStateSerializer<T> egyéni szerializáló regisztrálására szolgál az adott T típushoz. Ennek a regisztrációnak a StatefulServiceBase kiépítésekor kell történnie, hogy a helyreállítás megkezdése előtt minden megbízható gyűjtemény hozzáférhessen a megfelelő szerializálóhoz a tárolt adatok olvasásához.

public StatefulBackendService(StatefulServiceContext context)
  : base(context)
  {
    if (!this.StateManager.TryAddStateSerializer(new OrderKeySerializer()))
    {
      throw new InvalidOperationException("Failed to set OrderKey custom serializer");
    }
  }

Feljegyzés

Az egyéni szerializálók elsőbbséget élveznek a beépített szerializálókkal szemben. Ha például egy int egyéni szerializálója regisztrálva van, az egész számokat szerializálja a beépített szerializáló helyett a inthez.

Egyéni szerializáló implementálása

Az egyéni szerializálónak implementálnia kell az IStateSerializer<T> interfészt.

Feljegyzés

Az IStateSerializer<T> tartalmaz egy túlterhelést az íráshoz és az olvasáshoz, amely egy további T, úgynevezett alapértéket vesz igénybe. Ez az API a különbségi szerializáláshoz készült. A különbségi szerializálási funkció jelenleg nem érhető el. Ezért ezt a két túlterhelést csak akkor hívjuk meg, ha a különbségi szerializálás ki van téve és engedélyezve van.

Az alábbi példa egy OrderKey nevű egyéni típus, amely négy tulajdonságot tartalmaz

public class OrderKey : IComparable<OrderKey>, IEquatable<OrderKey>
{
    public byte Warehouse { get; set; }

    public short District { get; set; }

    public int Customer { get; set; }

    public long Order { get; set; }

    #region Object Overrides for GetHashCode, CompareTo and Equals
    #endregion
}

Az alábbi példa az IStateSerializer OrderKey> implementációjára<mutat be példát. Vegye figyelembe, hogy a baseValue-ban előforduló olvasási és írási túlterhelések a továbbítási kompatibilitás érdekében hívják meg a megfelelő túlterhelést.

public class OrderKeySerializer : IStateSerializer<OrderKey>
{
  OrderKey IStateSerializer<OrderKey>.Read(BinaryReader reader)
  {
      var value = new OrderKey();
      value.Warehouse = reader.ReadByte();
      value.District = reader.ReadInt16();
      value.Customer = reader.ReadInt32();
      value.Order = reader.ReadInt64();

      return value;
  }

  void IStateSerializer<OrderKey>.Write(OrderKey value, BinaryWriter writer)
  {
      writer.Write(value.Warehouse);
      writer.Write(value.District);
      writer.Write(value.Customer);
      writer.Write(value.Order);
  }
  
  // Read overload for differential de-serialization
  OrderKey IStateSerializer<OrderKey>.Read(OrderKey baseValue, BinaryReader reader)
  {
      return ((IStateSerializer<OrderKey>)this).Read(reader);
  }

  // Write overload for differential serialization
  void IStateSerializer<OrderKey>.Write(OrderKey baseValue, OrderKey newValue, BinaryWriter writer)
  {
      ((IStateSerializer<OrderKey>)this).Write(newValue, writer);
  }
}

Felminősíthetőség

Egy gördülő alkalmazásfrissítés esetén a frissítés a csomópontok egy részhalmazára, egyszerre egy frissítési tartományra lesz alkalmazva. A folyamat során egyes frissítési tartományok az alkalmazás újabb verziójában lesznek, egyes frissítési tartományok pedig az alkalmazás régebbi verziójában lesznek. A bevezetés során az alkalmazás új verziójának képesnek kell lennie az adatok régi verziójának olvasására, és az alkalmazás régi verziójának képesnek kell lennie az adatok új verziójának olvasására. Ha az adatformátum nem továbbítható és visszamenőleges kompatibilis, előfordulhat, hogy a frissítés sikertelen vagy rosszabb, az adatok elveszhetnek vagy megsérülhetnek.

Ha beépített szerializálót használ, nem kell aggódnia a kompatibilitás miatt. Ha azonban egyéni szerializálót vagy DataContractSerializert használ, az adatoknak végtelenül visszafelé és továbbítva kell lenniük. Más szóval a szerializáló minden verziójának képesnek kell lennie a szerializálásra és a típus bármely verziójának szerializálására.

Az adatszerződés felhasználóinak a mezők hozzáadására, eltávolítására és módosítására vonatkozó, jól meghatározott verziószámozási szabályokat kell követnie. A Data Contract emellett támogatja az ismeretlen mezők kezelését, a szerializálási és deszerializálási folyamathoz való csatlakoztatást, valamint az osztályöröklés kezelését. További információ: Adatszerződés használata.

Az egyéni szerializáló felhasználóknak be kell tartaniuk az általuk használt szerializáló irányelveit, hogy biztosan kompatibilisek legyenek a visszafelé és a továbbítással. Az összes verzió támogatásának általános módja a méretinformációk hozzáadása az elején, és csak az opcionális tulajdonságok hozzáadása. Így az egyes verziók annyi mindent elolvashatnak, és átugorhatják a stream fennmaradó részét.

Következő lépések