/// <summary> /// </summary> /// <param name = "items"> /// </param> /// <param name = "selector"> /// </param> /// <typeparam name = "T"> /// </typeparam> /// <typeparam name = "TResult"> /// </typeparam> /// <returns> /// </returns> public static IObservable <PortableUnit> Try <T>(this IObservable <T> items, Action <T> selector) { return(Observable.CreateWithDisposable <PortableUnit>( d => items.Subscribe( item => { try { selector(item); d.OnNext(new PortableUnit()); } catch (WebException webException) { Exception newError = ConvertWebException(webException); d.OnError(newError); } catch (ZlibException zlibException) { var zlibError = new ServiceException("The response from the server was interrupted, please try again later", zlibException, 444); d.OnError(zlibError); } catch (Exception ex) { d.OnError(ex); } }, d.OnError, d.OnCompleted))); }
/* NOTE: This is left here for reference - the real one is expanded out * to 10 parameters in VariadicTemplates.tt */ #if FALSE public static IObservable <TRet> WhenAny <TSender, T1, T2, TRet>(this TSender This, Expression <Func <TSender, T1> > property1, Expression <Func <TSender, T2> > property2, Func <IObservedChange <TSender, T1>, IObservedChange <TSender, T2>, TRet> selector) where TSender : IReactiveNotifyPropertyChanged { var slot1 = new ObservedChange <TSender, T1>() { Sender = This, PropertyName = String.Join(".", RxApp.expressionToPropertyNames(property1)), }; T1 slot1Value = default(T1); slot1.TryGetValue(out slot1Value); slot1.Value = slot1Value; var slot2 = new ObservedChange <TSender, T2>() { Sender = This, PropertyName = String.Join(".", RxApp.expressionToPropertyNames(property2)), }; T2 slot2Value = default(T2); slot2.TryGetValue(out slot2Value); slot2.Value = slot2Value; IObservedChange <TSender, T1> islot1 = slot1; IObservedChange <TSender, T2> islot2 = slot2; return(Observable.CreateWithDisposable <TRet>(subject => { subject.OnNext(selector(slot1, slot2)); return Observable.Merge( This.ObservableForProperty(property1).Do(x => { lock (slot1) { islot1 = x.fillInValue(); } }).Select(x => selector(islot1, islot2)), This.ObservableForProperty(property2).Do(x => { lock (slot2) { islot2 = x.fillInValue(); } }).Select(x => selector(islot1, islot2)) ).Subscribe(subject); })); }
public void finally_action_is_executed_if_disposition_source_subscription_throws_exception() { StatsObserver <int> stats = new StatsObserver <int>(); bool finallyCalled = true; try { Observable.CreateWithDisposable <int>(obs => { return(Disposable.Create(() => { throw new ApplicationException(); })); }) .Finally(() => { finallyCalled = true; }) .Subscribe(stats) .Dispose(); } finally { Assert.IsTrue(finallyCalled); } }
public IObservable <PortableUnit> SaveAsync(T item) { if (item == null) { return(ObservableEx.SingleUnit()); } return(Observable.CreateWithDisposable <PortableUnit>( observer => Scheduler.ThreadPool.Schedule(() => { try { var key = this.getKeyFromItem(item); var filePath = this.GetFilePath(key); using (var storage = IsolatedStorageFile.GetUserStoreForApplication()) { this.EnsureDirectoryExistsAsync(storage); using (var stream = new IsolatedStorageFileStream(filePath, FileMode.Create, storage)) { serializer.WriteObject(stream, item); stream.Flush(); stream.Close(); } } observer.OnNext(ObservableEx.Unit); observer.OnCompleted(); } catch (IOException error) { observer.OnError(error); } })).Wait(this.syncLock, TimeSpan.FromSeconds(5))); }
public static IObservable <T> ContinueWhile <T>(this IObservable <T> sequence, Predicate <T> predicate, Action onExit) { return(Observable.CreateWithDisposable <T>( observer => { bool isRunning = true; return sequence.Subscribe(item => { if (!isRunning) { return; } isRunning = predicate(item); observer.OnNext(item); if (!isRunning) { observer.OnCompleted(); if (onExit != null) { onExit(); } } }, observer.OnError, observer.OnCompleted); })); }
public void supports_null_cancelable_value() { StatsObserver <int> stats = new StatsObserver <int>(); Observable.CreateWithDisposable <int>(x => null) .Subscribe(stats) .Dispose(); }
public static IObservable <TSource> Create <TSource>(Func <IObserver <TSource>, IDisposable> subscribe) { #if WINDOWS_PHONE return(Observable.CreateWithDisposable(subscribe)); #else return(Observable.Create(subscribe)); #endif }
public void create_calls_delegate() { bool createCalled = false; Observable.CreateWithDisposable <int>(x => { createCalled = true; return(Disposable.Empty); }) .Subscribe(new Subject <int>()); Assert.IsTrue(createCalled); }
public void calls_dispose_function_when_unsubscribed_from() { bool disposeCalled = false; StatsObserver <int> stats = new StatsObserver <int>(); Observable.CreateWithDisposable <int>(x => Disposable.Create(() => { disposeCalled = true; })) .Subscribe(stats) .Dispose(); Assert.IsTrue(disposeCalled); }
public static IObservable <Unit> FinishedToNext <T>(this IObservable <T> observable) { return(Observable.CreateWithDisposable <Unit>( o => { return observable.Subscribe <T>( result => { }, error => o.OnError(error), () => o.OnNext(new Unit())); } ).Take(1)); }
public static IObservable <TResult> FinallySelect <T, TResult>(this IObservable <T> sequence, Func <TResult> finalValue) { return(Observable.CreateWithDisposable <TResult>( observer => sequence.Subscribe( _ => { }, observer.OnError, () => { observer.OnNext(finalValue()); observer.OnCompleted(); }))); }
public static IObservable <T> MergeWithCompleteOnEither <T>(this IObservable <T> source, IObservable <T> right) { return(Observable.CreateWithDisposable <T>(obs => { var compositeDisposable = new CompositeDisposable(); var subject = new Subject <T>(); compositeDisposable.Add(subject.Subscribe(obs)); compositeDisposable.Add(source.Subscribe(subject)); compositeDisposable.Add(right.Subscribe(subject)); return compositeDisposable; })); }
public void calls_dispose_function_when_sequence_completes() { bool disposeCalled = false; StatsObserver <int> stats = new StatsObserver <int>(); Observable.CreateWithDisposable <int>(x => { x.OnCompleted(); return(Disposable.Create(() => { disposeCalled = true; })); }) .Subscribe(stats); Assert.IsTrue(disposeCalled); }
/// <summary> /// Takes a "chunked" sequence of characters and converts it to a "chunked" sequence of bytes using the specified encoding, optionally including the encoding preamble. /// </summary> /// <param name="source">The "chunked" sequence of characters.</param> /// <param name="encoding">The encoding used to translate the sequence of characters to a sequence of bytes.</param> /// <param name="includePreamble">If set to <c>true</c>, the preamble of the encoding is produced before the encoded characters.</param> /// <returns>The "chunked" sequence of bytes.</returns> public static IObservable <byte[]> Encode(this IObservable <char[]> source, Encoding encoding, bool includePreamble = false) { IObservable <byte[]> ret = Observable.CreateWithDisposable <byte[]>(observer => { var encoder = encoding.GetEncoder(); return(source.Subscribe( charData => { try { var byteData = new byte[encoder.GetByteCount(charData, 0, charData.Length, false)]; encoder.GetBytes(charData, 0, charData.Length, byteData, 0, false); if (byteData.Length != 0) { observer.OnNext(byteData); } } catch (EncoderFallbackException ex) { observer.OnError(ex); } }, observer.OnError, () => { try { var byteData = new byte[encoder.GetByteCount(new char[0], 0, 0, true)]; encoder.GetBytes(new char[0], 0, 0, byteData, 0, true); if (byteData.Length != 0) { observer.OnNext(byteData); } observer.OnCompleted(); } catch (EncoderFallbackException ex) { observer.OnError(ex); } })); }); return(includePreamble ? ret.StartWith(encoding.GetPreamble()) : ret); }
public static IObservable <T> DeferredStart <T>(Func <T> func, IScheduler scheduler) { return(Observable.CreateWithDisposable <T>( observer => scheduler.Schedule( () => { try { observer.OnNext(func()); observer.OnCompleted(); } catch (Exception ex) { observer.OnError(ex); } }))); }
public static void Run <TResult>(Func <TResult> todo, Action <TResult> continuation, Action <Exception> onException) { bool errored = false; IDisposable subscription = null; var toCall = Observable.ToAsync <TResult>(todo); var observable = Observable.CreateWithDisposable <TResult>(o => toCall().Subscribe(o)).ObserveOn(Scheduler.Dispatcher).Catch( (Exception err) => { errored = true; if (onException != null) { onException(err); } return(Observable.Never <TResult>()); }).Finally( () => { if (subscription != null) { subscription.Dispose(); } }); subscription = observable.Subscribe((TResult result) => { if (!errored && continuation != null) { try { continuation(result); } catch (Exception e) { if (onException != null) { onException(e); } } } }); }
/// <summary> /// Takes a "chunked" sequence of bytes and converts it to a "chunked" sequence of characters using the specified encoding. /// </summary> /// <param name="source">The "chunked" sequence of bytes.</param> /// <param name="encoding">The encoding used to translate the sequence of bytes to a sequence of characters.</param> /// <returns>The "chunked" sequence of characters.</returns> public static IObservable <char[]> Decode(this IObservable <byte[]> source, Encoding encoding) { // TODO: (bool allowPreamble), then IObservable<Tuple<Encoding, IObservable<char[]>>> Decode() - for autodetection. return(Observable.CreateWithDisposable <char[]>(observer => { var decoder = encoding.GetDecoder(); return source.Subscribe( data => { try { var ret = new char[decoder.GetCharCount(data, 0, data.Length, false)]; decoder.GetChars(data, 0, data.Length, ret, 0, false); if (ret.Length != 0) { observer.OnNext(ret); } } catch (EncoderFallbackException ex) { observer.OnError(ex); } }, observer.OnError, () => { try { var ret = new char[decoder.GetCharCount(new byte[0], 0, 0, true)]; decoder.GetChars(new byte[0], 0, 0, ret, 0, true); if (ret.Length != 0) { observer.OnNext(ret); } observer.OnCompleted(); } catch (EncoderFallbackException ex) { observer.OnError(ex); } }); })); }
public static IObservable <PortableUnit> DeferredStart(Action action, IScheduler scheduler) { return(Observable.CreateWithDisposable <PortableUnit>( observer => scheduler.Schedule( () => { try { action(); observer.OnNext(new PortableUnit()); observer.OnCompleted(); } catch (Exception ex) { observer.OnError(ex); } }))); }
public void Async() { var observable = Observable .CreateWithDisposable <int>(o => { var cancel = new CancellationDisposable(); Scheduler.NewThread.Schedule(AsyncAction(cancel, o)); return(cancel); }); var subscription = observable.Subscribe(Console.WriteLine); Thread.Sleep(1000); // cause cancel subscription.Dispose(); Thread.Sleep(100); // give background thread time to write the cancel acknowledge message Thread.Sleep(1000); }
public IObservable <INode> Fetch(IObservable <Guid> ids) { return(Observable .CreateWithDisposable <INode>(observer => ids.Subscribe(x => { INode node; if (NodeCache.TryGetValue(x, out node)) { observer.OnNext(node); } else { node = _lazyStorage.Value.Fetch(x); NodeCache[x] = node; observer.OnNext(node); } }, observer.OnError, observer.OnCompleted))); }
public static IObservable <T> FirstDo <T>(this IObservable <T> sequence, Action <T> firstAction) { bool hasBeenRun = false; return(Observable.CreateWithDisposable <T>( observer => sequence.Subscribe( _ => { if (!hasBeenRun) { hasBeenRun = true; firstAction(_); } observer.OnNext(_); }, observer.OnError, observer.OnCompleted))); }
public void finally_action_is_executed_after_source_subscription_is_disposed() { StatsObserver <int> stats = new StatsObserver <int>(); bool sourceSubscriptionDisposed = true; Observable.CreateWithDisposable <int>(obs => { return(Disposable.Create(() => { sourceSubscriptionDisposed = true; })); }) .Finally(() => { Assert.IsTrue(sourceSubscriptionDisposed); }) .Subscribe(stats) .Dispose(); }
public static IObservable <T> AsObservable <T>(this IServiceBus bus, Predicate <T> condition) where T : class { return(Observable.CreateWithDisposable <T>( observer => new ServiceBusSubscription <T>(bus, observer, condition))); }
public static IObservable <T> Defer <T>(Func <IObservable <T> > func) { return(Observable.CreateWithDisposable <T>(observer => func().Subscribe(observer))); }
public static IObservable <TSource[]> BufferWithTimeout <TSource>( this IObservable <TSource> source, TimeSpan timeout, IScheduler scheduler, bool flushFirst = false) { return(Observable.CreateWithDisposable <TSource[]>( observer => { object lockObject = new object(); List <TSource> buffer = new List <TSource>(); bool fistToBuffer = true; MutableDisposable timeoutDisposable = new MutableDisposable(); Action flushBuffer = () => { TSource[] values; lock (lockObject) { values = buffer.ToArray(); buffer.Clear(); fistToBuffer = true; } observer.OnNext(values); }; var sourceSubscription = source.Subscribe( value => { if (fistToBuffer && flushFirst) { bool isFirst = false; lock (lockObject) { if (fistToBuffer) { fistToBuffer = false; isFirst = true; } } if (isFirst) { observer.OnNext(new[] { value }); return; } } lock (lockObject) { buffer.Add(value); } timeoutDisposable.Disposable = scheduler.Schedule(flushBuffer, timeout); }, observer.OnError, () => { flushBuffer(); observer.OnCompleted(); }); return new CompositeDisposable(sourceSubscription, timeoutDisposable); })); }
public static IObservableX <T> CreateWithDisposable <T>(Func <IObserverX <T>, IDisposable> subscribe) { return(Observable.CreateWithDisposable <T>(observer => subscribe(observer.ToObserverX())).ToObservableX()); }