Değişmez türlerin seri hale getirilmesi Orleans

Orleans sabit türler içeren iletileri seri hale getirmeyle ilgili bazı ek yüklerden kaçınmak için kullanabileceğiniz bir özelliğe sahiptir. Bu bölümde, ilgili olduğu bağlamdan başlayarak özellik ve uygulaması açıklanmaktadır.

Serileştirme işlemi Orleans içinde

Grain yöntemini çağırdığınızda, Orleans çalışma zamanı yöntem bağımsız değişkenlerinin derin bir kopyasını oluşturur ve isteği bu kopyalardan meydana getirir. Bu, veriler çağrılan işleme geçmeden önce bağımsız değişken nesnelerini değiştiren çağırma koduna karşı koruma sağlar.

Çağrılan tahıl farklı bir silodaysa, kopyalar sonunda bir bayt akışı halinde serileştirilir ve ağ üzerinden hedef siloya gönderilir, orada nesnelere geri dönüştürülür. Çağrılan tahıl aynı silo üzerindeyse, kopyalar doğrudan çağrılan yönteme teslim edilir.

Dönüş değerleri aynı şekilde işlenir: önce kopyalanır, sonra büyük olasılıkla serileştirilebilir ve seriden çıkarılabilir.

Kopyalama, serileştirme ve seri durumdan çıkarma gibi üç işlemin de nesne kimliğine saygı duyduğunu unutmayın. Başka bir deyişle, aynı nesneyi içeren bir listeyi iki kez geçirirseniz, alıcı taraf aynı değere sahip iki nesne yerine aynı nesneye sahip bir listeyi iki kez alır.

Kopyalamayı en iyi duruma getirme

Çoğu durumda derin kopyalama gereksizdir. Örneğin, bir web ön ucunun istemcisinden bir bayt dizisi aldığı ve bayt dizisi de dahil olmak üzere bu isteği işlenmek üzere bir dilime geçirdiği bir senaryo düşünün. Ön uç süreci, diziyi öğeye geçirdikten sonra diziyle hiçbir şey yapmaz; özellikle, diziyi gelecekteki talepler için yeniden kullanmaz. Grain içerisinde, bayt dizisi giriş verilerini getirmek için ayrıştırılır ancak değiştirilmez. Grain, web istemcisine geri oluşturduğu başka bir bayt dizisi döndürür ve döndürdüğü diziyi hemen atar. Web ön ucu, sonuç bayt dizisini değiştirmeden istemcisine geri geçirir.

Böyle bir senaryoda istek veya yanıt bayt dizilerini kopyalamanız gerekmez. Ne yazık ki, Orleans çalışma zamanı, web ön ucunun mu yoksa dilimin mi dizileri daha sonra değiştireceğini belirleyemediği için bunu otomatik olarak anlayamaz. İdeal olarak, .NET mekanizması bir değerin artık değiştirilmediğini gösterir. Eksikse, Orleans için özel mekanizmalar ekledik: Immutable<T> sarmalayıcı sınıfı ve ImmutableAttribute.

Tür, parametre, özellik veya alanı değişmez olarak işaretlemek için ImmutableAttribute özniteliğini kullanın

Kullanıcı tanımlı türler için ImmutableAttribute ekleyebilirsiniz. Bu, seri hale getiriciye Orleans bu türdeki örneklerin kopyalanmasını önlemesini sağlar. Aşağıdaki kod parçacığı, ImmutableAttribute'yi değişmez bir türü belirtmek için kullanmayı gösterir. Bu tür iletim sırasında kopyalanamaz.

[Immutable]
public class MyImmutableType
{
    public int MyValue { get; }

    public MyImmutableType(int value)
    {
        MyValue = value;
    }
}

Bazen nesneyi denetlemeyebilirsiniz; örneğin, tahıllar arasında gönderdiğiniz bir List<int> olabilir. Diğer durumlarda, nesnelerinizin bazı bölümleri sabitken, diğerleri değişmez olabilir. Bu durumlar için ek Orleans seçenekleri destekler.

1. Yöntem imzaları, her bir parametre bazında ImmutableAttribute içerebilir.

   public interface ISummerGrain : IGrain
   {
     // `values` will not be copied.
     ValueTask<int> Sum([Immutable] List<int> values);
   }
   

2. İçeren türün örnekleri kopyalandığında kopyalanmalarını önlemek için tek tek özellikleri ve alanları olarak ImmutableAttribute işaretleyin.

   [GenerateSerializer]
   public sealed class MyType
   {
       [Id(0), Immutable]
       public List<int> ReferenceData { get; set; }
   
       [Id(1)]
       public List<int> RunningTotals { get; set; }
   }
   

Immutable<T> komutunu kullanma

Bir değerin Immutable<T> sabit kabul edilebileceğini belirtmek için sarmalayıcı sınıfını kullanın; yani, temel alınan değer değiştirilmez, bu nedenle güvenli paylaşım için kopyalama gerekmez. Unutmayın ki Immutable<T> kullanmak, ne sağlayıcının ne de alıcının değeri gelecekte değiştirmeyeceğini ifade eder. Bu karşılıklı, çift taraflı bir taahhüt, tek taraflı bir taahhüt değil.

Tahıl arayüzünüzde Immutable<T> kullanmak için Immutable<T> yerine T geçirin. Örneğin, yukarıda açıklanan senaryoda tahıl yöntemi şöyleydi:

Task<byte[]> ProcessRequest(byte[] request);

Bu da şu hale gelir:

Task<Immutable<byte[]>> ProcessRequest(Immutable<byte[]> request);

Bir Immutable<T> oluşturmak için, sadece onun oluşturucusunu kullanmanız yeterlidir.

Immutable<byte[]> immutable = new(buffer);

Sabit sarmalayıcının içindeki değeri almak için .Value özelliğini kullanın:

byte[] buffer = immutable.Value;

Orleans'da değişmezlik

Orleans' amacıyla değişmezlik katı bir deyimdir: Veri öğesinin içeriği, öğenin anlamsal anlamını değiştirebilecek veya başka bir iş parçacığının aynı anda erişmesini engelleyebilecek şekilde değiştirilmez. Bunu sağlamanın en güvenli yolu, öğeyi hiç değiştirmemektir: mantıksal değişmezlik yerine bit düzeyinde değişmezliği kullanın.

Bazı durumlarda, bunu mantıksal değişmezlik düzeyine gevşetmek güvenlidir, ancak değişen kodun eşzamanlılık açısından güvenli olduğundan emin olmanız gerekir. Çoklu iş parçacığı kullanımı bir Orleans bağlamında yaygın olmadığından ve karmaşık olduğundan, bu yaklaşımdan kesinlikle kaçınmanızı tavsiye ederiz ve bit düzeyinde değişmezliğe bağlı kalmanızı öneririz.