Delen via

Korrelidentiteit

  • Artikel

Korrels in Orleans elk hebben één unieke, door de gebruiker gedefinieerde id die uit twee delen bestaat:

  1. De naam van het graantype, die de graanklasse uniek identificeert.
  2. De graansleutel, die een logisch exemplaar van die graanklasse uniek identificeert.

Het korreltype en de sleutel worden beide weergegeven als door mensen leesbare tekenreeksen en Orleans , volgens conventie, wordt de korrelidentiteit geschreven met het graantype en de sleutel gescheiden door een / teken. Vertegenwoordigt bijvoorbeeld shoppingcart/bob65 het graantype met de naam shoppingcart van een sleutel bob65.

Het is niet gebruikelijk om graanidentiteiten rechtstreeks samen te stellen. In plaats daarvan is het gebruikelijker om graanverwijzingen te maken met behulp van Orleans.IGrainFactory.

In de volgende secties worden de namen en korrelsleutels in meer detail besproken.

Namen van graantypen

Orleans maakt een korreltypenaam voor u op basis van uw graanimplementatieklasse door het achtervoegsel 'Grain' te verwijderen uit de klassenaam, als deze aanwezig is en de resulterende tekenreeks te converteren naar de kleine letters. Een klasse met de naam ShoppingCartGrain krijgt bijvoorbeeld de naam shoppingcartvan het graantype. Het wordt aanbevolen om de namen en sleutels van het graantype alleen uit af te drukken tekens zoals alfanumerieke tekens (az-,Z-A en 0-9) en symbolen zoals -, _, @, . = Andere tekens kunnen of niet worden ondersteund en hebben vaak speciale behandeling nodig wanneer ze worden afgedrukt in logboeken of als id's worden weergegeven in andere systemen, zoals databases.

U kunt ook het kenmerk gebruiken om de naam van het Orleans.GrainTypeAttribute graantype aan te passen voor de graanklasse waaraan deze is gekoppeld, zoals in het volgende voorbeeld:

[GrainType("cart")]
public class ShoppingCartGrain : IShoppingCartGrain
{
    // Add your grain implementation here
}

In het voorgaande voorbeeld heeft de graanklasse ShoppingCartGrain een korreltypenaam van cart. Elk graan mag slechts één graantypenaam hebben.

Voor algemene korrels moet de generieke arity worden opgenomen in de naam van het graantype. Denk bijvoorbeeld aan de volgende DictionaryGrain<K, V> klasse:

[GrainType("dict`2")]
public class DictionaryGrain<K, V> : IDictionaryGrain<K, V>
{
    // Add your grain implementation here
}

De graanklasse heeft twee algemene parameters, dus een backtick ` gevolgd door de algemene arity, 2, wordt toegevoegd aan het einde van de graantypenaam, om de naam dict`2van het graantype te maken, dict zoals opgegeven in het kenmerk op de graanklasse, [GrainType("dict`2")].

Korreltoetsen

Voor het gemak Orleans maakt u methoden beschikbaar die de constructie van graansleutels van een Guid of een Int64, naast een String. De primaire sleutel is gericht op het graantype. Daarom wordt de volledige identiteit van een graan gevormd uit het type en de sleutel van het graan.

De aanroeper van het graan bepaalt welk schema moet worden gebruikt. De opties zijn:

Omdat de onderliggende gegevens hetzelfde zijn, kunnen de schema's door elkaar worden gebruikt: ze worden allemaal gecodeerd als tekenreeksen.

Situaties waarvoor een singleton grain-exemplaar is vereist, kunnen een bekende, vaste waarde zoals "default". Dit is slechts een conventie, maar door zich aan deze conventie te houden, wordt het duidelijk op de site van de beller dat een singletonkorrel in gebruik is.

GuiD's (Globally Unique Identifiers) gebruiken als sleutels

