/// <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());
}
