public IDisposable Run()
{
_totalTime = TimeSpan.Zero;
_nextShift = _parent._timeShift;
_nextSpan = _parent._timeSpan;
_gate = new object();
_q = new Queue <ISubject <TSource> >();
_timerD = new SerialDisposable();
var groupDisposable = new CompositeDisposable(2)
{
_timerD
};
_refCountDisposable = new RefCountDisposable(groupDisposable);
CreateWindow();
CreateTimer();
groupDisposable.Add(_parent._source.SubscribeSafe(this));
return(_refCountDisposable);
}
public IDisposable Subscribe(ICompletableObserver observer)
{
var velocity = GetVelocity(_property).ToReactiveProperty();
var outerDisposable = new SingleAssignmentDisposable();
var currentTween = new SerialDisposable();
var observerCompletion = new RefCountDisposable(Disposable.Create(observer.OnCompleted));
outerDisposable.Disposable = new CompositeDisposable
(
_target.Subscribe(x =>
{
// Prevent observer from completing while there is a tween in progress
var tweenCompletion = observerCompletion.GetDisposable();
// Dispose any previous tween in progress, if any
currentTween.Disposable = new CompositeDisposable
(
Tween(_property, x, _duration, velocity.Value, _easer)
.SubscribeAndForget(tweenCompletion.Dispose),
tweenCompletion
);
},
() => observerCompletion.Dispose()),
currentTween
);
return(outerDisposable);
}
public void RefCountDisposable_AsFactory_Test()
{
// arrange
const int COUNT = 10;
var innerDisposable = new BooleanDisposable();
var dispFactory = new RefCountDisposable(innerDisposable);
// act
var dispodables = from i in Enumerable.Range(0, COUNT)
// will produce a related disposable
select dispFactory.GetDisposable();
dispodables = dispodables.ToArray();
dispFactory.Dispose(); // Start with single reference
// verify
foreach (IDisposable d in dispodables)
{
Assert.IsFalse(innerDisposable.IsDisposed);
Assert.IsFalse(dispFactory.IsDisposed);
d.Dispose();
}
Assert.IsTrue(dispFactory.IsDisposed);
Assert.IsTrue(innerDisposable.IsDisposed);
}
public static ISequence <ISequence <T> > Window <T>(this ISequence <T> source, int windowSize, int queueLimit = 1)
{
if (queueLimit < 1)
{
throw new ArgumentOutOfRangeException("queueLimit must be greater that one.");
}
return(Create <ISequence <T> >(context =>
{
Task <bool> lastCopyToResult = null;
var i = source.Start(context);
var subscription = new RefCountDisposable(i);
return Iterator.Create <ISequence <T> >(async(r, c) =>
{
if (lastCopyToResult != null && await lastCopyToResult.ConfigureAwait(false) == false)
{
return false;
}
if (!await i.MoveNext(c).ConfigureAwait(false))
{
return false;
}
var queue = new AsyncQueue <T>(queueLimit);
await queue.OnNext(i.Current, c).ConfigureAwait(false);
r.Value = Create(context2 => new AnonymousIterator <T>(queue.MoveNext, () => queue.Current, queue.Dispose, Enumerable.Empty <Task>, context2));
var keepAlive = subscription.GetDisposable();
lastCopyToResult = CopyToQueue(i, queue, windowSize - 1, CancellationToken.None, true).Finally(keepAlive.Dispose);
return true;
}, context, subscription);
}));
}
public static ONIDisposable ReserveDAQ(uint context_index = 0)
{
Tuple <ONIController, RefCountDisposable> oni_context;
lock (openContextsLock)
{
if (!openContexts.TryGetValue(context_index, out oni_context)) // Context has not been opened yet
{
ONIController oni; // Does not call constructor
var configuration = LoadConfiguration();
if (configuration.Contains(context_index)) // There is a configuration file specifying non-default channel paths
{
var config = configuration[context_index]; // Nothing used yet
oni = new ONIController(config.ConfigurationPath, config.DataInputPath, config.SignalPath);
}
else
{
oni = new ONIController(); // Default params
}
var dispose = Disposable.Create(() =>
{
//oni.DAQ.Dispose(false);
openContexts.Remove(context_index);
});
var ref_count = new RefCountDisposable(dispose);
oni_context = Tuple.Create(oni, ref_count);
openContexts.Add(context_index, oni_context);
return(new ONIDisposable(oni, ref_count));
}
}
return(new ONIDisposable(oni_context.Item1, oni_context.Item2.GetDisposable())); // New reference
}
public void RefCountDisposable_RefCounting()
{
var d = new BooleanDisposable();
var r = new RefCountDisposable(d);
Assert.False(d.IsDisposed);
var d1 = r.GetDisposable();
var d2 = r.GetDisposable();
Assert.False(d.IsDisposed);
d1.Dispose();
Assert.False(d.IsDisposed);
d2.Dispose();
Assert.False(d.IsDisposed); // CHECK
r.Dispose();
Assert.True(d.IsDisposed);
Assert.True(r.IsDisposed);
var d3 = r.GetDisposable(); // CHECK
d3.Dispose();
}
/// <summary>
/// Runs or observes a single catchup batch asynchronously for multiple catchup instances.
/// </summary>
public static IObservable <ReadModelCatchupStatus> SingleBatchAsync(
params ReadModelCatchup <ReadModelDbContext>[] catchups)
{
return(Observable.Create <ReadModelCatchupStatus>(observer =>
{
if (!catchups?.Any() ?? true)
{
observer.OnCompleted();
return Disposable.Empty;
}
var completions = new RefCountDisposable(Disposable.Create(observer.OnCompleted));
var subscriptions = new CompositeDisposable();
catchups.ForEach(catchup =>
{
var completion = completions.GetDisposable();
var sub = catchup.SingleBatchAsync()
.Subscribe(onNext: observer.OnNext,
onCompleted: completion.Dispose);
subscriptions.Add(sub);
});
completions.Dispose();
return subscriptions;
}));
}
public IDisposable Run()
{
groupDisposable = new CompositeDisposable();
refCountDisposable = new RefCountDisposable(groupDisposable);
groupDisposable.Add(parent.source.Subscribe(this));
return(refCountDisposable);
}
public static void RefCountDisposable_SuppliesAsManyDependentDisposablesAsYouNeed_ButOnlyGetsDisposedAfterAllDependentsAreDisposedOf()
{
//Can be used as part of a synchonization mechanism
var refCountDisposable = new RefCountDisposable(
Disposable.Create(() =>
Debug.WriteLine("Underlying disposable has been disposed.")));
var firstDependentDisposable = refCountDisposable.GetDisposable();
var secondDependentDisposable = refCountDisposable.GetDisposable();
var thirdDependentDisposable = refCountDisposable.GetDisposable();
Console.WriteLine("Disposing of the second dependent.");
secondDependentDisposable.Dispose();
Console.WriteLine("Trying to dispose of the RefCountDisposable");
refCountDisposable.Dispose();
Console.WriteLine($"Evidently it fails! RefCountDisposable is disposed: {refCountDisposable.IsDisposed}");
Console.WriteLine("Disposing of the third dependent.");
thirdDependentDisposable.Dispose();
Console.WriteLine("Disposing of the first dependent.");
firstDependentDisposable.Dispose();
Console.WriteLine($"Now that the last dependent is disposed, RefCountDisposable is disposed: {refCountDisposable.IsDisposed}");
}
public IObservable <IParseResult <IObservable <TResult> > > Parse(IObservableCursor <TSource> source)
{
return(Observable.Defer(() =>
{
firstParser = null;
bool first = true;
var any = new AnyObservableParser <TSource, TResult>(parsers);
var except = new List <IObservableParser <TSource, TResult> >();
// See the AllObservableParser.Parse method for an explanation of the optimization that is provided by SelectMany's TContext argument
var root = source.Branch();
var rootDisposable = new RefCountDisposable(root);
return ObservableParseResult.ReturnSuccessMany <TResult>(0)
.SelectMany(
Tuple.Create(root, rootDisposable),
parsers.Select(
parser => (Func <Tuple <IObservableCursor <TSource>, RefCountDisposable>, Tuple <IParseResult <IObservable <TResult> >, bool>, Tuple <Tuple <IObservableCursor <TSource>, RefCountDisposable>, IObservable <IParseResult <IObservable <TResult> > > > >)
((context, value) =>
{
if (first)
{
first = false;
firstParser = parser;
}
var branch = context.Item1;
var disposable = context.Item2;
var refDisposable = disposable.GetDisposable();
IObservable <IParseResult <IObservable <TResult> > > results;
// Item2 is only true when value.Item1 is the last element of its sequence.
if (value.Item2)
{
branch.Move(value.Item1.Length);
results = any.Parse(except, branch)
.Select(result => result.YieldMany())
.Finally(refDisposable.Dispose);
}
else
{
branch = branch.Remainder(value.Item1.Length);
disposable = new RefCountDisposable(new CompositeDisposable(branch, refDisposable));
results = any.Parse(except, branch)
.Select(result => result.YieldMany())
.Finally(disposable.Dispose);
}
return Tuple.Create(Tuple.Create(branch, disposable), results);
})),
(firstResult, otherResults) => firstResult.Concat(otherResults))
.Finally(rootDisposable.Dispose);
}));
}
public IDisposable Run(IObservable <TSource> source)
{
var sourceSubscription = new SingleAssignmentDisposable();
_refCountDisposable = new RefCountDisposable(sourceSubscription);
sourceSubscription.Disposable = source.SubscribeSafe(this);
return(_refCountDisposable);
}
public _(Count parent, IObserver <IObservable <TSource> > observer)
: base(observer)
{
_refCountDisposable = new RefCountDisposable(_m);
_count = parent._count;
_skip = parent._skip;
}
static IObservable <T> AddRef <T>(IObservable <T> xs, RefCountDisposable r)
{
return(Observable.Create <T>((IObserver <T> observer) => new CompositeDisposable(new IDisposable[]
{
r.GetDisposable(),
xs.Subscribe(observer)
})));
}
public override void Run(IObservable <TSource> source)
{
var sourceSubscription = new SingleAssignmentDisposable();
_refCountDisposable = new RefCountDisposable(sourceSubscription);
sourceSubscription.Disposable = source.SubscribeSafe(this);
SetUpstream(_refCountDisposable);
}
public void Open()
{
if (String.IsNullOrEmpty(connectionName))
{
return;
}
lock (sync) {
//если две нитки используют один RasHelper и одна уже получила ссылку
if (connectionRef != Disposable.Empty)
{
return;
}
//если соединение есть и его открыли мы тогда берем ссылку
if (connection != null && !connection.IsDisposed)
{
connectionRef = connection.GetDisposable();
return;
}
//если соединение открыли не мы, тогда выходим
if (RasConnection.GetActiveConnections().Any(c => c.EntryName == connectionName))
{
return;
}
string phonebookPath = null;
foreach (var path in GetPhoneBooks())
{
using (var book = new RasPhoneBook()) {
book.Open(path);
if (book.Entries.Any(e => e.Name.Match(connectionName)))
{
phonebookPath = book.Path;
}
}
}
if (phonebookPath == null)
{
log.Warn($"Не удалось найти соединение {connectionName}, удаленное соединение устанавливаться не будет");
return;
}
using (var dialer = new RasDialer()) {
dialer.PhoneBookPath = phonebookPath;
dialer.EntryName = connectionName;
var handle = dialer.Dial();
var rasConnection = RasConnection.GetActiveConnections().FirstOrDefault(c => c.Handle == handle);
connection = new RefCountDisposable(Disposable.Create(() => rasConnection?.HangUp()));
connectionRef = connection.GetDisposable();
connection.Dispose();
}
}
}
public _(GroupByUntil <TSource, TKey, TElement, TDuration> parent, IObserver <IGroupedObservable <TKey, TElement> > observer)
: base(observer)
{
_refCountDisposable = new RefCountDisposable(_groupDisposable);
_map = new Map <TKey, ISubject <TElement> >(parent._capacity, parent._comparer);
_keySelector = parent._keySelector;
_elementSelector = parent._elementSelector;
_durationSelector = parent._durationSelector;
}
public void RefCountDisposable_SingleReference()
{
var d = new BooleanDisposable();
var r = new RefCountDisposable(d);
Assert.False(d.IsDisposed);
r.Dispose();
Assert.True(d.IsDisposed);
r.Dispose();
Assert.True(d.IsDisposed);
}
public void RefCountDisposable_Throw_If_Disposed()
{
var d = new BooleanDisposable();
var r = new RefCountDisposable(d, true);
r.Dispose();
Assert.True(d.IsDisposed);
ReactiveAssert.Throws <ObjectDisposedException>(() => { r.GetDisposable(); });
}
internal static ArduinoDisposable ReserveConnection(string portName, ArduinoConfiguration arduinoConfiguration)
{
var connection = default(Tuple <Arduino, RefCountDisposable>);
lock (openConnectionsLock)
{
if (string.IsNullOrEmpty(portName))
{
if (!string.IsNullOrEmpty(arduinoConfiguration.PortName))
{
portName = arduinoConfiguration.PortName;
}
else if (openConnections.Count == 1)
{
connection = openConnections.Values.Single();
}
else
{
throw new ArgumentException("An alias or serial port name must be specified.", "portName");
}
}
if (connection == null && !openConnections.TryGetValue(portName, out connection))
{
var serialPortName = arduinoConfiguration.PortName;
if (string.IsNullOrEmpty(serialPortName))
{
serialPortName = portName;
}
var configuration = LoadConfiguration();
if (configuration.Contains(serialPortName))
{
arduinoConfiguration = configuration[serialPortName];
}
var arduino = new Arduino(serialPortName, arduinoConfiguration.BaudRate);
arduino.Open();
arduino.SamplingInterval(arduinoConfiguration.SamplingInterval);
var dispose = Disposable.Create(() =>
{
arduino.Close();
openConnections.Remove(portName);
});
var refCount = new RefCountDisposable(dispose);
connection = Tuple.Create(arduino, refCount);
openConnections.Add(portName, connection);
return(new ArduinoDisposable(arduino, refCount));
}
}
return(new ArduinoDisposable(connection.Item1, connection.Item2.GetDisposable()));
}
public _(GroupJoin <TLeft, TRight, TLeftDuration, TRightDuration, TResult> parent, IObserver <TResult> observer, IDisposable cancel)
: base(observer, cancel)
{
_refCount = new RefCountDisposable(_group);
_leftMap = new SortedDictionary <int, IObserver <TRight> >();
_rightMap = new SortedDictionary <int, TRight>();
_leftDurationSelector = parent._leftDurationSelector;
_rightDurationSelector = parent._rightDurationSelector;
_resultSelector = parent._resultSelector;
}
/// <summary>
/// RefCountDisposable 可以使用 GetDisposable 来生成新的 Disposable，并且只会在生成的 Disposable 全部调用完 Dispose 之后，才会执行自己的 Dispose
/// </summary>
public static void RefCountDisposable()
{
var refCount = new RefCountDisposable(Disposable.Create(() => Console.WriteLine("Disposing refCount")));
var d1 = refCount.GetDisposable();
var d2 = refCount.GetDisposable();
refCount.Dispose();
Console.WriteLine("Disposing 1st");
d1.Dispose();
Console.WriteLine("Disposing 2nd");
d2.Dispose();
}
protected override IDisposable Run(IObserver <IGroupedObservable <TKey, TElement> > observer, IDisposable cancel, Action <IDisposable> setSink)
{
_groupDisposable = new CompositeDisposable();
_refCountDisposable = new RefCountDisposable(_groupDisposable);
var sink = new _(this, observer, cancel);
setSink(sink);
_groupDisposable.Add(_source.SubscribeSafe(sink));
return(_refCountDisposable);
}
public void Run(TimeHopping parent)
{
var groupDisposable = new CompositeDisposable(2);
_refCountDisposable = new RefCountDisposable(groupDisposable);
CreateWindow();
groupDisposable.Add(parent._scheduler.SchedulePeriodic(parent._timeSpan, Tick));
groupDisposable.Add(parent._source.SubscribeSafe(this));
SetUpstream(_refCountDisposable);
}
internal static AudioContextDisposable ReserveContext(string deviceName, int sampleRate, int refresh)
{
if (string.IsNullOrEmpty(deviceName))
{
var currentContext = OpenTK.Audio.AudioContext.CurrentContext;
if (currentContext != null)
{
deviceName = currentContext.CurrentDevice;
}
else
{
deviceName = OpenTK.Audio.AudioContext.DefaultDevice;
}
}
Tuple <AudioContext, RefCountDisposable> activeContext;
lock (activeContextLock)
{
if (!activeContexts.TryGetValue(deviceName, out activeContext))
{
AudioContext context;
var configuration = LoadConfiguration();
if (configuration.Contains(deviceName))
{
var contextConfiguration = configuration[deviceName];
context = new AudioContext(
deviceName,
contextConfiguration.SampleRate,
contextConfiguration.Refresh);
}
else
{
context = new AudioContext(deviceName, sampleRate, refresh);
}
var dispose = Disposable.Create(() =>
{
context.Dispose();
activeContexts.Remove(deviceName);
});
var refCount = new RefCountDisposable(dispose);
activeContext = Tuple.Create(context, refCount);
activeContexts.Add(deviceName, activeContext);
return(new AudioContextDisposable(context, refCount));
}
}
return(new AudioContextDisposable(activeContext.Item1, activeContext.Item2.GetDisposable()));
}
public static IDisposable Subscribe(Func <ObservableConsole, IDisposable> subscribe)
{
lock (_systemConsoleSwapLock)
{
if (_refCount is null || _refCount.IsDisposed)
{
var console = new ConsoleOutput
{
_originalOutputWriter = Console.Out,
_originalErrorWriter = Console.Error
};
_out = new MultiplexingTextWriter();
_error = new MultiplexingTextWriter();
Console.SetOut(_out);
Console.SetError(_error);
_refCount = new RefCountDisposable(Disposable.Create(() =>
{
_out = null;
_error = null;
_refCount = null;
console.RestoreSystemConsole();
}));
}
var writerForCurrentContext = EnsureInitializedForCurrentAsyncContext();
var observableConsole = new ObservableConsole(
@out: _out.GetObservable(),
error: _error.GetObservable());
return(new CompositeDisposable
{
_refCount,
_refCount.GetDisposable(),
subscribe(observableConsole),
writerForCurrentContext
});
IDisposable EnsureInitializedForCurrentAsyncContext() =>
new CompositeDisposable
{
_out.EnsureInitializedForCurrentAsyncContext(),
_error.EnsureInitializedForCurrentAsyncContext()
};
}
}
public void Dispose()
{
RefCountDisposable parent;
lock (parentLock)
{
parent = _parent;
_parent = null;
}
if (parent != null)
{
parent.Release();
}
}
public IDisposable Run()
{
_buffer = new List <TSource>();
_gate = new object();
var d = new CompositeDisposable(2);
_refCountDisposable = new RefCountDisposable(d);
d.Add(_parent._source.SubscribeSafe(this));
d.Add(_parent._bufferBoundaries.SubscribeSafe(new Omega(this)));
return(_refCountDisposable);
}
public async void AsyncDisposeTest()
{
pipe = new EventPipe();
var endThing = new TaskCompletionSource <bool>();
var disposer = new RefCountDisposable(Disposable.Create(() => endThing.SetResult(true)));
for (var i = 0; i < 100; i++)
{
pipe.ObserveFirst.Subscribe(new TestObserver(i, outp, "first", disposer.GetDisposable()));
pipe.ObserveConcurrent.Subscribe(new TestObserver(i, outp, "reader", disposer.GetDisposable()));
pipe.ObserveSynchronous.Subscribe(new TestObserver(i, outp, "writer", disposer.GetDisposable()));
}
disposer.Dispose();
//var testTask = new List<Task>();
var totalDisposer = new RefCountDisposable(Disposable.Create(() => pipe.Complete()));
var rand = new Random();
Parallel.ForEach(Enumerable.Range(0, 99), async x =>
{
using (totalDisposer.GetDisposable())
{
using (var scp = testProv.CreateScope())
{
var e = new MessageEvent
{
IgnoreThis = false,
Services = scp.ServiceProvider.CreateScope().ServiceProvider,
Scenario = VersaCommsID.FromEnum(EVersaCommIDType.Scenario, 0),
Player = new UnionType <VersaCommsID, IPlayer>(0),
Terminal = new UnionType <VersaCommsID, IVersaWriter>(0),
FullMessage = x.ToString(),
Entity = new UnionType <VersaCommsID, IEntity>(0),
};
await Task.Yield();
await pipe.ProcessEvent(e);
}
}
});
//totalDisposer.Dispose();
//scp.Dispose();
//await Task.WhenAll(testTask);
await Task.Delay(200);
totalDisposer.Dispose();
//await Task.Delay(200);
await endThing.Task;
//pipe.Dispose();
}
public IDisposable Run()
{
_queue = new Queue <ISubject <TSource> >();
_n = 0;
_m = new SingleAssignmentDisposable();
_refCountDisposable = new RefCountDisposable(_m);
var firstWindow = CreateWindow();
base._observer.OnNext(firstWindow);
_m.Disposable = _parent._source.SubscribeSafe(this);
return(_refCountDisposable);
}
private ObservableDictionary()
{
_state = new Dictionary <TKey, TValue>();
_subject = new Subject <DictionaryNotification <TKey, TValue> >();
_sourceSubscription = new SingleAssignmentDisposable();
_refCountDisposable = new RefCountDisposable(_sourceSubscription);
_disposables = new CompositeDisposable(_sourceSubscription, _refCountDisposable, _subject);
_observer = new Observer(this);
var connectableObservable =
_subject.Only(DictionaryNotificationType.Initialised).Select(_ => Unit.Default).Take(1).PublishLast();
_streamInitialisation = connectableObservable;
_disposables.Add(connectableObservable.Connect());
}
public InnerDisposable(RefCountDisposable parent)
{
_parent = parent;
}
