Tane kalıcılığı

Tahıl birimlerine birden fazla adlandırılmış kalıcı veri nesnesi bağlanabilir. Bu durum nesneleri, veri etkinleştirme sırasında depolama alanından yüklenir, böylece istekler sırasında kullanılabilirler. Tahıl kalıcılığı, genişletilebilir bir eklenti modeli kullanarak herhangi bir veritabanı için depolama sağlayıcılarını kullanmanıza olanak tanır. Bu kalıcılık modeli basitlik için tasarlanmıştır ve tüm veri erişim desenlerini kapsamaya yönelik değildir. Tahıllar ayrıca, tane kalıcılık modelini kullanmadan veritabanlarına doğrudan erişebilir.

Önceki diyagramda, UserGrain'in her biri ayrı bir depolama sisteminde depolanan bir Profil durumu ve Sepet durumu vardır.

Hedefler

1. Her bir tanecik için birden çok adlandırılmış kalıcı veri nesnesini destekler.
2. Her birinin farklı bir yapılandırmaya sahip ve farklı bir depolama sistemi tarafından desteklenen birden çok yapılandırılmış depolama sağlayıcısına izin verin.
3. Topluluğun depolama sağlayıcıları geliştirmesini ve yayımlamasını sağlayın.
4. Depolama sağlayıcılarına, kalıcı destek deposunda tahıl durumu verilerini nasıl depoladıkları üzerinde tam kontrol verin. Corollary: Orleans kapsamlı bir ORM depolama çözümü sağlamaz, ancak özel depolama sağlayıcılarının gerektiğinde belirli ORM gereksinimlerini desteklemesine izin verir.

Paketler

Orleans tahıl depolama sağlayıcıları bulabilirsiniz. Resmi olarak bakımı yapılan paketler şunlardır:

