olmayan bir iş parçacığı güvenli sınıfa

Question

Bir sınıf olması için test oluşturulduğu aynı iş parçacığı üzerinde yapılacak Calc için tüm çağrıları gerektirir

public class Test 
{ 
    public int Calc(); 
} 

gözlemlenebilir bir sarmalayıcı oluşturun. Testi bir kez (pahalı işlem) oluşturmalı ve birden çok kez Calc'i aramalıyım.

bana asynchronousely Kireç diyelim bir sarmalayıcı olsun isterim: Bu BackgroundWorker veya Konu oluşturmak ve teminat olarak kullanmak olacaktır yapmak

public class TestWrapper 
{ 
    private Test _test; 
    public IObservable<int> Calc(); 
} 

bir yolu olduğunu tüm işlemler On Test aynı konu üzerinde. Basitlik için, Calc() 'a yapılan tüm çağrıların sırayla yürütüleceğini, yani kuyruklama konusunda endişelenmenize gerek olmadığını varsayabiliriz.

Bunu yapmak için daha zarif bir RX yolu var mı?

Diğer bir seçenek Test üyesinde [ThreadStatic] koymak kullanmaktır ...

var MyTEST = new ThreadLocal<Test>(); 

o zaman herhangi aramalar için MyTEST.Value.Calc() kullanabilirsiniz: Test senin örneğini oluştururken

Answer 1

sonra bu sınıf gereksinimlerinizi karşılamak gibi görünüyor ve sınanmış ve Calc yürütülür aynı iş parçacığı üzerinde Test oluşturur. Öte yandan, abonelik, testWrapper'un kendisi üzerinde oluşturulduğu gibi (yani arama iş parçacığı) aynı iş parçacığı üzerinde işlenir.

Answer 2

ThreadLocal<T> sınıfını kullanın sarmalayıcı sınıf ... bkz. http://msdn.microsoft.com/en-us/library/system.threadstaticattribute.aspx

'in birden fazla örneğine ihtiyacınız olup olmadığına bağlı olarakbunu Singleton yapabilirdiniz.

Answer 3

Bu yüzden yorumlarınızdan ve sorunuzu yeniden okurken, Calc() öğesini sürekli olarak bir iş parçacığında aramak ve sonuçların bir IObservable<Int>() olarak kullanılabilir olmasını ister misiniz?

Bu durumda,sınıfını sarmak için Observable.Create ve Calc uygulamasının tek bir iş parçacığı olmasını sağlamak için EventLoopScheduler kullanırdım.

public class TestWrapper 
{ 
    public TestWrapper(Func<Test> factory) 
    { 
     _scheduler = new EventLoopScheduler(); 
     _test = Observable.Start(factory, _scheduler).First(); 
    } 

    private readonly EventLoopScheduler _scheduler; 
    private readonly Test _test; 

    public IObservable<int> Calc() 
    { 
     return Observable.Start(() => _test.Calc(), _scheduler); 
    } 
} 

O şöyle kullanılır:

var testWrapper = new TestWrapper(() => new Test()); 
testWrapper.Calc().Subscribe(x => { }); 

Ben TestWrapper oluşturulduğunda Test oluşturulacak mümkün değilse

public class TestWrapper 
{ 
    private Test _test; 
    public IObservable<int> Calc() 
    { 
    return Observable.Create(obsvr => 
    { 
     var fixedThreadsched = new EventLoopScheduler(); 
     var disp = new BooleanDisposable(); 
     while (!disp.IsDisposed) 
     { 
      fixedThreadsched.Schedule(() => obsvr.OnNext(_test.Calc())); 
     } 

     return disp; 
    }); 
    } 
}