void setupRx()
{
var countAsBehavior = Observable.Concat(
Observable.Defer(() => Observable.Return(_NavigationStack.Count)),
NavigationStack.CountChanged);
NavigateBack = ReactiveCommand.CreateAsyncObservable(
countAsBehavior.Select(x => x > 1),
_ => Observable.Return(Unit.Default));
NavigateBack.Subscribe(_ =>
NavigationStack.RemoveAt(NavigationStack.Count - 1));
Navigate = new ReactiveCommand <object>(Observable.Return(true), x => Observable.Return(x));
Navigate.Subscribe(x => {
var vm = x as IRoutableViewModel;
if (vm == null)
{
throw new Exception("Navigate must be called on an IRoutableViewModel");
}
NavigationStack.Add(vm);
});
NavigateAndReset = new ReactiveCommand <object>(Observable.Return(true), x => Observable.Return(x));
NavigateAndReset
.SelectMany(x => {
NavigationStack.Clear();
return(Navigate.ExecuteAsync(x));
}).Subscribe();
CurrentViewModel = Observable.Concat(
Observable.Defer(() => Observable.Return(NavigationStack.LastOrDefault())),
NavigationStack.Changed.Select(_ => NavigationStack.LastOrDefault()));
}
/// <summary>
/// 複数のObservableを直列で流す
/// onCompleted発行時に次のObservableを購読
/// </summary>
private void ExcuteConcat()
{
Subject <string> subjectFirst = new Subject <string>();
Subject <string> subjectSecond = new Subject <string>();
Observable
.Concat(subjectFirst, subjectSecond)
.Subscribe(x => {
Debug.Log("Concat onNext : " + x);
}, () => {
Debug.Log("Concat onCompleted");
});
// 流れる
subjectFirst.OnNext("First 1回目");
// 流れない
subjectSecond.OnNext("Second 1回目");
// onCompletedは呼ばれないが、subjectSecondが購読される
subjectFirst.OnCompleted();
// 流れない
subjectFirst.OnNext("First 2回目");
// 流れる
subjectSecond.OnNext("Second 2回目");
// onCompleted呼ばれる
subjectSecond.OnCompleted();
}
async Task <List <string> > executeInstall(string currentAssemblyDir, IPackage bundledPackageMetadata, IObserver <int> progress = null)
{
var fxVersion = determineFxVersionFromPackage(bundledPackageMetadata);
var eigenUpdater = new UpdateManager(currentAssemblyDir, bundledPackageMetadata.Id, fxVersion, TargetRootDirectory);
var eigenCheckProgress = new Subject <int>();
var eigenCopyFileProgress = new Subject <int>();
var eigenApplyProgress = new Subject <int>();
var realCheckProgress = new Subject <int>();
var realCopyFileProgress = new Subject <int>();
var realApplyProgress = new Subject <int>();
// The real update takes longer than the eigenupdate because we're
// downloading from the Internet instead of doing everything
// locally, so give it more weight
Observable.Concat(
Observable.Concat(eigenCheckProgress, eigenCopyFileProgress, eigenCopyFileProgress).Select(x => (x / 3.0) * 0.33),
Observable.Concat(realCheckProgress, realCopyFileProgress, realApplyProgress).Select(x => (x / 3.0) * 0.67))
.Select(x => (int)x)
.Subscribe(progress);
List <string> ret = null;
var updateInfo = await eigenUpdater.CheckForUpdate(progress : eigenCheckProgress);
await eigenUpdater.DownloadReleases(updateInfo.ReleasesToApply, eigenCopyFileProgress);
ret = await eigenUpdater.ApplyReleases(updateInfo, eigenApplyProgress);
eigenUpdater.Dispose();
var updateUrl = bundledPackageMetadata.ProjectUrl != null?bundledPackageMetadata.ProjectUrl.ToString() : null;
updateUrl = null; //XXX REMOVE ME
if (updateUrl == null)
{
realCheckProgress.OnNext(100); realCheckProgress.OnCompleted();
realCopyFileProgress.OnNext(100); realCopyFileProgress.OnCompleted();
realApplyProgress.OnNext(100); realApplyProgress.OnCompleted();
return(ret);
}
var realUpdater = new UpdateManager(updateUrl, bundledPackageMetadata.Id, fxVersion, TargetRootDirectory);
try {
updateInfo = await realUpdater.CheckForUpdate(progress : realCheckProgress);
await realUpdater.DownloadReleases(updateInfo.ReleasesToApply, realCopyFileProgress);
await realUpdater.ApplyReleases(updateInfo, realApplyProgress);
} catch (Exception ex) {
log.ErrorException("Failed to update to latest remote version", ex);
return(new List <string>());
}
realUpdater.Dispose();
return(ret);
}
public void SetUp()
{
// デッキシャッフル
foreach (var deck in decks)
{
deck.SetUp();
}
var drawShuffle = decks.Select(deck => deck.DrawShulle()).Merge();
// 手札配置
foreach (var hand in hands)
{
hand.Deal(decks[0]);
}
var drawHandDeal = hands.Select(hand => hand.DrawDeal()).Merge();
// プレイエリア配置
foreach (var playArea in playAreas)
{
playArea.Deal(decks[0].TopDraw());
}
var drawPlayAreaDeal = playAreas.Select(playArea => playArea.DrawDeal()).Merge();
// 描画をdrawableに伝達
drawable.SyncCommand.Execute(Observable.Concat(drawShuffle));
}
void Start()
{
var list1 = Observable.Create <string>(observer => {
Thread.Sleep(1);
observer.OnNext("A1");
Thread.Sleep(8);
observer.OnNext("A2");
Thread.Sleep(2);
observer.OnNext("A3");
observer.OnCompleted();
return(Disposable.Empty);
}).SubscribeOn(Scheduler.ThreadPool);
var list2 = Observable.Create <string>(observer => {
Thread.Sleep(3);
observer.OnNext("B1");
Thread.Sleep(1);
observer.OnNext("B2");
Thread.Sleep(12);
observer.OnNext("B3");
observer.OnCompleted();
return(Disposable.Empty);
}).SubscribeOn(Scheduler.ThreadPool);
Observable
.Concat(list1, list2)
.Subscribe(x => Debug.Log(x));
}
public Cache(IObservable <T> newElements, IEnumerable <T> seedElements, Func <T, TKey> keySelector)
{
var agg = new State {
Cache = seedElements.ToImmutableDictionary(keySelector), Value = default(T)
};
_source = newElements
// Use the Scan operator to update the dictionary of values based on key and use the anonymous tuple to pass this and the current item to the next operator
.Scan(agg, (tuple, item) => new State {
Cache = tuple.Cache.SetItem(keySelector(item), item), Value = item
})
// Ensure we always have at least one item
.StartWith(agg)
// Share this single subscription to the above with all subscribers
.Publish();
_observable = _source.Publish(source =>
// ... concatting ...
Observable.Concat(
// ... getting a single collection of values from the cache and flattening it to a series of values ...
source.Select(tuple => tuple.Cache.Values).Take(1).SelectMany(values => values),
// ... and the returning the values as they're emitted from the source
source.Select(tuple => tuple.Value)
)
);
}
public IObservable <Unit> ExecuteAsync(ExecutionContext context)
{
context.AssertNotNull(nameof(context));
var childExecutions = this
.children
.Select(
child => Observable
.Return(Unit.Default)
.Select(
_ =>
{
context.CancellationToken.ThrowIfCancellationRequested();
var execute = true;
if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= child.Duration)
{
context.AddProgress(child.Duration);
execute = false;
}
return(new
{
Child = child,
Execute = execute
});
})
.Where(x => x.Execute)
.SelectMany(x => x.Child.ExecuteAsync(context)))
.DefaultIfEmpty(Observable.Return(Unit.Default));
return(Observable
.Concat(childExecutions)
.RunAsync(context.CancellationToken));
}
public void LoopTest2()
{
var n = 0;
var loop = default(IObservable <int>);
loop = Observable.While(
() => n++ < 10,
Observable.Concat(
Observable.Return(42),
Observable.Defer(() => loop)
)
);
var res = new List <int>();
var std = new List <int>();
loop.ForEach(x =>
{
res.Add(x);
std.Add(new System.Diagnostics.StackTrace().FrameCount);
});
Assert.True(res.SequenceEqual(Enumerable.Repeat(42, 10)));
Assert.True(std.Distinct().Count() == 1);
}
public IObservable <Unit> Execute(ExecutionContext context)
{
Ensure.ArgumentNotNull(context, nameof(context));
return(Observable
.Concat(
this
.GetEventsWithActions(context)
.SelectMany(eventWithActions => eventWithActions.Actions.Select(action => new { Action = action, Event = eventWithActions.Event }))
.Select(
actionAndEvent =>
{
var action = actionAndEvent.Action;
var @event = actionAndEvent.Event;
if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= action.Duration)
{
this.logger.Debug("Skipping action {0} for event {1} because its duration ({2}) is less than the remaining skip ahead ({3}).", action, @event, action.Duration, context.SkipAhead);
context.AddProgress(action.Duration);
return Observable.Return(Unit.Default);
}
this.logger.Debug("Executing action {0} for event {1}.", action, @event);
return action.Execute(context);
})));
}
void setupRx()
{
NavigateBack = new ReactiveCommand(
NavigationStack.CountChanged.StartWith(_NavigationStack.Count).Select(x => x > 1));
NavigateBack.Subscribe(_ =>
NavigationStack.RemoveAt(NavigationStack.Count - 1));
Navigate = new NavigationReactiveCommand();
Navigate.Subscribe(x => {
var vm = x as IRoutableViewModel;
if (vm == null)
{
throw new Exception("Navigate must be called on an IRoutableViewModel");
}
NavigationStack.Add(vm);
});
NavigateAndReset = new NavigationReactiveCommand();
NavigateAndReset.Subscribe(x => {
NavigationStack.Clear();
Navigate.Execute(x);
});
CurrentViewModel = Observable.Concat(
Observable.Defer(() => Observable.Return(NavigationStack.LastOrDefault())),
NavigationStack.Changed.Select(_ => NavigationStack.LastOrDefault()));
}
public void ConcatCrossMap()
{
var M = 1000 * 1000 / N;
Observable.Concat(Observable.Range(1, N).Select(v => Observable.Range(v, M)))
.Subscribe(v => Volatile.Write(ref _store, v));
}
private void ProcessBackfillPump()
{
var o = Observable.Concat(
Observable.StartAsync(async() =>
{
HomeTimeLineLargestSeenId = await GetHomeTimeLine_Backfill();
}),
Observable.StartAsync(async() =>
{
DirectMessagesReceivedLargestSeenId = await GetDirectMessages_Received_Backfill();
}),
Observable.StartAsync(async() =>
{
DirectMessagesSentLargestSeenId = await GetDirectMessages_Sent_Backfill();
}),
Observable.StartAsync(async() =>
{
RetweetsOfMeLargestSeenId = await GetRTOfMe_Backfill();
}),
Observable.StartAsync(async() =>
{
MentionsOfMeLargestSeenId = await GetMentions_Backfill();
}),
Observable.StartAsync(async() =>
{
MyTweetsLargestSeenId = await GetMyTweets_Backfill();
}).Finally(() =>
{
_backfillsCompleted.OnNext(StreamSignal.Completed);
}));
}
public async Task ReturnsTheSelectedTagIds()
{
await ViewModel.Initialize();
var tagIds = Enumerable.Range(0, 20).Select(num => (long)num);
var selectedTagIds = tagIds.Where(id => id % 2 == 0)
.ToArray();
var selectedTags = selectedTagIds
.Select(createDatabaseTagSubstitute)
.Select(databaseTag => new TagSuggestion(databaseTag))
.Select(tagSuggestion
=> new SelectableTagViewModel(tagSuggestion.TagId, tagSuggestion.Name, false,
tagSuggestion.WorkspaceId));
var auxObservable = TestScheduler.CreateObserver <Unit>();
var selectExecutions = Observable.Concat(selectedTags
.Select(tag => Observable.Defer(() => ViewModel.SelectTag.Execute(tag))));
var saveExecution = Observable.Defer(() => ViewModel.Save.Execute());
Observable
.Concat(selectExecutions, saveExecution)
.Subscribe(auxObservable);
TestScheduler.Start();
await NavigationService
.Received()
.Close(
Arg.Is(ViewModel),
Arg.Is <long[]>(ids => EnsureExpectedTagsAreReturned(ids, selectedTagIds))
);
}
public IObservable <RawClientRequest> StartNodes()
{
// Iterate through the config and launch each node.
foreach (var config in _configManager.NetworkConfigs)
{
switch (config.Type)
{
case NetworkConfigType.Lidgren:
_serverNodes.Add(SetupLidgrenServerNode(config));
break;
// Currently replicates Lidgren. As we add auth and other logic,
// This can be told to disable things like secure sessions, etc.
case NetworkConfigType.Test:
_serverNodes.Add(SetupLidgrenServerNode(config));
break;
}
}
_serverNodes.ForEach(p => p.Start());
// Combine the streams of messages into an agnostic, concatenated stream.
ConcatStream = Observable.Concat(_serverNodes.Select(p => p.MessageStream));
return(ConcatStream);
}
public void ThrottleFirstTest()
{
var xs = Observable.Concat(
Observable.Return(1),
Observable.Return(2).Delay(TimeSpan.FromSeconds(1)),
Observable.Return(3).Delay(TimeSpan.FromSeconds(1)),
Observable.Return(4).Delay(TimeSpan.FromSeconds(0.4)),
Observable.Return(5).Delay(TimeSpan.FromSeconds(0.2)), // over 2500
Observable.Return(6).Delay(TimeSpan.FromSeconds(1)),
Observable.Return(7).Delay(TimeSpan.FromSeconds(1)),
Observable.Return(8).Delay(TimeSpan.FromSeconds(1)), // over 2500
Observable.Return(9) // withCompleted
)
.Timestamp()
.ThrottleFirst(TimeSpan.FromMilliseconds(2500))
.Materialize()
.ToArray()
.Wait();
xs.Length.Is(4);
xs[0].Value.Value.Is(1);
xs[1].Value.Value.Is(5);
xs[2].Value.Value.Is(8);
xs[3].Kind.Is(NotificationKind.OnCompleted);
}
public void DoesNotEmitAnythingWhenSelectingAdditionalCalendars()
{
var observer = Substitute.For <IObserver <bool> >();
ViewModel.Done.Enabled.Subscribe(observer);
var selectedableUserCalendars = Enumerable
.Range(0, 10)
.Select(id =>
{
var userCalendar = new UserCalendar(id.ToString(), id.ToString(), "Doenst matter");
return(new SelectableUserCalendarViewModel(userCalendar, false));
});
var auxObserver = TestScheduler.CreateObserver <Unit>();
Observable.Concat(
selectedableUserCalendars
.Select(calendar => Observable.Defer(() => ViewModel.SelectCalendar.Execute(calendar)))
)
.Subscribe(auxObserver);
TestScheduler.Start();
Received.InOrder(() =>
{
observer.OnNext(false);
observer.OnNext(true);
});
}
public async Task Limit2SequenceToTwo()
{
await new TestScheduler().WithAsync(async shed =>
{
var source = Observable.Concat(Observable.Return(5), Observable.Return(10), Observable.Return(60));
int counter = 0;
var sequence = source.LimitGlobally(s => s.Do(_ => counter++).Delay(TimeSpan.FromMilliseconds(100), shed).WriteLine("Done with delay"), 2);
var results = new List <int>();
sequence.Subscribe(v =>
{
lock (results)
{
results.Add(v);
}
});
Assert.AreEqual(0, results.Count);
await TestUtils.SpinWait(() => counter == 2, 100);
await Task.Delay(20);
Assert.AreEqual(2, counter);
});
}
public IObservable <Unit> EndTurn()
{
return(Observable.Defer(() =>
{
return Observable.Concat(elements.Select(x => x.OnEndTurn()))
.DoOnCompleted(() =>
{
for (var i = 0; i < elements.Count;)
{
var e = elements[i];
if (e.CanRemove)
{
elements.RemoveAt(i);
foreach (var s in owner.Skills.OfType <IModifiedAbnormalState>())
{
s.OnRemovedAbnormalState(e.AbnormalStateType, owner);
}
}
else
{
i++;
}
}
})
.AsSingleUnitObservable();
}));
}
/// <summary>
/// Result:
/// CubeA
/// CubeB
/// CylinderA
/// CubeB
/// CylinderA
/// CylinderB
/// SphereA
/// CylinderB
/// SphereA
/// SphereB
/// CubeA
/// CylinderA
/// SphereA
/// </summary>
void Test_Concat()
{
var sequence = Observable.Range(1, 3).Publish();
var streamA = sequence.Select(e => names[e - 1] + "A")
.Do(s => Debug.Log(s))
.SelectMany(x => Resources.LoadAsync <GameObject>(x).AsAsyncOperationObservable());
var streamB = sequence.Select(e => names[e - 1] + "B")
.Do(s => Debug.Log(s))
.SelectMany(x => Resources.LoadAsync <GameObject>(x).AsAsyncOperationObservable());
List <IObservable <ResourceRequest> > list = new List <IObservable <ResourceRequest> >();
list.Add(streamA);
list.Add(streamB);
Observable.Concat(list).ToArray().Subscribe(
x =>
{
Debug.Log("+++ Concat +++");
foreach (ResourceRequest rq in x)
{
GameObject r = rq.asset as GameObject;
Debug.LogFormat("name: {0}", r.name);
GameObject o = GameObject.Instantiate(r);
}
}, () => { /*OnCompleted*/ });
sequence.Connect();
}
/// <summary>
/// Concatenates all of the specified observable sequences, as long as the previous
/// observable sequence terminated successfully.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequences.</typeparam>
/// <param name="first">The first observable sequence.</param>
/// <param name="second">The second observable sequence.</param>
/// <param name="remainder">The remaining observable sequences to concatenate.</param>
/// <returns>
/// An observable sequence that contains the elements of each given sequence,
/// in sequential order.
/// </returns>
public IObservable <TSource> Process <TSource>(
IObservable <TSource> first,
IObservable <TSource> second,
params IObservable <TSource>[] remainder)
{
return(Observable.Concat(EnumerableEx.Concat(first, second, remainder)));
}
public IObservable <Unit> Execute(ExecutionContext context)
{
Ensure.ArgumentNotNull(context, nameof(context));
var childExecutions = this
.children
.Select(
child =>
Observables
.Unit
.Select(
_ =>
{
var execute = true;
if (context.SkipAhead > TimeSpan.Zero && context.SkipAhead >= child.Duration)
{
context.AddProgress(child.Duration);
execute = false;
}
return(new
{
Child = child,
Execute = execute
});
})
.Where(x => x.Execute)
.SelectMany(x => x.Child.Execute(context)));
return(Observable
.Concat(childExecutions)
.DefaultIfEmpty());
}
public void Concat()
{
var a = Observable.Range(1, 5, Scheduler.ThreadPool);
var b = Observable.Range(10, 3, Scheduler.ThreadPool);
var c = Observable.Return(300, Scheduler.ThreadPool);
Observable.Concat(a, b, c).ToArray().Wait().Is(1, 2, 3, 4, 5, 10, 11, 12, 300);
}
public void Concat_Task()
{
var tss = Observable.Concat(new[] { Task.Factory.StartNew(() => 1), Task.Factory.StartNew(() => 2), Task.Factory.StartNew(() => 3) }.ToObservable());
var res = tss.ToArray().Single();
Assert.True(res.SequenceEqual(new[] { 1, 2, 3 }));
}
public void TestSelectorIsSequential()
{
var selector = new Selector("", 0, 1);
selector.AddChild(new RunRunFail("", 0, 0));
selector.AddChild(new RunRunSuccess("", 0, 0));
Assert.AreEqual(selector.Start(), Observable.Concat(Running, Success));
}
/// <summary>
/// Save all the data we pull off the internet in the cache for later user.
/// </summary>
/// <param name="file"></param>
/// <param name="serverModifiedType"></param>
/// <param name="filedata"></param>
/// <param name="cache"></param>
/// <returns></returns>
public static IObservable <Unit> SaveFileInCache(this IFile file, string serverModifiedType, byte[] filedata, IBlobCache cache)
{
var timeToDelete = DateTime.Now + Settings.CacheFilesTime;
var insertDate = cache.InsertObject(file.FileDateKey(), serverModifiedType, timeToDelete);
var insertData = cache.Insert(file.FileDataKey(), filedata, timeToDelete);
return(Observable.Concat(insertDate, insertData).Skip(1));
}
public RxAction(Func <TInput, IObservable <TElement> > workFactory, IObservable <bool> enabledIf)
{
this.workFactory = workFactory;
DisposeBag = new CompositeDisposable();
Inputs = new Subject <TInput>();
var enabledSubject = new BehaviorSubject <bool>(false);
Enabled = enabledSubject.AsObservable();
var errorsSubject = new Subject <Exception>();
Errors = errorsSubject.AsObservable();
executionObservables = Inputs
.WithLatestFrom(Enabled, (i, e) => (input: i, enabled: e))
.SelectMany(tuple =>
{
var enabled = tuple.enabled;
var input = tuple.input;
if (enabled)
{
var ob = workFactory(input)
.Do(CommonFunctions.DoNothing, error => errorsSubject.OnNext(error))
.Replay(1).RefCount();
return(Observable.Return(ob));
}
else
{
errorsSubject.OnNext(new RxActionNotEnabledException());
return(Observable.Empty <IObservable <TElement> >());
}
})
.Share();
Elements = executionObservables
.SelectMany(observable => observable.OnErrorResumeNext(Observable.Empty <TElement>()));
Executing = executionObservables
.SelectMany(exec =>
{
var execution = exec
.SelectMany(_ => Observable.Empty <bool>())
.OnErrorResumeNext(Observable.Empty <bool>());
return(Observable.Concat(Observable.Return(true), execution, Observable.Return(false)));
})
.StartWith(false)
.Replay(1).RefCount();
Observable.CombineLatest(Executing, enabledIf, (executing, enabled) => !executing && enabled)
.Subscribe(enabledSubject)
.DisposedBy(DisposeBag);
}
public void Concat()
{
var M = N - N / 2;
Observable.Concat(
Observable.Range(1, N),
Observable.Range(1, M)
)
.Subscribe(v => Volatile.Write(ref _store, v));
}
static IObservable <BatchProcessResult> Upload(IAuctionProcedures soap,
IImageLookup imgs,
Consent c,
Lot input) =>
CreateAuction(soap, c, input)
.SelectMany(x => Observable.Concat(
Observable.Return(Add(x)),
AddImages(soap, imgs, c, x).Select(_ => Image(x)),
soap.Commit(c, x.RequestId).Select(_ => Commit(x)))
);
// Use this for initialization
void Start()
{
Observable.Concat(
Observable.Merge(
Observable.TimerFrame(70).ForEachAsync(_ => Debug.Log("1")),
Observable.TimerFrame(60).ForEachAsync(_ => Debug.Log("2"))
),
Observable.TimerFrame(60).ForEachAsync(_ => Debug.Log("3"))
).Subscribe();
}
private static IObservable <TOutput> executeSequentally <TInput, TOutput>(this RxAction <TInput, TOutput> action,
IEnumerable <TInput> inputs)
{
var observables = inputs
.Select(input => Observable.Defer(() => action.ExecuteWithCompletion(input)));
return(Observable.Concat(
observables
));
}
