TaskObservableMethodBuilder<T>
Represents a builder for asynchronous methods that return a task-like ITaskObservable<T>.
using System.Reactive;
using System.Reactive.Concurrency;
using System.Reactive.Disposables;
using System.Reactive.Subjects;
using System.Security;
namespace System.Runtime.CompilerServices
{
[System.Runtime.CompilerServices.NullableContext(1)]
[System.Runtime.CompilerServices.Nullable(0)]
public struct TaskObservableMethodBuilder<[System.Runtime.CompilerServices.Nullable(2)] T>
{
[System.Runtime.CompilerServices.Nullable(0)]
internal sealed class TaskObservable : ITaskObservable<T>, IObservable<T>, ITaskObservableAwaiter<T>, INotifyCompletion
{
[System.Runtime.CompilerServices.Nullable(new byte[] {
2,
1
})]
private readonly AsyncSubject<T> _subject;
[System.Runtime.CompilerServices.Nullable(2)]
private readonly T _result;
[System.Runtime.CompilerServices.Nullable(2)]
private readonly Exception _exception;
public bool IsCompleted {
get {
AsyncSubject<T> subject = _subject;
if (subject == null)
return true;
return subject.IsCompleted;
}
}
public TaskObservable()
{
_subject = new AsyncSubject<T>();
}
public TaskObservable(T result)
{
_result = result;
}
public TaskObservable(Exception exception)
{
_exception = exception;
}
public void SetResult(T result)
{
if (IsCompleted)
throw new InvalidOperationException();
_subject.OnNext(result);
_subject.OnCompleted();
}
public void SetException(Exception exception)
{
if (IsCompleted)
throw new InvalidOperationException();
_subject.OnError(exception);
}
public IDisposable Subscribe(IObserver<T> observer)
{
if (_subject != null)
return _subject.Subscribe(observer);
if (_exception != null) {
observer.OnError(_exception);
return Disposable.Empty;
}
observer.OnNext(_result);
return Disposable.Empty;
}
public ITaskObservableAwaiter<T> GetAwaiter()
{
return this;
}
public T GetResult()
{
if (_subject != null)
return _subject.GetResult();
Exception exception = _exception;
if (exception != null)
exception.Throw();
return _result;
}
public void OnCompleted(Action continuation)
{
if (_subject != null)
_subject.OnCompleted(continuation);
else
continuation();
}
}
private IAsyncStateMachine _stateMachine;
[System.Runtime.CompilerServices.Nullable(new byte[] {
1,
0
})]
private TaskObservable _inner;
public ITaskObservable<T> Task => _inner ?? (_inner = new TaskObservable());
[return: System.Runtime.CompilerServices.Nullable(new byte[] {
0,
1
})]
public static TaskObservableMethodBuilder<T> Create()
{
return default(TaskObservableMethodBuilder<T>);
}
public void Start<[System.Runtime.CompilerServices.Nullable(0)] TStateMachine>(ref TStateMachine stateMachine) where TStateMachine : IAsyncStateMachine
{
if (stateMachine == null)
throw new ArgumentNullException("stateMachine");
stateMachine.MoveNext();
}
public void SetStateMachine(IAsyncStateMachine stateMachine)
{
if (_stateMachine != null)
throw new InvalidOperationException();
if (stateMachine == null)
throw new ArgumentNullException("stateMachine");
_stateMachine = stateMachine;
}
public void SetResult(T result)
{
if (_inner == null)
_inner = new TaskObservable(result);
else
_inner.SetResult(result);
}
public void SetException(Exception exception)
{
if (exception == null)
throw new ArgumentNullException("exception");
if (_inner == null)
_inner = new TaskObservable(exception);
else
_inner.SetException(exception);
}
public void AwaitOnCompleted<[System.Runtime.CompilerServices.Nullable(0)] TAwaiter, [System.Runtime.CompilerServices.Nullable(0)] TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : INotifyCompletion where TStateMachine : IAsyncStateMachine
{
try {
if (this._stateMachine == null) {
ITaskObservable<T> task = this.Task;
this._stateMachine = (IAsyncStateMachine)(object)stateMachine;
this._stateMachine.SetStateMachine(this._stateMachine);
}
ref TAwaiter reference = ref awaiter;
TAwaiter val = default(TAwaiter);
if (val == null) {
val = reference;
ref reference = ref val;
}
IAsyncStateMachine stateMachine2 = this._stateMachine;
reference.OnCompleted(stateMachine2.MoveNext);
} catch (Exception exception) {
TaskObservableMethodBuilder<T>.Rethrow(exception);
}
}
[SecuritySafeCritical]
public void AwaitUnsafeOnCompleted<[System.Runtime.CompilerServices.Nullable(0)] TAwaiter, [System.Runtime.CompilerServices.Nullable(0)] TStateMachine>(ref TAwaiter awaiter, ref TStateMachine stateMachine) where TAwaiter : ICriticalNotifyCompletion where TStateMachine : IAsyncStateMachine
{
try {
if (this._stateMachine == null) {
ITaskObservable<T> task = this.Task;
this._stateMachine = (IAsyncStateMachine)(object)stateMachine;
this._stateMachine.SetStateMachine(this._stateMachine);
}
ref TAwaiter reference = ref awaiter;
TAwaiter val = default(TAwaiter);
if (val == null) {
val = reference;
ref reference = ref val;
}
IAsyncStateMachine stateMachine2 = this._stateMachine;
reference.UnsafeOnCompleted(stateMachine2.MoveNext);
} catch (Exception exception) {
TaskObservableMethodBuilder<T>.Rethrow(exception);
}
}
private static void Rethrow(Exception exception)
{
Scheduler.Schedule<Exception>((IScheduler)Scheduler.Default, exception, (Action<Exception, Action<Exception>>)delegate(Exception ex, Action<Exception> recurse) {
ex.Throw();
});
}
}
}