public void Let_ArgumentChecking()
{
var someObservable = Observable.Empty <int>();
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Let(default(IObservable <int>), x => x));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Let <int, int>(someObservable, null));
}
public IObservable <PortableUnit> SaveJsonAsync <T>(string file, T data) where T : class
{
return(ObservableEx.DeferredStart(
() =>
{
try
{
lock (this.syncRoot)
{
using (var storage = IsolatedStorageFile.GetUserStoreForApplication())
{
this.CreateFolderForFile(storage, file);
using (IsolatedStorageFileStream fileStream = storage.CreateFile(file))
{
Json <T> .Instance.SerializeToStream(data, fileStream);
}
}
}
}
catch (IsolatedStorageException inner)
{
throw new IsolatedStorageException("Could not SaveJsonAsync to file '" + file + "'", inner);
}
},
Scheduler.ThreadPool).Retry(2));
}
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)));
}
private IObservable <Tuple <string, string> > OpenFiles(string[] fileNames)
{
return(ObservableEx.Create <Tuple <string, string> >(async(observer, ct) =>
{
try
{
IsProcessing = true;
foreach (var name in fileNames)
{
if (ct.IsCancellationRequested)
{
return;
}
using (var stream = new System.IO.FileStream(name, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
var bytes = await stream.ReadBytesAsync().ConfigureAwait(false);
var text = bytes.GetCode().GetString(bytes);
observer.OnNext(Tuple.Create(System.IO.Path.GetFileName(name), text));
}
}
observer.OnCompleted();
}
catch (Exception e)
{
observer.OnError(e);
}
finally
{ IsProcessing = false; }
}));
}
public void ForkJoin_NaryParamsEmptyBeforeEnd()
{
var scheduler = new TestScheduler();
var msgs1 = new[] {
OnNext(150, 1),
OnNext(215, 2),
OnNext(225, 4),
OnCompleted <int>(230)
};
var msgs2 = new[] {
OnCompleted <int>(235)
};
var msgs3 = new[] {
OnNext(150, 1),
OnNext(230, 3),
OnNext(245, 5),
OnCompleted <int>(270)
};
var o1 = scheduler.CreateHotObservable(msgs1);
var o2 = scheduler.CreateHotObservable(msgs2);
var o3 = scheduler.CreateHotObservable(msgs3);
var res = scheduler.Start(() => ObservableEx.ForkJoin(o1, o2, o3));
res.Messages.AssertEqual(
OnCompleted <int[]>(235)
);
}
public IObservable <T> LoadJsonAsync <T>(string filePath) where T : class
{
return(ObservableEx.DeferredStart(() =>
{
try
{
lock (this.syncRoot)
{
using (var storage = IsolatedStorageFile.GetUserStoreForApplication())
{
if (!storage.FileExists(filePath))
{
return default(T);
}
using (
var input = new IsolatedStorageFileStream(
filePath, FileMode.Open, FileAccess.Read, FileShare.Read, storage))
{
return Json <T> .Instance.DeserializeFromStream(input);
}
}
}
}
catch (IsolatedStorageException inner)
{
throw new IsolatedStorageException("Could not LoadJsonAsync for file '" + filePath + "'", inner);
}
},
Scheduler.ThreadPool).Retry(2));
}
public void Expand_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Expand(null, DummyFunc <int, IObservable <int> > .Instance, DummyScheduler.Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Expand(DummyObservable <int> .Instance, null, DummyScheduler.Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Expand(DummyObservable <int> .Instance, DummyFunc <int, IObservable <int> > .Instance, null));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Expand(null, DummyFunc <int, IObservable <int> > .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.Expand(DummyObservable <int> .Instance, null));
}
private static IObservable <Unit> SleepInternal(float duration, IScheduler scheduler)
{
return(Observable
.Defer(() => Observable.Return(scheduler.Now))
.ContinueWith(start =>
ObservableEx.FromMicroCoroutineWithInitialValue((observer, token) => DelayCoroutine(start, duration, scheduler, observer, token), Unit.Default)
));
}
public void ManySelect_ArgumentChecking()
{
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ManySelect <int, int>(null, DummyFunc <IObservable <int>, int> .Instance, DummyScheduler.Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ManySelect <int, int>(DummyObservable <int> .Instance, null, DummyScheduler.Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ManySelect <int, int>(DummyObservable <int> .Instance, DummyFunc <IObservable <int>, int> .Instance, null));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ManySelect <int, int>(null, DummyFunc <IObservable <int>, int> .Instance));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ManySelect <int, int>(DummyObservable <int> .Instance, null));
}
private static IObservable <float> PlayInternal(ITween tween, float distance, IScheduler scheduler)
{
return(Observable
.Defer(() => Observable.Return(scheduler.Now))
.ContinueWith(start =>
ObservableEx.FromMicroCoroutineWithInitialValue((observer, token) => TweenCoroutine(tween, start, distance, scheduler, observer, token), tween.CalculatePosition(scheduler.Now - start, distance))
));
}
/// <summary>
/// </summary>
/// <param name="player">
/// </param>
/// <returns>
/// </returns>
private IObservable <PortableUnit> StopPlayingAsync(BackgroundAudioPlayer player)
{
Debug.WriteLine("Player: StopPlayingAsync");
return(this.NowPlaying.StopAsync(player)
.Catch <PortableUnit, ServiceException>(ex => ObservableEx.SingleUnit())
.Catch <PortableUnit, WebException>(ex => ObservableEx.SingleUnit())
.ObserveOn(Scheduler.CurrentThread)
.Do(_ => this.StopPlayingMix(player), ex => this.StopPlayingMix(player)));
}
public FireworksParticleController(IReadOnlyList <ParticleSystem> particles, IObservable <SlotProductionStatus> status)
{
//当たった瞬間から1500ms以内のランダムなタイミングで花火を何個か打ち上げる
status.Where(s => s == SlotProductionStatus.Winning)
.SelectMany(_ => ObservableEx.RandomTiming(0, 1500, particles.Count))
.Subscribe(index => particles[index].Play());
Observable.EveryUpdate().Count();
}
/// <summary>
/// </summary>
/// <param name = "url">
/// </param>
/// <param name = "postData">
/// </param>
/// <typeparam name = "TRequest">
/// </typeparam>
/// <typeparam name = "TResponse">
/// </typeparam>
/// <returns>
/// </returns>
public IObservable <TResponse> PostAndGetDeserializedAsync <TRequest, TResponse>(Uri url, TRequest postData)
where TRequest : class where TResponse : class
{
var sequence = from postString in ObservableEx.DeferredStart(() => Json <TRequest> .Instance.SerializeToString(postData))
from completed in this.PostAndGetStringAsync(url, postString)
select Json <TResponse> .Instance.DeserializeFromString(completed);
return(sequence);
}
public void ForkJoin_ArgumentChecking()
{
var someObservable = DummyObservable <int> .Instance;
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin(someObservable, someObservable, (Func <int, int, int>)null));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin(someObservable, (IObservable <int>)null, (_, __) => _ + __));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin((IObservable <int>)null, someObservable, (_, __) => _ + __));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin((IObservable <int>[])null));
ReactiveAssert.Throws <ArgumentNullException>(() => ObservableEx.ForkJoin((IEnumerable <IObservable <int> >)null));
}
public void ForkJoin_None()
{
var scheduler = new TestScheduler();
var res = scheduler.Start(() => ObservableEx.ForkJoin <int>());
res.Messages.AssertEqual(
OnCompleted <int[]>(200)
);
}
public PollingGateway(IPublishEndpoint bus, IMessagePoller poller, TimeSpan period)
{
_bus = bus;
_poller = poller;
_cancellationTokenSource = new CancellationTokenSource();
_observable = ObservableEx
.Create <MessageEnvelope>(Poll, _cancellationTokenSource.Token)
.Concat(Observable.Empty <MessageEnvelope>().Delay(period))
.Repeat();
}
public UserInputProvider()
{
//KeyConfigに使用されているキーをすべて監視する
IObservable <KeyCode> observableKeyCode = Observable.Empty <KeyCode>();
foreach (var code in KeyConfigProvider.Now.KeyCommandTable.Keys)
{
observableKeyCode = observableKeyCode.Merge(ObservableEx.FromKeyCode(code));
}
this.ObservableKeyCode = observableKeyCode.Share();
}
private static void MergingObservableOfObservables()
{
Demo.DisplayHeader("The Merge operator - allows also to merge observables emitted from another observable");
IObservable <string> texts = ObservableEx.FromValues("Hello", "World");
texts
.Select(txt => Observable.Return(txt + "-Result"))
.Merge()
.SubscribeConsole("Merging from observable");
}
private static void DelayingEachNotificationIndependently()
{
Demo.DisplayHeader("Throttle operator - each notification can be shifted independently by providing observable that signals the delay is over");
var observable = ObservableEx.FromValues(4, 1, 2, 3);
observable
.Timestamp()
.Delay(x => Observable.Timer(TimeSpan.FromSeconds(x.Value)))
.Timestamp()
.RunExample("Independent Delay");
}
public void GivenAResetTimerObservableIsCreatedThatUsesAsTheResetSource(string streamKey)
{
var scheduler = _scenario.GetEx <TestScheduler>();
var resetSource = _scenario.GetEx <IObservable <int> >(streamKey);
var dueTime = _scenario.GetEx <Duration>("dueTime");
var period = _scenario.GetEx <Duration>("period");
IObservable <int> obs = ObservableEx
.ResetTimer(dueTime, period, resetSource, scheduler).Select(x => (int)x);
_scenario.Set(obs);
}
private static void ZippingTwoObservables()
{
Demo.DisplayHeader("The Zip operator - combines values with the same index from two observables");
//temperatures from two sensors (in celsius)
IObservable <double> temp1 = ObservableEx.FromValues(20.0, 21, 22);
IObservable <double> temp2 = ObservableEx.FromValues(22.0, 21, 24);
temp1
.Zip(temp2, (t1, t2) => (t1 + t2) / 2)
.SubscribeConsole("Avg Temp.");
}
public static IObservable <PortableUnit> StopAsync(this PlayingMixContract nowPlaying, TimeSpan timePlayed)
{
ResetNowPlayingTile();
Storage.Delete(NowPlayingFilePath);
if (nowPlaying == null)
{
return(ObservableEx.SingleUnit());
}
return(AddToMixTrackHistoryAsync(nowPlaying, timePlayed));
}
private void Initialize()
{
HaloSize = 3;
NearThreshold = 1589;
FarThreshold = 1903;
objectFilter = ObjectFilter.CreateObjectFilterWithGPUSupport();
// -- Initialize Relay commands --
InitializeRelayCommands();
// --
// -- Create observables to activate / deactivate recording and to start and stop processing --
var observableIsRecording = ObservableEx.ObservableProperty(() => IsRecording);
observableIsRecording
.Throttle(TimeSpan.FromMilliseconds(150))
.Subscribe(e =>
{
if (e)
{
ActivateRecording();
}
else
{
DeactivateRecording();
}
});
var observableIsAvailable = Observable.FromEventPattern <bool>(KinectManager.Instance, "KinectAvailabilityChanged")
.Select(e => e.EventArgs);
StartProcessingSubscription = observableIsAvailable
.CombineLatest(observableIsRunning, (available, running) => Tuple.Create(available, running))
.Where(tuple => tuple.Item1 && tuple.Item2)
.Subscribe(_ => StartProcessing());
StopProcessingSubscription = observableIsAvailable
.CombineLatest(observableIsRunning, (available, running) => Tuple.Create(available, running))
.Where(tuple => !tuple.Item1 || !tuple.Item2)
.Subscribe(_ => StopProcessing());
InitializeReactiveCommands();
InitializeReactiveProperties();
// --
fpsTimer = Stopwatch.StartNew();
colorAndDepthFPSTimer = Stopwatch.StartNew();
}
public void Iterate_Void_Func_Throw()
{
var scheduler = new TestScheduler();
var obs = scheduler.Start(() => ObservableEx.Create(() => { throw new InvalidOperationException(); }));
Assert.Equal(1, obs.Messages.Count);
var notification = obs.Messages[0].Value;
Assert.Equal(NotificationKind.OnError, notification.Kind);
Assert.IsType <InvalidOperationException>(notification.Exception);
}
public void Iterate_Complete_Dispose()
{
var scheduler = new TestScheduler();
var xs = scheduler.CreateColdObservable(
OnNext(10, 1),
OnNext(20, 2),
OnNext(30, 3),
OnNext(40, 4),
OnCompleted <int>(50)
);
var ys = scheduler.CreateColdObservable(
OnNext(10, 1),
OnNext(20, 2),
OnCompleted <int>(30)
);
var zs = scheduler.CreateColdObservable(
OnNext(100, 1),
OnNext(200, 2),
OnNext(300, 3),
OnNext(400, 4),
OnNext(500, 5),
OnNext(600, 6),
OnNext(700, 7),
OnNext(800, 8),
OnNext(900, 9),
OnNext(1000, 10)
);
var res = scheduler.Start(() => ObservableEx.Create <int>(observer => ToIterate_Complete_Dispose(xs, ys, zs, observer)));
res.Messages.AssertEqual(
OnNext(200, 1),
OnNext(250, 2),
OnNext(280, 3)
);
xs.Subscriptions.AssertEqual(
Subscribe(200, 250)
);
ys.Subscriptions.AssertEqual(
Subscribe(250, 280)
);
zs.Subscriptions.AssertEqual(
Subscribe(280, 1000)
);
}
public void GivenARandomTimerObservableThatPublishesValuesIsCreated(int count)
{
var scheduler = _scenario.GetEx <TestScheduler>();
var dueTime = _scenario.GetEx <Duration>("dueTime");
var minPeriod = _scenario.GetEx <Duration>("minPeriod");
var maxPeriod = _scenario.GetEx <Duration>("maxPeriod");
IObservable <int> obs = ObservableEx
.RandomTimer(dueTime, minPeriod, maxPeriod, scheduler)
.Take(count)
.Select(x => (int)x);
_scenario.Set(obs);
}
/// <summary>
/// Applies the setter to a control.
/// </summary>
/// <param name="style">The style that is being applied.</param>
/// <param name="control">The control.</param>
/// <param name="activator">An optional activator.</param>
public IDisposable Apply(IStyle style, IStyleable control, IObservable <bool> activator)
{
Contract.Requires <ArgumentNullException>(control != null);
var description = style?.ToString();
if (Property == null)
{
throw new InvalidOperationException("Setter.Property must be set.");
}
var value = Value;
var binding = value as IBinding;
if (binding == null)
{
var template = value as ITemplate;
bool isPropertyOfTypeITemplate = typeof(ITemplate).GetTypeInfo()
.IsAssignableFrom(Property.PropertyType.GetTypeInfo());
if (template != null && !isPropertyOfTypeITemplate)
{
var materialized = template.Build();
NameScope.SetNameScope((Visual)materialized, new NameScope());
value = materialized;
}
if (activator == null)
{
return(control.Bind(Property, ObservableEx.SingleValue(value), BindingPriority.Style));
}
else
{
var activated = new ActivatedValue(activator, value, description);
return(control.Bind(Property, activated, BindingPriority.StyleTrigger));
}
}
else
{
var source = binding.Initiate(control, Property);
if (source != null)
{
var cloned = Clone(source, style, activator);
return(BindingOperations.Apply(control, Property, cloned, null));
}
}
return(Disposable.Empty);
}
public void Iterate_Iterator_Throw()
{
var scheduler = new TestScheduler();
var xs = scheduler.CreateColdObservable(
OnNext(10, 1),
OnNext(20, 2),
OnNext(30, 3),
OnNext(40, 4),
OnCompleted <int>(50)
);
var ys = scheduler.CreateColdObservable(
OnNext(10, 1),
OnNext(20, 2),
OnCompleted <int>(30)
);
var zs = scheduler.CreateColdObservable(
OnNext(10, 1),
OnNext(20, 2),
OnNext(30, 3),
OnNext(40, 4),
OnNext(50, 5),
OnCompleted <int>(60)
);
var ex = new Exception();
var res = scheduler.Start(() => ObservableEx.Create <int>(observer => ToIterate_Throw(xs, ys, zs, observer, ex)));
res.Messages.AssertEqual(
OnNext(200, 1),
OnNext(250, 2),
OnNext(280, 3),
OnError <int>(280, ex)
);
xs.Subscriptions.AssertEqual(
Subscribe(200, 250)
);
ys.Subscriptions.AssertEqual(
Subscribe(250, 280)
);
zs.Subscriptions.AssertEqual(
);
}
public static void SubscribeOnAndObserveOn()
{
Demo.DisplayHeader("using SubscribeOn and ObserveOn together and their effect");
ObservableEx.FromValues(0, 1, 2, 3, 4, 5)
.Take(3)
.LogWithThread("A")
.Where(x => x % 2 == 0)
.LogWithThread("B")
.SubscribeOn(NewThreadScheduler.Default)
.LogWithThread("C")
.Select(x => x * x)
.LogWithThread("D")
.ObserveOn(TaskPoolScheduler.Default)
.LogWithThread("E")
.RunExample("squares by time");
}
private static void AddToCompositeDisposable()
{
Demo.DisplayHeader("AddToCompositeDisposable extensions method - useful for keeping your observable pipeline fluent");
var compositeDisposable = new CompositeDisposable();
IObservable <string> observable = ObservableEx.FromValues("Rx", "For", "The", "Win");
observable.Where(x => x.Length % 2 == 0)
.Select(x => x.ToUpper())
.Subscribe(x => Console.WriteLine(x))
.AddToCompositeDisposable(compositeDisposable);
observable.Where(x => x.Length % 2 == 1)
.Select(x => x.ToLower())
.Subscribe(x => Console.WriteLine(x))
.AddToCompositeDisposable(compositeDisposable);
}
