/// <summary>
/// Disposes of managed memory for the class.
/// </summary>
/// <param name="disposing">If this method is being called by the Dispose method.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_queuedOps?.Dispose();
_shutdownObs?.Dispose();
}
}
private void OnDestroy()
{
// Observableがまだ動いていたら止める
_disposable?.Dispose();
// AsyncSubjectを破棄
_onTimeUpAsyncSubject.Dispose();
}
/// <summary>
/// Disposes of the resources.
/// </summary>
/// <param name="disposing">A value indicating whether the instance is disposing.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
_appearing.Dispose();
PageDisposables.Dispose();
}
}
public void HasObservers_Dispose3()
{
var s = new AsyncSubject <int>();
Assert.IsFalse(s.HasObservers);
s.Dispose();
Assert.IsFalse(s.HasObservers);
}
public void Dispose()
{
if (subject.IsCompleted)
{
var disposable = subject.GetResult();
if (disposable != null)
{
disposable.Dispose();
}
}
subject.Dispose();
}
internal static IObservable <T> ToAsyncSource <T>(this IObservable <T> source, Duration lifetime, IClock clock)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
var gate = new object();
AsyncSubject <T>?subject = null;
IDisposable? connection = null;
var updated = Instant.MinValue;
var complete = false;
return(Observable.Create <T>(observer =>
{
lock (gate)
{
if (subject == null || ((clock.GetCurrentInstant() - updated > lifetime || !complete) && !subject.HasObservers))
{
subject?.Dispose();
subject = new AsyncSubject <T>();
complete = false;
updated = clock.GetCurrentInstant();
connection?.Dispose();
connection = source
.Subscribe(
onNext: subject.OnNext,
onError: subject.OnError,
onCompleted: () =>
{
lock (gate)
{
complete = true;
subject.OnCompleted();
}
});
}
var subscription = subject.Subscribe(observer);
return Disposable.Create(() =>
{
lock (gate)
subscription.Dispose();
});
}
}));
}
/// <summary>
/// Disposes managed resources that are disposable and handles cleanup of unmanaged items.
/// </summary>
/// <param name="isDisposing">If we are disposing managed resources.</param>
protected virtual void Dispose(bool isDisposing)
{
if (_isDisposed)
{
return;
}
if (isDisposing)
{
_queuedOps?.Dispose();
_shutdownObs?.Dispose();
}
_isDisposed = true;
}
public void HasObservers_Dispose2()
{
var s = new AsyncSubject <int>();
Assert.IsFalse(s.HasObservers);
var d = s.Subscribe(_ => { });
Assert.IsTrue(s.HasObservers);
d.Dispose();
Assert.IsFalse(s.HasObservers);
s.Dispose();
Assert.IsFalse(s.HasObservers);
}
/// <summary>
/// クライアントを破棄する
/// </summary>
public void Dispose()
{
lock (lockObject)
{
if (_ws != null)
{
_ws.Close();
}
if (_disposedEventAsyncSubject != null)
{
_disposedEventAsyncSubject.OnNext(Unit.Default);
_disposedEventAsyncSubject.OnCompleted();
_disposedEventAsyncSubject.Dispose();
}
_ws = null;
_isDisposed = true;
}
}
/// <summary>
/// Acquires the read or write lock on the scheduler, as observable.
/// </summary>
/// <param name="schedulingTaskFactory">The task factory.</param>
/// <returns></returns>
private IObservable <ReaderWriterLock> AcquireReadOrWriteLockObservable(TaskFactory schedulingTaskFactory)
{
// check for incorrect entry once we have already been disposed
if (IsDisposed)
{
return(Observable.Throw <ReaderWriterLock>(new ObjectDisposedException(this.GetType().Name)));
}
// basically what happens here is we use the (concurrent) reader or (exclusive) handed in
// and schedule a new tpl task on it which merely wraps or contains chained IDisposable creation.
// What happens then is, we return a 'future' promise or timeslot for whenever the ConcurrentExclusiveSchedulerPair
// does actually start working on that TPL task (meaning that by its own, internal r/w locking, the task was up next).
// this is the result we hand back to the caller
var asyncSubject = new AsyncSubject <ReaderWriterLock>();
var gate = new AsyncSubject <Unit>();
schedulingTaskFactory.StartNew(async() =>
{
// this asyncSubject is the one actually handed back to the method's caller as IDisposable instance
// & whenever that one is disposed, the gate gets unblocked \o/
asyncSubject.OnNext(
new ReaderWriterLock(
Interlocked.Increment(ref _scheduledOperationId),
schedulingTaskFactory == ExclusiveTaskFactory,
Disposable.Create(() =>
{
gate.OnNext(Unit.Default);
gate.OnCompleted();
})));
asyncSubject.OnCompleted();
// once the asyncSubject's ticket has been disposed, this gate gets unlocked, too
await gate;
// cleanup
gate.Dispose();
gate = null;
});
return(asyncSubject);
}
protected async Task <bool> HookProgress(AsyncOperation operation, ProgressDelegate progress, float weight = 1.0f)
{
var promise = new AsyncSubject <int>();
var disposable = Observable.Interval(TimeSpan.FromSeconds(1 / 30f))
.Select(x => new ProgressInfo()
{
current = x,
total = operation.allowSceneActivation ? 1f : 0.9f,
weight = weight,
})
.TakeWhile(x =>
{
if (x.current < x.total)
{
return(true);
}
if (progress != null)
{
progress(x.Percent());
}
promise.OnNext(0);
promise.OnCompleted();
return(false);
}).Subscribe(x =>
{
if (progress != null)
{
progress(x.Percent());
}
});
await promise;
promise.Dispose();
disposable.Dispose();
return(true);
}
// Update is called once per frame
void OnDestory()
{
_Disposable?.Dispose();
_OnTimeUpAsyncSubject.Dispose();
}
public void Dispose()
{
_shutdownSignal.Dispose();
GC.SuppressFinalize(this);
}
/// <summary>
/// Acquires the read or write lock on the scheduler, as observable.
/// </summary>
/// <param name="schedulingTaskFactory">The task factory.</param>
/// <returns></returns>
private IObservable<ReaderWriterLock> AcquireReadOrWriteLockObservable(TaskFactory schedulingTaskFactory)
{
// check for incorrect entry once we have already been disposed
if (IsDisposed)
return Observable.Throw<ReaderWriterLock>(new ObjectDisposedException(this.GetType().Name));
// basically what happens here is we use the (concurrent) reader or (exclusive) handed in
// and schedule a new tpl task on it which merely wraps or contains chained IDisposable creation.
// What happens then is, we return a 'future' promise or timeslot for whenever the ConcurrentExclusiveSchedulerPair
// does actually start working on that TPL task (meaning that by its own, internal r/w locking, the task was up next).
// this is the result we hand back to the caller
var asyncSubject = new AsyncSubject<ReaderWriterLock>();
var gate = new AsyncSubject<Unit>();
schedulingTaskFactory.StartNew(async () =>
{
// this asyncSubject is the one actually handed back to the method's caller as IDisposable instance
// & whenever that one is disposed, the gate gets unblocked \o/
asyncSubject.OnNext(
new ReaderWriterLock(
Interlocked.Increment(ref _scheduledOperationId),
schedulingTaskFactory == ExclusiveTaskFactory,
Disposable.Create(() =>
{
gate.OnNext(Unit.Default);
gate.OnCompleted();
})));
asyncSubject.OnCompleted();
// once the asyncSubject's ticket has been disposed, this gate gets unlocked, too
await gate;
// cleanup
gate.Dispose();
gate = null;
});
return asyncSubject;
}
public void HasObservers_Dispose3()
{
var s = new AsyncSubject<int>();
Assert.IsFalse(s.HasObservers);
Assert.IsFalse(s.IsDisposed);
s.Dispose();
Assert.IsFalse(s.HasObservers);
Assert.IsTrue(s.IsDisposed);
}
public void Dispose() => subject.Dispose();
public bool TrySetCanceled()
{
_tcs.Dispose();
_tcs.OnCompleted();
return(true);
}
public void Dispose()
{
subject.Dispose();
}
public void HasObservers_Dispose2()
{
var s = new AsyncSubject<int>();
Assert.IsFalse(s.HasObservers);
Assert.IsFalse(s.IsDisposed);
var d = s.Subscribe(_ => { });
Assert.IsTrue(s.HasObservers);
Assert.IsFalse(s.IsDisposed);
d.Dispose();
Assert.IsFalse(s.HasObservers);
Assert.IsFalse(s.IsDisposed);
s.Dispose();
Assert.IsFalse(s.HasObservers);
Assert.IsTrue(s.IsDisposed);
}
public void Dispose()
{
_subject.Dispose();
GC.SuppressFinalize(this);
}
void Destroy()
{
disposable?.Dispose();
onTimeUpAsyncSubject.Dispose();
}
public void Dispose()
{
_asyncSubject.Dispose();
}