System.Guid maak nuttige sleutels wanneer willekeurigheid en globale uniekheid gewenst zijn, zoals bij het maken van een nieuwe taak in een taakverwerkingssysteem. U hoeft de toewijzing van sleutels niet te coördineren, wat kan leiden tot een single point of failure in het systeem of een vergrendeling aan de systeemzijde van een resource die een knelpunt kan opleveren. Er is een zeer lage kans dat GUID's botsen, dus ze zijn een veelvoorkomende keuze bij het ontwerpen van een systeem dat willekeurige id's moet toewijzen.

Verwijzen naar een korrel door GUID in clientcode:

var grain = grainFactory.GetGrain<IExample>(Guid.NewGuid());

De primaire sleutel ophalen uit graancode:

public override Task OnActivateAsync()
{
    Guid primaryKey = this.GetPrimaryKey();
    return base.OnActivateAsync();
}

Gehele getallen gebruiken als sleutels

Er is ook een lang geheel getal beschikbaar, wat zinvol is als het graan wordt bewaard in een relationele database, waarbij numerieke indexen de voorkeur hebben boven GUID's.

Verwijzen naar een korrel door een lang geheel getal in clientcode:

var grain = grainFactory.GetGrain<IExample>(1);

De primaire sleutel ophalen uit graancode:

public override Task OnActivateAsync()
{
    long primaryKey = this.GetPrimaryKeyLong();
    return base.OnActivateAsync();
}

Tekenreeksen gebruiken als sleutels

Er is ook een tekenreeks beschikbaar.

Verwijst naar een korrel per tekenreeks in clientcode:

var grain = grainFactory.GetGrain<IExample>("myGrainKey");

De primaire sleutel ophalen uit graancode:

public override Task OnActivateAsync()
{
    string primaryKey = this.GetPrimaryKeyString();
    return base.OnActivateAsync();
}

Samengestelde sleutels gebruiken

Als u een systeem hebt dat niet goed past bij GUID's of longs, kunt u kiezen voor een samengestelde primaire sleutel, waarmee u een combinatie van een GUID of lang en een tekenreeks kunt gebruiken om naar een korrel te verwijzen.

U kunt uw interface overnemen van IGrainWithGuidCompoundKey of IGrainWithIntegerCompoundKey interface als volgt:

public interface IExampleGrain : Orleans.IGrainWithIntegerCompoundKey
{
    Task Hello();
}

In clientcode voegt u een tweede argument toe aan de IGrainFactory.GetGrain methode op de graanfactory:

var grain = grainFactory.GetGrain<IExample>(0, "a string!", null);

Voor toegang tot de samengestelde sleutel in het graan kunnen we een overbelasting aanroepen voor de GrainExtensions.GetPrimaryKey methode (de GrainExtensions.GetPrimaryKeyLong):

public class ExampleGrain : Orleans.Grain, IExampleGrain
{
    public Task Hello()
    {
        long primaryKey = this.GetPrimaryKeyLong(out string keyExtension);
        Console.WriteLine($"Hello from {keyExtension}");

        return Task.CompletedTask;
    }
}

Waarom korrels logische id's gebruiken

In objectgeoriënteerde omgevingen, zoals .NET, is de identiteit van een object moeilijk te onderscheiden van een verwijzing naar het object. Wanneer een object wordt gemaakt met behulp van het new trefwoord, vertegenwoordigt de verwijzing die u terugkrijgt alle aspecten van de identiteit, behalve de aspecten die het object toewijzen aan een externe entiteit die het vertegenwoordigt. Orleans is ontworpen voor gedistribueerde systemen. In gedistribueerde systemen kunnen objectverwijzingen geen exemplaaridentiteit vertegenwoordigen, omdat objectverwijzingen beperkt zijn tot de adresruimte van één proces. Orleans gebruikt logische id's om deze beperking te voorkomen. Grain gebruikt logische id's zodat korrelverwijzingen geldig blijven gedurende de levensduur van processen en draagbaar zijn van het ene proces naar het andere, zodat ze later kunnen worden opgeslagen en later kunnen worden opgehaald of via een netwerk naar een ander proces in de toepassing worden verzonden, allemaal terwijl ze nog steeds verwijzen naar dezelfde entiteit: het korrel waarvoor de verwijzing is gemaakt.