public static IObservable <T> ToObservable <T>(this UniTask <T> task)
{
if (task.IsCompleted)
{
try
{
return(Observable.Return <T>(task.GetAwaiter().GetResult()));
}
catch (Exception ex)
{
return(Observable.Throw <T>(ex));
}
}
var subject = new AsyncSubject <T>();
Fire(subject, task).Forget();
return(subject);
}
static AsyncSubject <TSource> RunAsync <TSource>(IConnectableObservable <TSource> source, CancellationToken cancellationToken)
{
AsyncSubject <TSource> s = new AsyncSubject <TSource>();
if (cancellationToken.IsCancellationRequested)
{
return(Cancel(s, cancellationToken));
}
IDisposable d = source.Subscribe(s);
IDisposable c = source.Connect();
if (cancellationToken.CanBeCanceled)
{
RegisterCancelation(s, StableCompositeDisposable.Create(d, c), cancellationToken);
}
return(s);
}
public static IObservable <Unit> ToObservable(this UniTask task)
{
if (task.IsCompleted)
{
try
{
return(Observable.ReturnUnit());
}
catch (Exception ex)
{
return(Observable.Throw <Unit>(ex));
}
}
var subject = new AsyncSubject <Unit>();
Fire(subject, task).Forget();
return(subject);
}
static void RegisterCancelation<T>(AsyncSubject<T> subject, IDisposable subscription, CancellationToken token) {
//
// Separate method used to avoid heap allocation of closure when no cancellation is needed,
// e.g. when CancellationToken.None is provided to the RunAsync overloads.
//
var ctr = token.Register(() => {
subscription.Dispose();
Cancel(subject, token);
});
//
// No null-check for ctr is needed:
//
// - CancellationTokenRegistration is a struct
// - Registration will succeed 99% of the time, no warranting an attempt to avoid spurious Subscribe calls
//
subject.Subscribe(Stubs<T>.Ignore, _ => ctr.Dispose(), ctr.Dispose);
}
/// <summary>
/// <para>Create an Observable that emits the return value of a function-like directive asynchronously</para>
///
/// <para>There are a number of ways that programming languages have for obtaining values as
/// the result of calculations, with names like functions, futures, actions, callables,
/// runnables, and so forth. The operators grouped here under the Start operator category
/// make these things behave like Observables so that they can be chained with other
/// Observables in an Observable cascade</para>
/// </summary>
/// <see cref="http://reactivex.io/documentation/operators/start.html"/>
public static Func <IObservable <Unit> > ToAsync(this Action action, IScheduler scheduler)
{
return(() => {
var subject = new AsyncSubject <Unit>();
scheduler.Schedule(() => {
try {
action();
} catch (Exception exception) {
subject.OnError(exception);
return;
}
subject.OnNext(Unit.Default);
subject.OnCompleted();
});
return subject.AsObservable();
});
}
/// <summary>
/// <para>Create an Observable that emits the return value of a function-like directive asynchronously</para>
///
/// <para>There are a number of ways that programming languages have for obtaining values as
/// the result of calculations, with names like functions, futures, actions, callables,
/// runnables, and so forth. The operators grouped here under the Start operator category
/// make these things behave like Observables so that they can be chained with other
/// Observables in an Observable cascade</para>
/// </summary>
/// <see cref="http://reactivex.io/documentation/operators/start.html"/>
public static Func <IObservable <T> > ToAsync <T>(this Func <T> function, IScheduler scheduler)
{
return(() => {
var subject = new AsyncSubject <T>();
scheduler.Schedule(() => {
var result = default(T);
try {
result = function();
} catch (Exception exception) {
subject.OnError(exception);
return;
}
subject.OnNext(result);
subject.OnCompleted();
});
return subject.AsObservable();
});
}
public void Dispose()
{
lock (gate) {
if (parent != null)
{
lock (parent.observerLock) {
var listObserver = parent.outObserver as ListObserver <T>;
if (listObserver != null)
{
parent.outObserver = listObserver.Remove(unsubscribeTarget);
}
else
{
parent.outObserver = EmptyObserver <T> .Instance;
}
unsubscribeTarget = null;
parent = null;
}
}
}
}
public Subscription(AsyncSubject <T> parent, IObserver <T> unsubscribeTarget)
{
this.parent = parent;
this.unsubscribeTarget = unsubscribeTarget;
}
static AsyncSubject<T> Cancel<T>(AsyncSubject<T> subject, CancellationToken cancellationToken)
{
subject.OnError(new OperationCanceledException(cancellationToken));
return subject;
}
public AsyncSubjectDisposable(AsyncSubject <T> parent, IObserver <T> downstream)
{
_parent = parent;
Downstream = downstream;
}