• Microsoft..Orleans. Persistence.AdoNet: sql veritabanları ve ADO.NET tarafından desteklenen diğer depolama sistemleri için. Daha fazla bilgi için bkz. ADO.NET tane kalıcılığı.
• Microsoft.Orleans.Persistence.AzureStorage: Azure Blob Depolama ve Azure Tablo Depolama dahil olmak üzere Azure Depolama için (Azure Tablo Depolama API'si aracılığıyla). Daha fazla bilgi için bakınız Azure Depolama grains kalıcılığı.
• Microsoft..Orleans. Persistence.Cosmos: Azure Cosmos DB sağlayıcısı. Daha fazla bilgi için bkz. Azure Cosmos DB tane kalıcılığı.
• Microsoft..Orleans. Persistence.DynamoDB: Amazon DynamoDB için. Daha fazla bilgi için bkz . Amazon DynamoDB tahıl kalıcılığı.
• Microsoft..Orleans. Persistence.Redis: Redis için. Daha fazla bilgi için Redis grain kalıcılığı başlığına bakın.

Uygulama Programlama Arayüzü (API)

Tanecikler, kalıcı durumlarıyla IPersistentState<TState> kullanarak etkileşim kurar; bu durumda TState, seri hale getirilebilir durum türüdür.

public interface IPersistentState<TState> : IStorage<TState>
{
}

public interface IStorage<TState> : IStorage
{
    TState State { get; set; }
}

public interface IStorage
{
    string Etag { get; }

    bool RecordExists { get; }

    Task ClearStateAsync();

    Task WriteStateAsync();

    Task ReadStateAsync();
}

public interface IPersistentState<TState> where TState : new()
{
    TState State { get; set; }

    string Etag { get; }

    Task ClearStateAsync();

    Task WriteStateAsync();

    Task ReadStateAsync();
}

Orleans , IPersistentState<TState> örneklerini yapılandırıcı parametreler olarak gruba enjekte eder. Eklenen durumun adını ve bunu sağlayan depolama sağlayıcısının adını tanımlamak için bu parametrelere bir PersistentStateAttribute öznitelikle açıklama ekleyebilirsiniz. Aşağıdaki örnek, oluşturucuya UserGrain iki adlandırılmış durum ekleyerek bunu gösterir:

public class UserGrain : Grain, IUserGrain
{
    private readonly IPersistentState<ProfileState> _profile;
    private readonly IPersistentState<CartState> _cart;

    public UserGrain(
        [PersistentState("profile", "profileStore")] IPersistentState<ProfileState> profile,
        [PersistentState("cart", "cartStore")] IPersistentState<CartState> cart)
    {
        _profile = profile;
        _cart = cart;
    }

    public Task<string> GetNameAsync() => Task.FromResult(_profile.State.Name);

    public async Task SetNameAsync(string name)
    {
        _profile.State.Name = name;
        await _profile.WriteStateAsync();
    }
}

Farklı tanecik türleri, her ne kadar her ikisi de aynı türde olsa da (örneğin, farklı Azure Depolama hesaplarına bağlı iki farklı Azure Tablo Depolama sağlayıcısı örneği), farklı yapılandırılmış depolama sağlayıcıları kullanabilir.

Okunma durumu

Tanecik etkinleştirildiğinde, tanecik durumu otomatik olarak okunur, ancak tanecikler, gerektiğinde değişen herhangi bir tanecik durumu için yazma işlemini açıkça tetiklemekle sorumludur.

Eğer bir tahıl, en son durumunu arka depodan yeniden okumak istiyorsa, ReadStateAsync yöntemini açıkça çağırmalıdır. Bu işlem, depolama sağlayıcısı aracılığıyla kalıcı depodan tahıl durumunu yeniden yükler. Task tamamlandığında, tanecik durumunun önceki bellek içi kopyası üzerine yazılır ve ReadStateAsync ile değiştirilir.

özelliğini kullanarak durumun değerine erişin State . Örneğin, aşağıdaki yöntem yukarıdaki kodda bildirilen profil durumuna erişir:

public Task<string> GetNameAsync() => Task.FromResult(_profile.State.Name);

Normal işlem sırasında çağrı ReadStateAsync yapmanız gerekmez; Orleans etkinleştirme sırasında durumu otomatik olarak yükler. Ancak, harici olarak değiştirilmiş durumu yenilemek için kullanabilirsiniz ReadStateAsync .

Hata işleme mekanizmaları hakkında ayrıntılı bilgi için aşağıdaki Hata modları bölümüne bakın.

Durumu yaz

Özelliğini kullanarak State durumu değiştirebilirsiniz. Değiştirilen durum otomatik olarak kalıcı olmaz. Bunun yerine, WriteStateAsync yöntemini çağırarak durumu ne zaman kalıcı hale getireceğinize karar verirsiniz. Örneğin, aşağıdaki yöntem üzerindeki State bir özelliği güncelleştirir ve güncelleştirilmiş durumda kalır:

public async Task SetNameAsync(string name)
{
    _profile.State.Name = name;
    await _profile.WriteStateAsync();
}

Kavramsal olarak, Orleans Çalışma Zamanı herhangi bir yazma işlemi sırasında kullanmak üzere tanecik durum veri nesnesinin derinlemesine kopyasını alır. Çalışma zamanı, beklenen mantıksal yalıtım semantiğinin korunması koşuluyla belirli durumlarda derin kopyanın bir kısmını veya tümünü gerçekleştirmekten kaçınmak için iyileştirme kurallarını ve buluşsal yöntemleri kullanabilir.

Hata işleme mekanizmaları hakkında ayrıntılı bilgi için aşağıdaki Hata modları bölümüne bakın.

Durumu sıfırla

ClearStateAsync yöntemi, tahılın depodaki durumunu temizler. Sağlayıcıya bağlı olarak, bu işlem isteğe bağlı olarak tahıl durumunu tamamen silebilir.

Başlayın

Bir taneciğin kalıcılığı kullanabilmesi için önce silo üzerinde bir depolama sağlayıcısı yapılandırmanız gerekir.

İlk olarak, biri profil durumu ve biri sepet durumu için depolama sağlayıcılarını yapılandırın:

Yönetilen kimlik (önerilen)

URI uç noktası ile kullanmak DefaultAzureCredential , üretim ortamları için önerilen yaklaşımdır.

var tableEndpoint = new Uri(configuration["AZURE_TABLE_STORAGE_ENDPOINT"]!);
var blobEndpoint = new Uri(configuration["AZURE_BLOB_STORAGE_ENDPOINT"]!);
var credential = new DefaultAzureCredential();

var builder = Host.CreateApplicationBuilder();
builder.UseOrleans(siloBuilder =>
{
    siloBuilder.AddAzureTableGrainStorage(
        name: "profileStore",
        configureOptions: options =>
        {
            options.TableServiceClient = new TableServiceClient(tableEndpoint, credential);
        })
        .AddAzureBlobGrainStorage(
            name: "cartStore",
            configureOptions: options =>
            {
                options.BlobServiceClient = new BlobServiceClient(blobEndpoint, credential);
            });
});

using var host = builder.Build();

Bağlantı dizesi

Uyarı

Bağlantı dizeleri gizli bilgiler içerir ve prodüksiyonda kullanılmaktan kaçınılmalıdır. Mümkün olduğunda yönetilen kimliği kullanın.

var builder = Host.CreateApplicationBuilder();
builder.UseOrleans(siloBuilder =>
{
    siloBuilder.AddAzureTableGrainStorage(
        name: "profileStore",
        configureOptions: options =>
        {
            options.TableServiceClient = new TableServiceClient(
                "DefaultEndpointsProtocol=https;AccountName=data1;AccountKey=SOMETHING1");
        })
        .AddAzureBlobGrainStorage(
            name: "cartStore",
            configureOptions: options =>
            {
                options.BlobServiceClient = new BlobServiceClient(
                    "DefaultEndpointsProtocol=https;AccountName=data2;AccountKey=SOMETHING2");
            });
});

using var host = builder.Build();

var host = new HostBuilder()
    .UseOrleans(siloBuilder =>
    {
        siloBuilder.AddAzureTableGrainStorage(
            name: "profileStore",
            configureOptions: options =>
            {
                // Use JSON for serializing the state in storage
                options.UseJson = true;

                // Configure the storage connection key
                options.ConnectionString =
                    "DefaultEndpointsProtocol=https;AccountName=data1;AccountKey=SOMETHING1";
            })
            .AddAzureBlobGrainStorage(
                name: "cartStore",
                configureOptions: options =>
                {
                    // Use JSON for serializing the state in storage
                    options.UseJson = true;

                    // Configure the storage connection key
                    options.ConnectionString =
                        "DefaultEndpointsProtocol=https;AccountName=data2;AccountKey=SOMETHING2";
                });
    })
    .Build();

Önemli

Microsoft, kullanılabilir en güvenli kimlik doğrulama akışını kullanmanızı önerir. Azure SQL'e bağlanıyorsanız önerilen kimlik doğrulama yöntemi Azure kaynakları için Yönetilen Kimlikler'dir.

"profileStore" adlı bir depolama sağlayıcısı yapılandırdığınıza göre, bu sağlayıcıya bir "grain" üzerinden erişebilirsiniz.

Bir taneye kalıcı durum eklemek için iki birincil yöntem kullanabilirsiniz:

1. Tahılın yapıcısına IPersistentState<TState> enjekte ederek.
2. Grain<TGrainState> öğesinden devralarak.

Tahıla depolama eklemenin önerilen yolu, IPersistentState<TState>'yi tahılın oluşturucusuna, [PersistentState("stateName", "providerName")] ilişkili bir öznitelikle enjeksiyon yapmaktır. Detaylar için Grain<TGrainState> hakkındaki bilgiye aşağıda Using Grain<TGrainState> to add storage to a grain kısmında bakın. Kullanımı Grain<TGrainState> hala desteklenir ancak eski bir yaklaşım olarak kabul edilir.

Tahılınızın durumunu saklamak için bir sınıf tanımlayın.

[Serializable]
public class ProfileState
{
    public string Name { get; set; }

    public Date DateOfBirth { get; set; }
}

IPersistentState<TState> ifadesini tahıl oluşturucusuna enjekte edin.

public class UserGrainSimple : Grain, IUserGrain
{
    private readonly IPersistentState<ProfileState> _profile;

    public UserGrainSimple(
        [PersistentState("profile", "profileStore")]
        IPersistentState<ProfileState> profile)
    {
        _profile = profile;
    }

    public Task<string> GetNameAsync() => Task.FromResult(_profile.State.Name);

    public async Task SetNameAsync(string name)
    {
        _profile.State.Name = name;
        await _profile.WriteStateAsync();
    }
}

Önemli

Profil durumu oluşturucuya eklendiği sırada yüklenmez, bu nedenle erişim o sırada geçersizdir. OnActivateAsync çağrılmadan önce durum yüklenecektir.

Artık tahıl kalıcı bir duruma sahip olduğuna göre, durumu okumak ve yazmak için yöntemler ekleyebilirsiniz:

public class UserGrainComplete : Grain, IUserGrain
{
    private readonly IPersistentState<ProfileState> _profile;

    public UserGrainComplete(
        [PersistentState("profile", "profileStore")]
        IPersistentState<ProfileState> profile)
    {
        _profile = profile;
    }

    public Task<string> GetNameAsync() => Task.FromResult(_profile.State.Name);

    public async Task SetNameAsync(string name)
    {
        _profile.State.Name = name;
        await _profile.WriteStateAsync();
    }
}

Kalıcılık işlemleri için hata modları

Okuma işlemleri için hata modları

Belirli bir grain için durum verilerinin ilk okunması sırasında depolama sağlayıcısı tarafından döndürülen hatalar, bu grain için başlatma işleminin başarısız olmasına neden olur. Böyle durumlarda, bu dilimin OnActivateAsync yaşam döngüsü geri çağırma yöntemine herhangi bir çağrı yapılmaz. Tahıl etkinleştirmesi sırasındaki diğer hatalarda olduğu gibi, etkinleştirme hatalarına neden olan özgün istek, arayana geri döner. Belirli bir tanecik için durum verileri okunurken depolama sağlayıcısının karşılaştığı hatalar, ReadStateAsyncTask'dan bir istisna ile sonuçlanır. Tane, herhangi bir Task içindeki Task gibi Orleans istisnasını işlemeyi veya yoksaymayı seçebilir.

Eksik veya hatalı depolama sağlayıcısı yapılandırması nedeniyle silo başlangıcında yüklenemeyen bir tahıla ileti gönderme girişimi kalıcı hata BadProviderConfigException döndürür.

Yazma işlemleri için hata modları

Belirli bir dilim için durum verileri yazılırken depolama sağlayıcısının karşılaştığı hatalar WriteStateAsyncTask tarafından oluşturulan bir istisna ile sonuçlanır. Genellikle bu, bu grain yönteminin son dönüş WriteStateAsync'sine doğru şekilde zincirlenmesi koşuluyla, taneli çağrı istisnasının istemci çağıranına geri atıldığı anlamına gelir. Ancak, bazı gelişmiş senaryolarda, bu tür yazma hatalarını işlemek için, diğer tüm hatalı Taskişlemleri gibi ayrıntılı kod yazabilirsiniz.

Hata işleme veya kurtarma kodu yürüten tanecikler özel durumları veya hatalı WriteStateAsyncs'leri yakalamalı ve bunları yeniden oluşturmamalı ve yazma hatasını başarıyla işlediklerini Task.

Öneriler

JSON serileştirme veya başka bir sürüme dayanıklı serileştirme biçimi kullanma

Kod gelişir ve bu genellikle depolama türlerini içerir. Bu değişikliklere uyum sağlamak için uygun bir seri hale getirici yapılandırın. 7.0'dan Orleans başlayarak tanecik depolama serileştiricisini IGrainStorageSerializer arabirimi ile yapılandırabilirsiniz. Varsayılan olarak, grain durumu JSON (Newtonsoft.Json) kullanarak serileştirilir. Veri sözleşmeleri geliştirilirken zaten depolanmış verilerin hala yüklenebilmesini sağlayın. Daha fazla bilgi için bkz tahıl depolama serileştiricileri.

Kod gelişir ve bu genellikle depolama türlerini içerir. Bu değişikliklere uyum sağlamak için uygun bir seri hale getirici yapılandırın. Çoğu depolama sağlayıcısı için, JSON'ı serileştirme biçimi olarak kullanmak için bir UseJson seçenek veya benzer bir seçenek kullanılabilir. Veri sözleşmeleri geliştirilirken zaten depolanmış verilerin hala yüklenebilmesini sağlayın.

Bir veri tanesine depolama eklemek için Grain<TGrainState> kullanmak

Önemli

Grain<TGrainState> kullanarak bir taneye depolama eklemek, eski bir özellik olarak kabul edilir. Daha önce açıklandığı gibi IPersistentState<TState> kullanarak tahıl saklama alanı ekleyin.

Öğesinden devralınan, kalıcı olması gereken uygulamaya özgü bir durum veri türü olan Grain<TGrainState>T tanecik sınıflarının durumu, belirtilen depolama alanından otomatik olarak yüklenir.

Bu tür taneleri, bu tanenin durum verilerini okuma/yazma işlemleri için kullanılacak bir depolama sağlayıcısının adlandırılmış bir örneğini belirlemek için StorageProviderAttribute ile işaretleyin.

[StorageProvider(ProviderName = "store1")]
public class MyGrain : Grain<MyGrainState>, IMyGrain
{
    public Task DoSomethingAsync() => Task.CompletedTask;
}

Grain<TGrainState> Temel sınıf, alt sınıfların çağırması için aşağıdaki yöntemleri tanımlar:

public abstract class GrainBaseExample<TState>
{
    protected virtual Task ReadStateAsync() { return Task.CompletedTask; }
    protected virtual Task WriteStateAsync() { return Task.CompletedTask; }
    protected virtual Task ClearStateAsync() { return Task.CompletedTask; }
}

Bu yöntemlerin davranışı, daha önce tanımlanan IPersistentState<TState> üzerindeki karşılıklarıyla örtüşmektedir.

Depolama sağlayıcısı oluşturma

Durum kalıcılığı API'lerinin iki bölümü vardır: IPersistentState<TState> veya Grain<TGrainState> aracılığıyla "grain"e sunulan API ve IGrainStorage etrafında merkezlenen depolama sağlayıcısı API'si — depolama sağlayıcılarının uygulaması gereken arabirim.

/// <summary>
/// Interface to be implemented for a storage able to read and write Orleans grain state data.
/// </summary>
public interface ICustomGrainStorage
{
    /// <summary>Read data function for this storage instance.</summary>
    /// <param name="stateName">Name of the state for this grain</param>
    /// <param name="grainId">Grain ID</param>
    /// <param name="grainState">State data object to be populated for this grain.</param>
    /// <typeparam name="T">The grain state type.</typeparam>
    /// <returns>Completion promise for the Read operation on the specified grain.</returns>
    Task ReadStateAsync<T>(
        string stateName, GrainId grainId, IGrainState<T> grainState);

    /// <summary>Write data function for this storage instance.</summary>
    /// <param name="stateName">Name of the state for this grain</param>
    /// <param name="grainId">Grain ID</param>
    /// <param name="grainState">State data object to be written for this grain.</param>
    /// <typeparam name="T">The grain state type.</typeparam>
    /// <returns>Completion promise for the Write operation on the specified grain.</returns>
    Task WriteStateAsync<T>(
        string stateName, GrainId grainId, IGrainState<T> grainState);

    /// <summary>Delete / Clear data function for this storage instance.</summary>
    /// <param name="stateName">Name of the state for this grain</param>
    /// <param name="grainId">Grain ID</param>
    /// <param name="grainState">Copy of last-known state data object for this grain.</param>
    /// <typeparam name="T">The grain state type.</typeparam>
    /// <returns>Completion promise for the Delete operation on the specified grain.</returns>
    Task ClearStateAsync<T>(
        string stateName, GrainId grainId, IGrainState<T> grainState);
}

/// <summary>
/// Interface to be implemented for a storage able to read and write Orleans grain state data.
/// </summary>
public interface IGrainStorage
{
    /// <summary>Read data function for this storage instance.</summary>
    /// <param name="grainType">Type of this grain [fully qualified class name]</param>
    /// <param name="grainReference">Grain reference object for this grain.</param>
    /// <param name="grainState">State data object to be populated for this grain.</param>
    /// <returns>Completion promise for the Read operation on the specified grain.</returns>
    Task ReadStateAsync(
        string grainType, GrainReference grainReference, IGrainState grainState);

    /// <summary>Write data function for this storage instance.</summary>
    /// <param name="grainType">Type of this grain [fully qualified class name]</param>
    /// <param name="grainReference">Grain reference object for this grain.</param>
    /// <param name="grainState">State data object to be written for this grain.</param>
    /// <returns>Completion promise for the Write operation on the specified grain.</returns>
    Task WriteStateAsync(
        string grainType, GrainReference grainReference, IGrainState grainState);

    /// <summary>Delete / Clear data function for this storage instance.</summary>
    /// <param name="grainType">Type of this grain [fully qualified class name]</param>
    /// <param name="grainReference">Grain reference object for this grain.</param>
    /// <param name="grainState">Copy of last-known state data object for this grain.</param>
    /// <returns>Completion promise for the Delete operation on the specified grain.</returns>
    Task ClearStateAsync(
        string grainType, GrainReference grainReference, IGrainState grainState);
}

Bu arabirimi uygulayarak ve bu uygulamayı kaydederek özel bir depolama sağlayıcısı oluşturun. Mevcut bir depolama sağlayıcısı uygulaması örneği için bkz AzureBlobGrainStorage. .

Depolama sağlayıcısı semantiği

Depolama sağlayıcısı tarafından, durum okunduğunda doldurulan taneli durum meta verilerinin bir parçası olarak sağlayıcıya özgü opak bir Etag değer (string) ayarlanabilir. Bazı sağlayıcılar, null kullanmadıkları takdirde bunu Etag bırakarak tercih edebilir.

Depolama sağlayıcısı bir Etag kısıtlama ihlali algıladığında bir yazma işlemi gerçekleştirme girişimi, yazma işleminin geçici bir hatayla Task başarısız olmasına ve temel alınan depolama özel durumunu kapsamasına neden InconsistentStateException.

public class InconsistentStateException : OrleansException
{
    public InconsistentStateException(
    string message,
    string storedEtag,
    string currentEtag,
    Exception storageException)
        : base(message, storageException)
    {
        StoredEtag = storedEtag;
        CurrentEtag = currentEtag;
    }

    public InconsistentStateException(
        string storedEtag,
        string currentEtag,
        Exception storageException)
        : this(storageException.Message, storedEtag, currentEtag, storageException)
    {
    }

    /// <summary>The Etag value currently held in persistent storage.</summary>
    public string StoredEtag { get; }

    /// <summary>The Etag value currently held in memory, and attempting to be updated.</summary>
    public string CurrentEtag { get; }
}

Bir depolama işleminden kaynaklanan diğer hata koşulları, döndürülen 'in temelindeki depolama sorununu belirten bir istisna ile bozulmasına neden Task. Çoğu durumda, bu istisna, grain üzerinde bir yöntem çağırarak depolama işlemini tetikleyen çağırana geri iletilebilir. Çağıranın bu istisnayı deserilize edip edemeyeceğini göz önünde bulundurmanız önemlidir. Örneğin, istemci özel durum türünü içeren belirli kalıcılık kitaplığını yüklememiş olabilir. Bu nedenle, özel durumların çağırana geri yayılabilir özel durumlara dönüştürülmesi önerilir.

Veri eşleme

Bireysel depolama sağlayıcıları, tahıl durumu için en iyi depolama yönteminin blob (çeşitli biçimler/serileştirilmiş formlar) veya alan başına sütun gibi seçeneklerden hangisi olduğunu seçmelidir.

Depolama sağlayıcısı kaydet

Çalışma zamanı, bir tahıl oluşturulduğunda hizmet sağlayıcısından (Orleans) bir depolama sağlayıcısını çözümler. Çalışma zamanı bir örneğini IGrainStorageçözümler. Depolama sağlayıcısı adlandırılmışsa (örneğin, [PersistentState(stateName, storageName)] özniteliği aracılığıyla), IGrainStorage adlı bir örnek çözümlenir.

Adlandırılmış bir IGrainStorage örneğini kaydetmek için, AddSingletonNamedService örneğini izleyerek uzantı yöntemini kullanın.

Redis grain kalıcılığı

Redis , tahıl kalıcılığı için kullanılabilecek popüler bir bellek içi veri deposudur. Microsoft.Orleans.Persistence.Redis paketi, Redis tarafından desteklenen bir tane depolama sağlayıcısı sağlar.

Redis grain depolamayı yapılandırma

AddRedisGrainStorage uzantı yöntemi ile Redis tahıl depolamasını yapılandırın.

var builder = Host.CreateApplicationBuilder();
builder.UseOrleans(siloBuilder =>
{
    siloBuilder.AddRedisGrainStorage(
        name: "redis",
        configureOptions: options =>
        {
            options.ConfigurationOptions = new ConfigurationOptions
            {
                EndPoints = { "localhost:6379" },
                AbortOnConnectFail = false
            };
        });
});

using var host = builder.Build();

Redis'i varsayılan tahıl depolama sağlayıcısı olarak yapılandırmak için kullanın AddRedisGrainStorageAsDefault:

siloBuilder.AddRedisGrainStorageAsDefault(options =>
{
    options.ConfigurationOptions = new ConfigurationOptions
    {
        EndPoints = { "localhost:6379" }
    };
});

Redis depolama seçenekleri

RedisStorageOptions sınıfı aşağıdaki yapılandırma seçeneklerini sağlar:

Mülkiyet	Türü	Description
ConfigurationOptions	ConfigurationOptions	StackExchange.Redis istemci yapılandırması. Gerekli.
DeleteStateOnClear	bool	Çağrıldığında ClearStateAsync Redis'ten durumun silinip silinmeyeceği. Varsayılan false değeridir.
EntryExpiry	TimeSpan?	Girişler için isteğe bağlı son kullanma süresi. Yinelenen etkinleştirmelere neden olabileceği için bunu yalnızca test gibi kısa ömürlü ortamlar için ayarlayın. Varsayılan null değeridir.
GrainStorageSerializer	IGrainStorageSerializer	Tanecik durumu için kullanılacak olan serileştirici. Varsayılan olarak Orleans serileştirici kullanılır.
CreateMultiplexer	Func<RedisStorageOptions, Task<IConnectionMultiplexer>>	Redis bağlantı çoklayıcısını oluşturmak için özel fabrika.
GetStorageKey	Func<string, GrainId, RedisKey>	Bir tahıl için Redis anahtarını oluşturmak için özel işlev. Varsayılan biçim şeklindedir {ServiceId}/state/{grainId}/{grainType}.

.NET Aspire entegrasyonu

.NET Aspire kullanırken Redis grain storage'ı Aspire tarafından yönetilen Redis kaynağıyla tümleştirebilirsiniz.

// In your AppHost project
var redis = builder.AddRedis("orleans-redis");

var orleans = builder.AddOrleans("cluster")
    .WithGrainStorage("Default", redis);

builder.AddProject<Projects.OrleansServer>("silo")
    .WithReference(orleans)
    .WaitFor(redis);

// Register the Redis client with keyed services.
// Orleans providers look up resources by their keyed service name.
// builder.AddKeyedRedisClient("orleans-redis");

builder.UseOrleans(siloBuilder =>
{
    siloBuilder.AddRedisGrainStorage(
        name: "redis",
        configureOptions: options =>
        {
            // Use the Aspire-provided connection string
            var connectionString = builder.Configuration.GetConnectionString("orleans-redis");
            options.ConfigurationOptions = ConfigurationOptions.Parse(connectionString!);
        });
});

Daha gelişmiş senaryolar için, IConnectionMultiplexer doğrudan CreateMultiplexer temsilcisi aracılığıyla enjekte edebilirsiniz.

// Register the Redis client with keyed services.
// Orleans providers look up resources by their keyed service name.
// builder.AddKeyedRedisClient("orleans-redis");

siloBuilder.AddRedisGrainStorage("redis");
siloBuilder.Services.AddOptions<Orleans.Persistence.RedisStorageOptions>("redis")
    .Configure<IServiceProvider>((options, sp) =>
    {
        options.CreateMultiplexer = _ =>
        {
            // Resolve the IConnectionMultiplexer from DI (provided by Aspire)
            return Task.FromResult(sp.GetRequiredService<IConnectionMultiplexer>());
        };
    });

Azure Cosmos DB tane kalıcılığı

Azure Cosmos DB , modern uygulama geliştirme için tam olarak yönetilen bir NoSQL ve ilişkisel veritabanıdır. Paket, Microsoft.Orleans.Persistence.Cosmos Cosmos DB tarafından desteklenen bir taneli depolama sağlayıcısı sağlar.

Cosmos DB parçacık depolamayı yapılandırın

Microsoft'u yükleyin.Orleans. Persistence.Cosmos NuGet paketi:

dotnet add package Microsoft.Orleans.Persistence.Cosmos

Cosmos DB için tahıl depolamayı AddCosmosGrainStorage uzantı yöntemiyle yapılandırın.

var builder = Host.CreateApplicationBuilder();
builder.UseOrleans(siloBuilder =>
{
    siloBuilder.AddCosmosGrainStorage(
        name: "cosmos",
        configureOptions: options =>
        {
            options.ConfigureCosmosClient(
                "https://myaccount.documents.azure.com:443/",
                new DefaultAzureCredential());
            options.DatabaseName = "Orleans";
            options.ContainerName = "OrleansStorage";
            options.IsResourceCreationEnabled = true;
        });
});

Cosmos DB'yi varsayılan taneli depolama sağlayıcısı olarak yapılandırmak için kullanın AddCosmosGrainStorageAsDefault:

siloBuilder.AddCosmosGrainStorageAsDefault(options =>
{
    options.ConfigureCosmosClient(
        "https://myaccount.documents.azure.com:443/",
        new DefaultAzureCredential());
    options.IsResourceCreationEnabled = true;
});

Cosmos DB depolama seçenekleri

CosmosGrainStorageOptions sınıfı aşağıdaki yapılandırma seçeneklerini sağlar:

Mülkiyet	Türü	Varsayılan	Description
DatabaseName	string	"Orleans"	Cosmos DB veritabanının adı.
ContainerName	string	"OrleansStorage"	Tahıl durumu verileri için kapsayıcının adı.
IsResourceCreationEnabled	bool	false	true olduğunda, veritabanı ve kapsayıcı yoksa otomatik olarak oluşturulur.
DeleteStateOnClear	bool	false	ClearStateAsync çağrıldığında Cosmos DB'den durumun silinip silinmeyeceğine karar verilir.
InitStage	int	ServiceLifecycleStage.ApplicationServices	Depolama başlatıldığında silo yaşam döngüsünün aşaması.
StateFieldsToIndex	List<string>	Boş	Cosmos DB dizinine eklenecek durum özelliklerinin JSON yolları.
PartitionKeyPath	string	"/PartitionKey"	Kapsayıcıdaki bölüm anahtarı için JSON yolu.
DatabaseThroughput	int?	null	Veritabanı için sağlanan aktarım hızı. ise nullsunucusuz modu kullanır.
ContainerThroughputProperties	ThroughputProperties?	null	Kapsayıcının aktarım hızı özellikleri.
ClientOptions	CosmosClientOptions	new()	Cosmos DB istemcisine geçirilen seçenekler.

Özel bölüm anahtarı sağlayıcısı

Varsayılan olarak, Orleans bölüm anahtarı olarak tanecik kimliğini kullanır. Gelişmiş senaryolar için özel bölüm anahtarı sağlayıcısı uygulayabilirsiniz:

public class MyPartitionKeyProvider : IPartitionKeyProvider
{
    public ValueTask<string> GetPartitionKey(string grainType, GrainId grainId)
    {
        // Custom logic to determine partition key
        return new ValueTask<string>(grainId.Key.ToString()!);
    }
}

Özel bölüm anahtarı sağlayıcısını kaydedin:

// Register with custom partition key provider
siloBuilder.AddCosmosGrainStorage<MyPartitionKeyProvider>(
    name: "cosmos",
    configureOptions: options =>
    {
        options.ConfigureCosmosClient("https://myaccount.documents.azure.com:443/", new DefaultAzureCredential());
    });