public void Last_FeedItem_Is_The_One_Published_Later() { var testPodcastsSubj = new ReplaySubject<IPodcastItem>(); IPodcastItemsLoader testPodcasts = new TestPodcastItemsLoader(testPodcastsSubj); var initialDate = DateTime.Now; testPodcastsSubj.OnNext(new TestPodcastItem(1, initialDate.AddDays(1))); testPodcastsSubj.OnNext(new TestPodcastItem(2, initialDate.AddDays(2))); _virtualScheduler.AdvanceBy(TimeSpan.FromSeconds(1)); var model = new FeedViewModel("TestFeed", testPodcasts); _virtualScheduler.AdvanceBy(TimeSpan.FromSeconds(1)); Assert.AreEqual(2, ((TestPodcastItem)model.LastFeedItem).Id); Assert.AreEqual(2, model.Items.Count); testPodcastsSubj.OnNext(new TestPodcastItem(3, initialDate.AddDays(3))); _virtualScheduler.AdvanceBy(TimeSpan.FromSeconds(1)); Assert.AreEqual(3, ((TestPodcastItem)model.LastFeedItem).Id); testPodcastsSubj.OnNext(new TestPodcastItem(4, initialDate.AddDays(-1))); _virtualScheduler.AdvanceBy(TimeSpan.FromSeconds(1)); Assert.AreEqual(3, ((TestPodcastItem)model.LastFeedItem).Id); }
public LeakyLetterRepo() { _letters = new ReplaySubject<string>(); _letters.OnNext("A"); _letters.OnNext("B"); _letters.OnNext("C"); }
private static IObservable<byte[]> CreateDownloadObservable(Uri uri) { return Observable.Create<byte[]>(o => { var result = new ReplaySubject<byte[]>(); var inner = Observable.Using(() => new WebClient(), wc => { var obs = Observable .FromEventPattern< DownloadDataCompletedEventHandler, DownloadDataCompletedEventArgs>( h => wc.DownloadDataCompleted += h, h => wc.DownloadDataCompleted -= h) .Take(1); wc.DownloadDataAsync(uri); return obs; }).Subscribe(ep => { if (ep.EventArgs.Cancelled) { result.OnCompleted(); } else { if (ep.EventArgs.Error != null) { result.OnError(ep.EventArgs.Error); } else { result.OnNext(ep.EventArgs.Result); result.OnCompleted(); } } }, ex => { result.OnError(ex); }); return new CompositeDisposable(inner, result.Subscribe(o)); }).Retry(5); }
public async Task GetProgressFromASyncOperation() { CredentialsHandler credentials = (url, usernameFromUrl, types) => new UsernamePasswordCredentials { Username = "******", Password = "******" }; var repository = new ObservableRepository( @"C:\Users\brendanforster\Documents\GìtHūb\testing-pushspecs", credentials); Func<int, int> translate = x => x / 3; var pullObserver = new ReplaySubject<Tuple<string, int>>(); var pushObserver = new ReplaySubject<Tuple<string, int>>(); var pullResult = await repository.Pull(pullObserver); Assert.NotEqual(MergeStatus.Conflicts, pullResult.Status); await repository.Push(pushObserver); var list = await pullObserver.Select(x => translate(x.Item2) * 2) .Concat(pushObserver.Select(x => 67 + translate(x.Item2))) .ToList(); Assert.NotEmpty(list); Assert.Equal(100, list.Last()); }
public Steps(ServiceContext serviceContext, ClientContext clientContext) { _serviceContext = serviceContext; _clientContext = clientContext; _messages = new ReplaySubject<Tuple<string, IMessage>>(); }
public CommandVersioningTests() { var events = new ReplaySubject<object>(); events.Subscribe(_publishedEvents.Add); _host = new CedarHost(new Bootstrapper(new ObservableMessagePublisher(events))); _client = _host.CreateClient(); }
public SynchronizationController( IScheduler scheduler, IStartSynchronizing startSynchronizing, ITranscodingNotifications transcodingNotifications) { if (transcodingNotifications == null) throw new ArgumentNullException(nameof(transcodingNotifications), $"{nameof(transcodingNotifications)} is null."); if (startSynchronizing == null) throw new ArgumentNullException(nameof(startSynchronizing), $"{nameof(startSynchronizing)} is null."); if (scheduler == null) throw new ArgumentNullException(nameof(scheduler)); _scheduler = scheduler; _startSynchronizing = startSynchronizing; _transcodingNotifications = transcodingNotifications; _enabledDisposable = new ReplaySubject<IDisposable>(1, _scheduler); _enabledDisposable.OnNext(null); _disposable = _enabledDisposable.Delta((d1, d2) => { if (d1 != null) { d1.Dispose(); } return d1 != null || d2 != null; }) .TakeWhile(b => b) .SubscribeOn(_scheduler) .Subscribe(_ => { }, e => { }); }
///<summary> ///ReplaySubject<T> will listen to all publications once subscribed. ///The subscriber will also get all publications made before subscription. ///Simply, ReplaySubject has a buffer in whihc it will keep all the publications made for future subscriptions. ///</summary> private static void ReplaySubject() { var subject = new ReplaySubject<string>(); subject.OnNext("a"); subject.Subscribe(Console.WriteLine); subject.OnNext("b"); subject.OnNext("c"); }
static IObservable<string> UsingSubject() { var subject = new ReplaySubject<string>(); subject.OnNext("a"); subject.OnNext("b"); subject.OnCompleted(); Task.Delay(TimeSpan.FromMilliseconds(3000)).Wait(); return subject; }
internal RedisLogger(string key, ILog log, IRedisConnectionFactory redisConnectionFactory) { this.key = string.Format(CultureInfo.InvariantCulture, "{0}:{1}", log.Logger.Name, key); this.log = log; this.messagesSubject = new ReplaySubject<Tuple<string, string>>(100, TimeSpan.FromSeconds(5)); this.retry = new BehaviorSubject<bool>(false); var redisOnConnectionAction = new Action<Task<RedisConnection>>(task => { if (task.IsCompleted && !task.IsFaulted) { Interlocked.CompareExchange<RedisConnection>(ref this.redisConnection, task.Result, null); subscription = messagesSubject.TakeUntil(retry.Skip(1)).Subscribe((item) => { redisConnection.Publish(item.Item1, item.Item2).ContinueWith(taskWithException => { taskWithException.Exception.Handle(ex => true); }, TaskContinuationOptions.OnlyOnFaulted); }); } }); var redisOnErrorAction = new Action<ErrorEventArgs>(ex => { if (ex.IsFatal) { retry.OnNext(true); Interlocked.Exchange<RedisConnection>(ref this.redisConnection, null); } }); Action subscribeAction = () => { var connectionTask = redisConnectionFactory.CreateRedisConnection(); connectionTask.ContinueWith(taskConnection => { if (!taskConnection.IsFaulted) { taskConnection.ContinueWith(redisOnConnectionAction); taskConnection.Result.Error += (_, err) => redisOnErrorAction(err); } else { taskConnection.Exception.Handle(_ => true); this.retry.OnNext(true); } }); }; retry.Subscribe(val => { if (val) Observable.Timer(TimeSpan.FromSeconds(10)).Subscribe(_ => subscribeAction()); else subscribeAction(); }); }
public static void ReplaySubjectBufferExample() { var bufferSize = 2; var subject = new ReplaySubject<string>(bufferSize); subject.OnNext("a"); subject.OnNext("b"); subject.OnNext("c"); subject.Subscribe(Console.WriteLine); subject.OnNext("d"); }
///<summary> ///The Method simulates a blocking call by assigning the Immediate Thread as the Thread of execution /// The execution will move into asyncmode when we call the Nonblocking Method /// </summary> private static IObservable<string> BlockingMethod() { var subject = new ReplaySubject<string>(Scheduler.Immediate); subject.Subscribe(Console.WriteLine); subject.OnNext("a"); subject.OnNext("b"); subject.OnCompleted(); Thread.Sleep(2000); return subject; }
public async Task EmitPointerStateWhenUpdated() { var points = new ReplaySubject<PointerState>(); var observer = new PointerObserver(points); observer.Update(new GameTime(), Point.Zero); Assert.AreEqual(new PointerState { Position = new GeoPoint() }, await points.FirstAsync()); observer.Update(new GameTime(), new Point(Config.SpriteSize, Config.SpriteSize)); Assert.AreEqual(new PointerState { Position = new GeoPoint { X = 1, Y = 1 } }, await points.Skip(1).FirstAsync()); }
public static void ReplaySubjectWindowExample() { var window = TimeSpan.FromMilliseconds(150); var subject = new ReplaySubject<string>(window); subject.OnNext("w"); Thread.Sleep(TimeSpan.FromMilliseconds(100)); subject.OnNext("x"); Thread.Sleep(TimeSpan.FromMilliseconds(100)); subject.OnNext("y"); subject.Subscribe(Console.WriteLine); subject.OnNext("z"); }
public static async Task Returns_Correct_Movement(decimal price1, decimal price2, PriceMovement expected) { var subject = new ReplaySubject<IPrice>(); var result = subject.ToPriceMovementStream(); subject.OnNext(new Price { Mid = price1 }); subject.OnNext(new Price { Mid = price2 }); subject.OnCompleted(); // Assert await result.SingleAsync(movement => movement == expected); }
private void Start() { //ReplaySubjectも初期を設定することができる(今回は設定しない) replaySubject = new ReplaySubject<int>(); /* OnNextを何回か繰り返す → Subscribe と実行し、Subscribeした瞬間に過去の値がまとめて値が発行されることを確認しよう */ // Subscribeボタンが押されたらSubjectをSubscribeしてresultTextに表示する subscribeButton.OnClickAsObservable().Subscribe(_ => { if (replaySubject != null) { replaySubject.Subscribe( time => resultText.text += time.ToString() + " ", //OnNext () => resultText.text += "OnCompleted "); //OnCompleted } }); // OnNextボタンが押されたら今が何度目のOnNextであるかを発行する onNextButton.OnClickAsObservable().Subscribe(_ => { if (replaySubject != null) { replaySubject.OnNext(++onNextCount); } }); // OnCompletedボタンが押されたらOnCompletedを発行する onCompletedButton.OnClickAsObservable().Subscribe(_ => { if (replaySubject != null) { replaySubject.OnCompleted(); } }); // Resetボタンが押されたら全体を初期化する resetButton.OnClickAsObservable().Subscribe(_ => { if (replaySubject != null) { replaySubject.OnCompleted(); } replaySubject = new ReplaySubject<int>(); resultText.text = ""; onNextCount = 0; }); }
public void ApplyReleasesWithDeltaReleases() { string tempDir; using (Utility.WithTempDirectory(out tempDir)) { Directory.CreateDirectory(Path.Combine(tempDir, "theApp", "packages")); new[] { "Shimmer.Core.1.0.0.0-full.nupkg", "Shimmer.Core.1.1.0.0-delta.nupkg", "Shimmer.Core.1.1.0.0-full.nupkg", }.ForEach(x => File.Copy(IntegrationTestHelper.GetPath("fixtures", x), Path.Combine(tempDir, "theApp", "packages", x))); var fixture = new UpdateManager("http://lol", "theApp", FrameworkVersion.Net40, tempDir, null, new FakeUrlDownloader()); var baseEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Shimmer.Core.1.0.0.0-full.nupkg")); var deltaEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Shimmer.Core.1.1.0.0-delta.nupkg")); var latestFullEntry = ReleaseEntry.GenerateFromFile(Path.Combine(tempDir, "theApp", "packages", "Shimmer.Core.1.1.0.0-full.nupkg")); var updateInfo = UpdateInfo.Create(baseEntry, new[] { deltaEntry, latestFullEntry }, "dontcare", FrameworkVersion.Net40); updateInfo.ReleasesToApply.Contains(deltaEntry).ShouldBeTrue(); using (fixture) { var progress = new ReplaySubject<int>(); fixture.ApplyReleases(updateInfo, progress).First(); this.Log().Info("Progress: [{0}]", String.Join(",", progress)); progress.Buffer(2,1).All(x => x.Count != 2 || x[1] > x[0]).First().ShouldBeTrue(); progress.Last().ShouldEqual(100); } var filesToFind = new[] { new {Name = "NLog.dll", Version = new Version("2.0.0.0")}, new {Name = "NSync.Core.dll", Version = new Version("1.1.0.0")}, new {Name = "Ionic.Zip.dll", Version = new Version("1.9.1.8")}, }; filesToFind.ForEach(x => { var path = Path.Combine(tempDir, "theApp", "app-1.1.0.0", x.Name); this.Log().Info("Looking for {0}", path); File.Exists(path).ShouldBeTrue(); var vi = FileVersionInfo.GetVersionInfo(path); var verInfo = new Version(vi.FileVersion ?? "1.0.0.0"); x.Version.ShouldEqual(verInfo); }); } }
public async Task fires_once_when_a_file_is_changed() { // Given File.WriteAllText(fileName, "hubba"); var results = new ReplaySubject<string>(); FileSystem.WhenFileChanges(fileName).Subscribe(results); // When File.WriteAllText(fileName, "bubba"); // Then var events = await results.TakeUntil(DateTime.Now + TimeSpan.FromMilliseconds(200)).ToArray(); events.Should().HaveCount(1); events[0].Should().Be(fileName); }
public async Task CanCloneARepository() { using (var directory = TestDirectory.Create()) { var cloneObserver = new ReplaySubject<Tuple<string, int>>(); using (await ObservableRepository.Clone( "https://github.com/shiftkey/rxui-design-guidelines.git", directory.Path, cloneObserver)) { Assert.NotEmpty(Directory.GetFiles(directory.Path)); var progressList = await cloneObserver.Select(x => x.Item2).ToList(); Assert.Equal(100, progressList.Last()); } } }
public void SubscribeBeforeSetParam() { var server = new ParameterServer(new Uri("http://localhost")); var slave = new SlaveServer("test", 0, new TopicContainer()); var observer = new ReplaySubject<KeyValuePair<string, object>>(); slave.ParameterUpdated += (key, value) => observer.OnNext(new KeyValuePair<string, object>(key, value)); server.SubscribeParam("test", slave.SlaveUri.ToString(), "test_param"); server.SetParam("test", "test_param", 5678); observer.First().Key.Is("test_param"); observer.First().Value.Is(5678); }
public void honours_buffer_size_for_replays_with_priority_to_most_recent() { ReplaySubject<int> subject = new ReplaySubject<int>(2); StatsObserver<int> stats = new StatsObserver<int>(); subject.OnNext(1); subject.OnNext(2); subject.OnNext(3); subject.Subscribe(stats); Assert.AreEqual(2, stats.NextCount); Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 2, 3 })); Assert.IsFalse(stats.CompletedCalled); }
public CueList(int? iterations = null, bool bounce = false, [System.Runtime.CompilerServices.CallerMemberName] string name = "") { this.iterations = iterations; this.iterationsLeft = iterations; this.bounce = bounce; this.name = name; this.cues = new List<Cue>(); this.deviceObserversBrightness = new Dictionary<IReceivesBrightness, ControlledObserver<double>>(); this.deviceObserversColor = new Dictionary<IReceivesColor, ControlledObserver<Color>>(); this.deviceObserversPan = new Dictionary<IReceivesPanTilt, ControlledObserver<double>>(); this.deviceObserversTilt = new Dictionary<IReceivesPanTilt, ControlledObserver<double>>(); this.direction = 1; this.currentCuePos = -1; this.heldLocks = new Dictionary<IOwnedDevice, IControlToken>(); this.triggerNext = new ManualResetEvent(false); this.triggerCancelSources = new Dictionary<Cue, CancellationTokenSource>(); this.cueListTime = new Stopwatch(); this.currentCueId = new ReplaySubject<int?>(1); this.currentCueId.OnNext(null); this.cueCompleted = new Subject<Tuple<int, long>>(); this.LockPriority = 1; this.cancelSource = new CancellationTokenSource(); this.cueListExecutor = new Task(() => { while (!this.cancelSource.IsCancellationRequested) { WaitHandle.WaitAny(new WaitHandle[] { this.cancelSource.Token.WaitHandle, this.triggerNext }); if (this.cancelSource.IsCancellationRequested) break; this.triggerNext.Reset(); NextCue(); } }, cancelSource.Token, TaskCreationOptions.LongRunning); Executor.Current.Register(this); }
public void buffer_size_includes_onerror() { ReplaySubject<int> subject = new ReplaySubject<int>(2); StatsObserver<int> stats = new StatsObserver<int>(); subject.OnNext(1); subject.OnNext(2); subject.OnNext(3); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.AreEqual(1, stats.NextCount); Assert.IsTrue(stats.NextValues.SequenceEqual(new int[] { 3 })); Assert.IsTrue(stats.ErrorCalled); }
public void errors_are_sent_through_scheduler() { ManualScheduler scheduler = new ManualScheduler(); ReplaySubject<int> subject = new ReplaySubject<int>(scheduler); StatsObserver<int> stats = new StatsObserver<int>(); subject.OnError(new Exception()); subject.Subscribe(stats); Assert.IsFalse(stats.ErrorCalled); scheduler.RunNext(); Assert.IsTrue(stats.ErrorCalled); }
public static void Run() { // var subject = new ReplaySubject<string>(); // var subject = new ReplaySubject<string>(2 /* bufferSize */); var window = TimeSpan.FromMilliseconds(150); var subject = new ReplaySubject<string>(window); subject.OnNext("a"); Task.Delay(TimeSpan.FromMilliseconds(100)).Wait(); subject.OnNext("b"); Task.Delay(TimeSpan.FromMilliseconds(100)).Wait(); subject.OnNext("c"); WriteSequenceToConsole(subject); subject.OnNext("d"); Console.ReadLine(); }
public void ObservableExecuteFuncShouldBeObservableAndAct() { var executed_params = new List<object>(); var fixture = createCommand(null); fixture.Subscribe(x => executed_params.Add(x)); var observed_params = new ReplaySubject<object>(); fixture.Subscribe(observed_params.OnNext, observed_params.OnError, observed_params.OnCompleted); var range = Enumerable.Range(0, 5); range.Run(x => fixture.Execute(x)); range.AssertAreEqual(executed_params.OfType<int>()); range.ToObservable() .Zip(observed_params, (expected, actual) => new {expected, actual}) .Do(Console.WriteLine) .Subscribe(x => Assert.Equal(x.expected, x.actual)); }
private static void Example2() { Console.WriteLine("Starting on threadId:{0}", Util.GetTid()); var subject = new ReplaySubject<int>(); subject.OnNext(0); subject.OnNext(1); subject.OnNext(2); subject // .SubscribeOn(NewThreadScheduler.Default) .Subscribe( i => Console.WriteLine("Received {1} on threadId:{0}", Util.GetTid(), i), () => Console.WriteLine("OnCompleted on threadId:{0}", Util.GetTid())); Console.WriteLine("Subscribed on threadId:{0}", Util.GetTid()); Task.Delay(TimeSpan.FromMilliseconds(500)).Wait(); }
private IObservable<ManagementBaseObject> Factory(ManagementClass mc) { var src = new ReplaySubject<ManagementBaseObject>(); var ob = new ManagementOperationObserver(); Observable.FromEventPattern<ObjectReadyEventHandler, ObjectReadyEventArgs>( h => h.Invoke, h => ob.ObjectReady += h, h => ob.ObjectReady -= h ).Subscribe(obj => src.OnNext(obj.EventArgs.NewObject)); Observable.FromEventPattern<CompletedEventHandler, CompletedEventArgs>( h => h.Invoke, h => ob.Completed += h, h => ob.Completed -= h ).Subscribe(_ => src.OnCompleted()); mc.GetInstances(ob); return src.AsObservable(); }
public CloneRepositoryViewModel(string cloneUrl, string localDirectory) { IsEmpty = true; Branches = new ReactiveList<BranchViewModel>(); // omg this hack sucks Progress = new ReplaySubject<Tuple<string, int>>(); var anyProgress = this.WhenAnyObservable(x => x.Progress); progressText = anyProgress.Select(x => x.Item1) .ToProperty(this, x => x.ProgressText, scheduler: RxApp.MainThreadScheduler); progressValue = anyProgress.Select(x => x.Item2) .ToProperty(this, x => x.ProgressValue, scheduler: RxApp.MainThreadScheduler); Clone = ReactiveCommand.CreateAsyncObservable(_ => { Progress = new ReplaySubject<Tuple<string, int>>(); return ObservableRepository.Clone(cloneUrl, localDirectory, Progress); }); isCloningObs = Clone.IsExecuting.ToProperty(this, x => x.IsCloning); Clone.Subscribe(_ => { IsEmpty = false; }); repositoryObs = Clone.ToProperty(this, x => x.Repository); this.WhenAnyValue(x => x.Repository) .Where(x => x != null) .Subscribe(RefreshBranches); Checkout = ReactiveCommand.CreateAsyncObservable( this.WhenAny(x => x.SelectedBranch, x => x != null), _ => { Progress = new ReplaySubject<Tuple<string, int>>(); var branch = Repository.Inner.Branches[SelectedBranch.Name]; return Repository.Checkout(branch, Progress); }); Checkout.Subscribe(_ => RefreshBranches(Repository)); }
private static IObservable<ServiceState> CallOperationOnService(ServiceBase serviceBase, Operation operation) { ReplaySubject<ServiceState> result = new ReplaySubject<ServiceState>(); result.OnNext(operation.InitialState); var methodObs = Observable.Start(() => { Type serviceBaseType = serviceBase.GetType(); object[] parameters = null; if (operation == Operations.Start) { parameters = new object[] { null }; } try { serviceBaseType.InvokeMember(operation.MethodCall, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.InvokeMethod, null, serviceBase, parameters); } catch (Exception ex) { throw new Exception(string.Format("An exception was thrown while trying to call the {0} of the {1} service. Examine the inner exception for more information.", operation, serviceBase.ServiceName), ex.InnerException); } }); methodObs.Subscribe ( _ => { result.OnNext(operation.FinishedState); result.OnCompleted(); }, ex => { result.OnNext(operation.ErrorState); result.OnError(ex); } ); return result; }
public SimpleOutput() { _replaySubject = new ReplaySubject <object>(1024); }
public IOStreams() { _input = new ReplaySubject <string>(); _output = new ReplaySubject <string>(); }
public InlineViewer([NotNull] InlineViewerArgs args, [NotNull] IClipboardHandler clipboardHandler, [NotNull] ISchedulerProvider schedulerProvider, [NotNull] ISelectionMonitor selectionMonitor, [NotNull] ILogger logger, [NotNull] IThemeProvider themeProvider) { if (args == null) { throw new ArgumentNullException(nameof(args)); } if (clipboardHandler == null) { throw new ArgumentNullException(nameof(clipboardHandler)); } if (schedulerProvider == null) { throw new ArgumentNullException(nameof(schedulerProvider)); } if (selectionMonitor == null) { throw new ArgumentNullException(nameof(selectionMonitor)); } if (themeProvider == null) { throw new ArgumentNullException(nameof(themeProvider)); } SelectionMonitor = selectionMonitor; CopyToClipboardCommand = new Command(() => clipboardHandler.WriteToClipboard(selectionMonitor.GetSelectedText())); _isSettingScrollPosition = false; var lineProvider = args.LineProvider; var selectedChanged = args.SelectedChanged; var pageSize = this.WhenValueChanged(vm => vm.PageSize); //if use selection is null, tail the file var scrollSelected = selectedChanged .CombineLatest(lineProvider, pageSize, (proxy, lp, pge) => proxy == null ? new ScrollRequest(pge, 0) : new ScrollRequest(pge, proxy.Start)) .DistinctUntilChanged(); var horizonalScrollArgs = new ReplaySubject <TextScrollInfo>(1); HorizonalScrollChanged = hargs => { horizonalScrollArgs.OnNext(hargs); }; var scrollUser = _userScrollRequested .Where(x => !_isSettingScrollPosition) .Select(request => new ScrollRequest(ScrollReason.User, request.PageSize, request.FirstIndex)); var scroller = scrollSelected.Merge(scrollUser) .ObserveOn(schedulerProvider.Background) .DistinctUntilChanged(); var lineScroller = new LineScroller(lineProvider, scroller); Count = lineProvider.Select(lp => lp.Count).ForBinding(); MaximumChars = lineScroller.MaximumLines() .ObserveOn(schedulerProvider.MainThread) .ForBinding(); var proxyFactory = new LineProxyFactory(new TextFormatter(args.SearchMetadataCollection), new LineMatches(args.SearchMetadataCollection), horizonalScrollArgs.DistinctUntilChanged(), themeProvider); //load lines into observable collection var loader = lineScroller.Lines.Connect() .Transform(proxyFactory.Create, new ParallelisationOptions(ParallelType.Ordered, 3)) .Sort(SortExpressionComparer <LineProxy> .Ascending(proxy => proxy)) .ObserveOn(schedulerProvider.MainThread) .Bind(out _data) .DisposeMany() .LogErrors(logger) .Subscribe(); // track first visible index [required to set scroll extent] var firstIndexMonitor = lineScroller.Lines.Connect() .Buffer(TimeSpan.FromMilliseconds(250)).FlattenBufferResult() .ToCollection() .Select(lines => lines.Count == 0 ? 0 : lines.Select(l => l.Index).Max() - lines.Count + 1) .ObserveOn(schedulerProvider.MainThread) .Subscribe(first => { try { _isSettingScrollPosition = true; FirstIndex = first; } finally { _isSettingScrollPosition = false; } }); _cleanUp = new CompositeDisposable(lineScroller, loader, Count, firstIndexMonitor, SelectionMonitor, MaximumChars, horizonalScrollArgs.SetAsComplete(), _userScrollRequested.SetAsComplete()); }
public static void RuMain() { WriteLine("Subject"); var subject = new Subject <string>(); subject.OnNext("A"); using (var subscriptiion = OutputToConsole(subject)) { subject.OnNext("B"); subject.OnNext("C"); subject.OnNext("D"); subject.OnCompleted(); subject.OnNext("Will not be printed out"); } WriteLine("ReplaySubject"); var replaySubject = new ReplaySubject <string>(); replaySubject.OnNext("A"); using (var subscriptiion = OutputToConsole(replaySubject)) { replaySubject.OnNext("B"); replaySubject.OnNext("C"); replaySubject.OnNext("D"); replaySubject.OnCompleted(); } WriteLine("Buffer ReplaySubject"); var bufferedSubject = new ReplaySubject <string>(2); bufferedSubject.OnNext("A"); bufferedSubject.OnNext("B"); bufferedSubject.OnNext("C"); using (var subscription = OutputToConsole(bufferedSubject)) { bufferedSubject.OnNext("D"); bufferedSubject.OnCompleted(); } WriteLine("Time Window Subject"); var timeSubject = new ReplaySubject <string>(TimeSpan.FromMilliseconds(200)); timeSubject.OnNext("A"); Sleep(TimeSpan.FromMilliseconds(100)); timeSubject.OnNext("B"); Sleep(TimeSpan.FromMilliseconds(100)); timeSubject.OnNext("C"); Sleep(TimeSpan.FromMilliseconds(100)); using (var subscriptiion = OutputToConsole(timeSubject)) { Sleep(TimeSpan.FromMilliseconds(300)); timeSubject.OnNext("D"); timeSubject.OnCompleted(); } WriteLine("AsyncSubject"); var asyncSubject = new AsyncSubject <string>(); asyncSubject.OnNext("A"); using (var subscription = OutputToConsole(asyncSubject)) { asyncSubject.OnNext("B"); asyncSubject.OnNext("C"); asyncSubject.OnNext("D"); asyncSubject.OnCompleted(); } WriteLine("BehaviorSubject"); var behaviorSubject = new BehaviorSubject <string>("Default"); using (var subscription = OutputToConsole(behaviorSubject)) { behaviorSubject.OnNext("B"); behaviorSubject.OnNext("C"); behaviorSubject.OnNext("D"); behaviorSubject.OnCompleted(); } }
public IControl CreatePopover( RectangleEdge prefferedContentEdge, Func <PopoverState, IControl> content, Func <PopoverState, IControl> popover) { var state = new PopoverState { IsVisible = new BehaviorSubject <bool>(false), }; var contentFrameState = new ReplaySubject <Rectangle <Points> >(1); var contentFrame = contentFrameState.Transpose(); var center = contentFrame.Center(); var arrow = Shapes.Rectangle(fill: Theme.PanelBackground) .WithSize(new Size <Points>(13, 13)) .Rotate(Math.PI / 4) ; var popoverContent = Control.Lazy(() => popover(state)); var desiredContentEdge = contentFrame.GetEdge(prefferedContentEdge) .Add(popoverContent.DesiredSize.Height); var desiredHostEdge = HostFrame.Switch().GetEdge(prefferedContentEdge); var adjustedEdge = desiredContentEdge .CombineLatest(desiredHostEdge, (a, b) => a >= b) // Put popover on the opposite edge if there are not enough room for it on the preffered edge. .Select(opposite => opposite ? prefferedContentEdge.Opposite() : prefferedContentEdge); var arrowStartOffsetY = adjustedEdge .Select(e => e.IsMinimal() ? contentFrame.GetEdge(e).Sub(arrow.DesiredSize.Height) : contentFrame.GetEdge(e).Sub(4)) .Switch(); var contentStartOffsetY = adjustedEdge .Select(e => e.IsMinimal() ? contentFrame.GetEdge(e).Sub(popoverContent.DesiredSize.Height).Sub(arrow.DesiredSize.Height.Div(2)) : contentFrame.GetEdge(e).Add(arrow.DesiredSize.Height.Div(2)).Sub(4)) .Switch(); var close = Command.Enabled(() => state.IsVisible.OnNext(false)); var popoverControl = Control.Lazy(() => Layout.Layer(self => { var widthInterval = Observable.CombineLatest( self.NativeFrame.Width, popoverContent.DesiredSize.Width, center.X, (availableWidth, desiredWidth, desiredCenter) => { desiredWidth += 8; // dropshadow compensation var halfWidth = desiredWidth / 2; return(Interval.FromOffsetLength( offset: desiredCenter - halfWidth <0 ? 0 : desiredCenter + halfWidth> availableWidth ? availableWidth - desiredWidth : desiredCenter - halfWidth, length: availableWidth.Min(desiredWidth))); }); return(Observable.Return( new[] { Shapes.Rectangle(fill: Color.AlmostTransparent).OnMouse(pressed: close), arrow .WithFixedPosition( Rectangle.FromIntervals( Interval.FromOffsetLength(center.X.Sub(arrow.DesiredSize.Width.Div(2)).Sub(4), arrow.DesiredSize.Width), Interval.FromOffsetLength(arrowStartOffsetY, arrow.DesiredSize.Height))), popoverContent .WithBackground( Shapes.Rectangle(fill: Theme.PanelBackground, cornerRadius: Observable.Return(new CornerRadius(2)))) .MakeHittable().Control .WithFixedPosition( Rectangle.FromIntervals( widthInterval.Transpose(), Interval.FromOffsetLength(contentStartOffsetY, popoverContent.DesiredSize.Height))) })); }) .DropShadow(radius: Observable.Return(new Points(4)), distance: Observable.Return(new Points(0.5)))); state.IsVisible.SubscribeUsing(isVisible => isVisible ? Popovers.AddTemporarily(popoverControl) : Disposable.Empty); return(LayoutTracker.TrackVisualBounds(contentFrameState.OnNext, content(state))); }
public void SchedulerUsage() { var sub = new ReplaySubject <int> (new ErrorScheduler()); sub.Subscribe(Console.WriteLine); }
/// <summary> /// Асинхрона получает содержимое страницы /// </summary> /// <returns>Итемы на странице</returns> private IObservable <IEnumerable <SaveToJson.Device> > GetContent(ParseSettings settings) { if (settings.Method == ParseSettings.Methods.GET) { return(Observable.Create <IEnumerable <SaveToJson.Device> >(o => { var result = new ReplaySubject <IEnumerable <SaveToJson.Device> >(); var inner = Observable.Using(() => new SmartWebClient(), wc => { var obs = Observable .FromEventPattern < DownloadStringCompletedEventHandler, DownloadStringCompletedEventArgs>( h => wc.DownloadStringCompleted += h, h => wc.DownloadStringCompleted -= h) .ObserveOn(Scheduler.CurrentThread) .Where(e => !e.EventArgs.Cancelled); var uri = new Uri(settings.UrlSite); PrintStatus("Start parsing", uri.Host, ConsoleColor.Yellow); wc.DownloadStringAsync(uri); return obs; }).Subscribe(ep => { if (ep.EventArgs.Cancelled) { result.OnCompleted(); } else { if (ep.EventArgs.Error != null) { PrintStatus(string.Format("Error {0} ", ep.EventArgs.Error), settings.UrlSite, ConsoleColor.Red); result.OnCompleted(); } else { result.OnNext(GetItems(ep.EventArgs.Result)); result.OnCompleted(); } } }, result.OnError); return new CompositeDisposable(inner, result.Subscribe(o)); })); } else { return(Observable.Create <IEnumerable <SaveToJson.Device> >(o => { var result = new ReplaySubject <IEnumerable <SaveToJson.Device> >(); var inner = Observable.Using(() => new SmartWebClient(), wc => { var obs = Observable .FromEventPattern < UploadDataCompletedEventHandler, UploadDataCompletedEventArgs>( h => wc.UploadDataCompleted += h, h => wc.UploadDataCompleted -= h) .ObserveOn(Scheduler.CurrentThread) .Where(e => !e.EventArgs.Cancelled); var uri = new Uri(settings.UrlSite); PrintStatus("Start parsing", uri.Host, ConsoleColor.Yellow); byte[] postArray = Encoding.UTF8.GetBytes(settings.Data); wc.Headers.Add(settings.Heades); wc.UploadDataAsync(uri, postArray); return obs; }).Subscribe(ep => { if (ep.EventArgs.Cancelled) { result.OnCompleted(); } else { if (ep.EventArgs.Error != null) { PrintStatus(string.Format("Error {0} ", ep.EventArgs.Error), settings.UrlSite, ConsoleColor.Red); result.OnCompleted(); } else { result.OnNext(GetItems(Encoding.UTF8.GetString(ep.EventArgs.Result))); result.OnCompleted(); } } }, result.OnError); return new CompositeDisposable(inner, result.Subscribe(o)); })); } }
public WithdrawalReceiver() { this.newWithdrawalsOnTargetChainStream = new ReplaySubject <IReadOnlyList <IWithdrawal> >(1); this.NewWithdrawalsOnTargetChainStream = this.newWithdrawalsOnTargetChainStream.AsObservable(); }
private IObservable <string> DoAsyncSend(string cmd) { if (this.scheduler == null) { throw new Exception("Connection closed."); } var subject = new ReplaySubject <string>(); this.scheduler.Schedule(() => { try { if (!this.Connect()) { return; } var writer = new StreamWriter(client.GetStream()) { AutoFlush = true }; var reader = new StreamReader(client.GetStream()); writer.WriteLine(cmd); var response = ReadLine(reader); subject.OnNext(response); if (Regex.IsMatch(response, "201.*")) { subject.OnNext(ReadLine(reader)); } else if (Regex.IsMatch(response, "200.*")) { while (response != string.Empty) { response = ReadLine(reader); subject.OnNext(response); } } else if (Regex.IsMatch(response, "400.*")) { throw new Exception("Command not understood."); } else if (Regex.IsMatch(response, "401.*")) { throw new Exception("Illegal Command."); } else if (Regex.IsMatch(response, "402.*")) { throw new Exception("Parameter missing."); } else if (Regex.IsMatch(response, "403.*")) { throw new Exception("Illegal parameter."); } else if (Regex.IsMatch(response, "404.*")) { throw new Exception("Media file not found."); } else if (Regex.IsMatch(response, "500.*")) { throw new Exception("Internal server error."); } else if (Regex.IsMatch(response, "501.*")) { throw new Exception("Internal server error."); } else if (Regex.IsMatch(response, "502.*")) { throw new Exception("Media file unreadable."); } } catch (IOException ex) { this.Reset(); subject.OnError(ex); } catch (ObjectDisposedException ex) { this.Reset(); subject.OnError(ex); } catch (Exception ex) { subject.OnError(ex); } subject.OnCompleted(); }); return(subject); }
void IAggregateRoot.ClearEvents() { _subject.Dispose(); _subject = new ReplaySubject <DomainEvent>(); ConnectEventHandlers(); }
public async Task ExpiredIndexClearsItems() { var expected = 5; var username = "******"; var reponame = "repo"; var cache = new InMemoryBlobCache(); var apiClient = Substitute.For <IApiClient>(); var modelService = new ModelService(apiClient, cache, Substitute.For <IAvatarProvider>()); var user = CreateOctokitUser(username); apiClient.GetUser().Returns(Observable.Return(new UserAndScopes(user, null))); apiClient.GetOrganizations().Returns(Observable.Empty <Organization>()); var act = modelService.GetAccounts().ToEnumerable().First().First(); var repo = Substitute.For <ILocalRepositoryModel>(); repo.Name.Returns(reponame); repo.Owner.Returns(user.Login); repo.CloneUrl.Returns(new UriString("https://github.com/" + username + "/" + reponame)); var indexKey = string.Format(CultureInfo.InvariantCulture, "{0}|{1}:{2}", CacheIndex.PRPrefix, user.Login, repo.Name); var prcache = Enumerable.Range(1, expected) .Select(id => CreatePullRequest(user, id, ItemState.Open, "Cache " + id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow)); // seed the cache prcache .Select(item => new ModelService.PullRequestCacheItem(item)) .Select(item => item.Save <ModelService.PullRequestCacheItem>(cache, indexKey).ToEnumerable().First()) .SelectMany(item => CacheIndex.AddAndSaveToIndex(cache, indexKey, item).ToEnumerable()) .ToList(); // expire the index var indexobj = await cache.GetObject <CacheIndex>(indexKey); indexobj.UpdatedAt = DateTimeOffset.UtcNow - TimeSpan.FromMinutes(6); await cache.InsertObject(indexKey, indexobj); var prlive = Observable.Range(5, expected) .Select(id => CreatePullRequest(user, id, ItemState.Open, "Live " + id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, 0)) .DelaySubscription(TimeSpan.FromMilliseconds(10)); apiClient.GetPullRequestsForRepository(user.Login, repo.Name).Returns(prlive); await modelService.InsertUser(new AccountCacheItem(user)); ITrackingCollection <IPullRequestModel> col = new TrackingCollection <IPullRequestModel>(); modelService.GetPullRequests(repo, col); col.ProcessingDelay = TimeSpan.Zero; var count = 0; var done = new ReplaySubject <Unit>(); done.OnNext(Unit.Default); done.Subscribe(); col.Subscribe(t => { // we get all the items from the cache (items 1-5), all the items from the live (items 5-9), // and 4 deletions (items 1-4) because the cache expired the items that were not // a part of the live data if (++count == 14) { done.OnCompleted(); } }, () => { }); await done; Assert.Equal(5, col.Count); Assert.Collection(col, t => { Assert.True(t.Title.StartsWith("Live")); Assert.Equal(5, t.Number); }, t => { Assert.True(t.Title.StartsWith("Live")); Assert.Equal(6, t.Number); }, t => { Assert.True(t.Title.StartsWith("Live")); Assert.Equal(7, t.Number); }, t => { Assert.True(t.Title.StartsWith("Live")); Assert.Equal(8, t.Number); }, t => { Assert.True(t.Title.StartsWith("Live")); Assert.Equal(9, t.Number); } ); }
/// <summary> /// Gets an observable returning values when Bluetooth LE adapter availability changes /// </summary> public IObservable <IAdapter> WhenAdapterChanges() => _adapterSubject ?? (_adapterSubject = Init());
// IObserver<T> : 'reader' / 'consumer' ; IObservable<T> : 'writer' / 'publisher' private static void Main() { // Subject<T> is the most basic of the subjects for providing push notifications after subscriptions. Console.WriteLine("Subject"); using (var stream = new Subject <string>()) { stream.OnNext("a"); stream.Subscribe(Console.WriteLine); stream.OnNext("b"); stream.OnNext("c"); } PressAnyKey("Press any key to continue .."); // ReplaySubject<T> provides the feature of caching values and then replaying them for any late subscriptions. Console.WriteLine("ReplaySubject"); using (var stream = new ReplaySubject <string>()) { stream.OnNext("a"); stream.OnNext("b"); stream.OnNext("c"); stream.Subscribe(Console.WriteLine); } PressAnyKey("Press any key to continue .."); // ReplaySubject<T> allows you to specify simple cache expiry settings that can alleviate this memory issue. // One option is that you can specify the size of the buffer in the cache. Console.WriteLine("ReplaySubject(Buffer)"); const int bufferSize = 2; using (var stream = new ReplaySubject <string>(bufferSize)) { stream.OnNext("a"); stream.OnNext("b"); stream.OnNext("c"); stream.Subscribe(Console.WriteLine); } PressAnyKey("Press any key to continue .."); // ReplaySubject<T> allows you to specify simple cache expiry settings that can alleviate this memory issue. // Another option is that you can provide a window time for the cache. Console.WriteLine("ReplaySubject(Window)"); var window = TimeSpan.FromMilliseconds(150); using (var stream = new ReplaySubject <string>(window)) { stream.OnNext("a"); Thread.Sleep(TimeSpan.FromMilliseconds(100)); stream.OnNext("b"); Thread.Sleep(TimeSpan.FromMilliseconds(100)); stream.OnNext("c"); stream.Subscribe(Console.WriteLine); } PressAnyKey("Press any key to continue .."); // BehaviorSubject<T> is similar to ReplaySubject<T> except it only remembers the last publication. // BehaviorSubject<T> also requires you to provide it a default value of T. // This means that all subscribers will receive a value immediately (unless it is already completed). Console.WriteLine("BehaviorSubject(default)"); // default value will be written to the console using (var stream = new BehaviorSubject <string>("a")) { stream.Subscribe(Console.WriteLine); } Console.WriteLine("BehaviorSubject(latest)"); // the last value will be written to the console using (var stream = new BehaviorSubject <string>("a")) { stream.OnNext("b"); stream.OnNext("c"); stream.Subscribe(Console.WriteLine); } PressAnyKey("Press any key to continue .."); // BehaviorSubject<T> is similar to ReplaySubject<T> except it only remembers the last publication. // No values will be published as the sequence has completed. Nothing is written to the console. Console.WriteLine("BehaviorSubject(OnCompleted)"); using (var stream = new BehaviorSubject <string>("a")) { stream.OnNext("b"); stream.OnNext("c"); stream.OnCompleted(); stream.Subscribe(Console.WriteLine); } PressAnyKey("Press any key to continue .."); // AsyncSubject<T> is similar to the Replay and Behavior subjects in the way that it caches values. // However, it will only store the last value and only publish it when the sequence is completed. Console.WriteLine("AsyncSubject(nothing)"); using (var stream = new AsyncSubject <string>()) { stream.OnNext("a"); stream.OnNext("b"); stream.OnNext("c"); stream.Subscribe(Console.WriteLine); } Console.WriteLine("AsyncSubject(latest)"); using (var stream = new AsyncSubject <string>()) { stream.OnNext("a"); stream.OnNext("b"); stream.OnNext("c"); stream.OnCompleted(); stream.Subscribe(Console.WriteLine); } PressAnyKey("Press any key to exit .."); }
public static CustomWindow Create(Window model, Optional <ObservableNSDocument> document) { var dispatcher = Fusion.Application.MainThread; model.Title = model.Title.Select(title => model.HideTitle ? "" : title); var sizeFeedback = model.Size .Or(Property.Create(Optional.None <Size <Points> >())) .Or(Size.Create <Points>(800, 600)) .AutoInvalidate(TimeSpan.FromSeconds(2)); var size = sizeFeedback.PreventFeedback(); var content = new NSDefaultView(); if (model.DragOperation.HasValue) { content.RegisterForDraggedTypes(new string[] { NSPasteboard.NSFilenamesType }); content.AddDropOperation(model.DragOperation.Value); } var window = new CustomWindow(model.Focused) { BackgroundColor = Color.FromBytes(0x31, 0x34, 0x3a).ToNSColor(), ContentView = content, StyleMask = NSWindowStyle.TexturedBackground | /*NSWindowStyle.Utility |*/ NSWindowStyle.Titled | NSWindowStyle.Closable | NSWindowStyle.Miniaturizable | NSWindowStyle.Resizable, HidesOnDeactivate = false, Restorable = false, }; window.IsOpaque = false; content.WantsLayer = true; var fusionContent = model.Content; var desiredTitleBarHeight = new ReplaySubject <IObservable <Points> >(1); switch (model.Style) { case WindowStyle.Regular: // Render window content beneath title bar area window.StyleMask |= NSWindowStyle.FullSizeContentView; // Make title bar transparent window.TitlebarAppearsTransparent = true; // Build custom title bar content and dock it on top of existing fusionContent var titleTextColor = Color.White; var titleBarContent = document.MatchWith(_ => { // If we have a document, we'll create a container to hijack the window's DocumentIconButton later var titleText = Label.Create(text: window.DocumentTitle.AsText(), color: titleTextColor); var documentIconButtonContainer = DocumentIconButtonContainer.Create(window).WithPadding(right: Optional.Some <Points>(4)); return(Layout.StackFromLeft(documentIconButtonContainer, titleText)); }, () => Label.Create(text: model.Title.AsText(), color: titleTextColor)); Action zoom = () => Fusion.Application.MainThread.Schedule(() => window.Zoom(window)); titleBarContent = titleBarContent .WithPadding(top: Optional.Some <Points>(2), bottom: Optional.Some <Points>(3)) .CenterHorizontally(); desiredTitleBarHeight.OnNext(titleBarContent.DesiredSize.Height); fusionContent = Layout.DockTop( titleBarContent, fusionContent ).OnMouse(doubleClicked: Command.Enabled(zoom)); break; case WindowStyle.Fat: // Render window content beneath title bar area window.StyleMask |= NSWindowStyle.FullSizeContentView; //Create a toolbar window.Toolbar = new NSToolbar("toolbar"); // Make title bar transparent window.TitlebarAppearsTransparent = true; window.Toolbar.ShowsBaselineSeparator = false; window.WillUseFullScreenPresentationOptions = (nsWindow, options) => options | NSApplicationPresentationOptions.AutoHideToolbar; // Build custom title bar content and dock it on top of existing fusionContent var titleTextColorFat = model.Foreground; var titleBarContentFat = document.MatchWith(_ => { // If we have a document, we'll create a container to hijack the window's DocumentIconButton later var titleText = Label.Create( text: window.DocumentTitle.AsText(), color: titleTextColorFat, font: Font.SystemDefault(11), lineBreakMode: LineBreakMode.TruncateTail) .WithWidth(140) .Center(); // Ensures the doc name can never run over the controls in compact mode return(titleText); }, () => Label.Create(text: model.Title.AsText(), color: titleTextColorFat)); // For some reason the toolbar sometimes causes double zoom events, this is a workaround bool zoomExpected = false; Action zoomFat = () => Fusion.Application.MainThread.Schedule(() => { try { zoomExpected = true; window.Zoom(window); } finally { zoomExpected = false; } }); window.ShouldZoom = (_, __) => zoomExpected; titleBarContentFat = Layout.StackFromLeft( Control.Empty .WithWidth(80) .HideOnWindows(), Control.Empty .WithWidth(16) .HideOnMac(), titleBarContentFat) .WithPadding(top: Optional.Some <Points>(12)) .DockTopLeft(); desiredTitleBarHeight.OnNext(Observable.Return <Points>(0.0)); fusionContent = fusionContent.OnMouse(doubleClicked: Command.Enabled(zoomFat)).WithOverlay(titleBarContentFat); break; case WindowStyle.None: window.StyleMask = NSWindowStyle.TexturedBackground | NSWindowStyle.Borderless; window.MovableByWindowBackground = true; window.BackgroundColor = NSColor.Clear; desiredTitleBarHeight.OnNext(Observable.Return <Points>(0.0)); content.Layer.Frame = content.Frame; content.Layer.CornerRadius = 5.0f; content.Layer.MasksToBounds = true; break; case WindowStyle.Sheet: desiredTitleBarHeight.OnNext(Observable.Return <Points>(0.0)); break; default: throw new NotImplementedException(); } model.Size.Do(s => s.IsReadOnly.ObserveOn(dispatcher).Subscribe(isReadOnly => { if (isReadOnly) { window.StyleMask &= ~NSWindowStyle.Resizable; } else { window.StyleMask |= NSWindowStyle.Resizable; } })); var sizeFeedbackObservable = sizeFeedback.AsObservable(); var sizeObservable = size.AsObservable(); model.Title.ObserveOn(dispatcher).Subscribe(title => window.Title = title); sizeObservable.CombineLatest( desiredTitleBarHeight.Switch(), (s, h) => new Size <Points>(s.Width, s.Height + h)).ObserveOn(dispatcher).Subscribe(s => window.SetContentSize(s.ToSize())); window.WillClose += (sender, args) => { model.Closed.ExecuteOnce(); }; // Window closed by user var observer = new WindowObserver(); observer.DangerousRetain(); window.AddObserver(observer, new NSString("visible"), NSKeyValueObservingOptions.New, IntPtr.Zero); window.DidResize += (s, a) => desiredTitleBarHeight.Switch() .Subscribe(titleBarHeight => size.Write((content.Frame.Size - new CGSize(0, (float)titleBarHeight)).ToFusion())); var transize = sizeFeedbackObservable.CombineLatest( desiredTitleBarHeight.Switch(), (s, h) => new Size <Points>(s.Width, s.Height + h)).Transpose(); fusionContent.Mount(new MountLocation.Mutable { AvailableSize = transize, NativeFrame = ObservableMath.RectangleWithSize(transize), IsRooted = window.IsShowing }); Fusion.Application.MainThread.Schedule(() => { var nativeContent = fusionContent.NativeHandle as NSView; if (nativeContent != null) { content.AddSubview(nativeContent); } }); var systemId = SystemGuidLoader.LoadOrCreateOrEmpty(); model.Menu.Do(menu => MenuBuilder .CreateMenu(menu, ReportFactory.GetReporter(systemId, Guid.NewGuid(), "Menu")) .ToObservable() .Subscribe(m => window.Menu = m)); window.Center(); var centerposition = new Point <Points>((double)window.Frame.X, (double)window.Frame.Y); var position = model.Position .Or(Property.Create(Optional.None <Point <Points> >())) .Or(centerposition) .AutoInvalidate(TimeSpan.FromSeconds(2)) .PreventFeedback(); model.TopMost.Do(topMost => topMost.Subscribe(t => { window.Level = t ? NSWindowLevel.Floating : NSWindowLevel.Normal; })); position.ObserveOn(dispatcher).Subscribe(p => { window.SetFrameOrigin(new CGPoint(p.X, p.Y)); }); window.DidMove += (s, a) => { position.Write(new Point <Points>((double)window.Frame.Left, (double)window.Frame.Top)); }; window.DidBecomeMain += (s, a) => { if (window.Menu != null) { NSApplication.SharedApplication.MainMenu = window.Menu; } else { NSApplication.SharedApplication.MainMenu = new NSMenu(); } }; return(window); }
public async Task ExpiredIndexReturnsLiveAsync() { var expected = 5; var username = "******"; var reponame = "repo"; var cache = new InMemoryBlobCache(); var apiClient = Substitute.For <IApiClient>(); var modelService = CreateTarget(apiClient: apiClient, hostCache: cache); var user = CreateOctokitUser(username); apiClient.GetUser().Returns(Observable.Return(user)); apiClient.GetOrganizations().Returns(Observable.Empty <Organization>()); var act = modelService.GetAccounts().ToEnumerable().First().First(); var repo = Substitute.For <ILocalRepositoryModel>(); repo.Name.Returns(reponame); repo.Owner.Returns(user.Login); repo.CloneUrl.Returns(new UriString("https://github.com/" + username + "/" + reponame)); var indexKey = string.Format(CultureInfo.InvariantCulture, "{0}|{1}:{2}", CacheIndex.PRPrefix, user.Login, repo.Name); var prcache = Enumerable.Range(1, expected) .Select(id => CreatePullRequest(user, id, ItemState.Open, "Cache " + id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow)); // seed the cache prcache .Select(item => new ModelService.PullRequestCacheItem(item)) .Select(item => item.Save <ModelService.PullRequestCacheItem>(cache, indexKey).ToEnumerable().First()) .SelectMany(item => CacheIndex.AddAndSaveToIndex(cache, indexKey, item).ToEnumerable()) .ToList(); // expire the index var indexobj = await cache.GetObject <CacheIndex>(indexKey); indexobj.UpdatedAt = DateTimeOffset.UtcNow - TimeSpan.FromMinutes(6); await cache.InsertObject(indexKey, indexobj); var prlive = Observable.Range(1, expected) .Select(id => CreatePullRequest(user, id, ItemState.Open, "Live " + id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow)) .DelaySubscription(TimeSpan.FromMilliseconds(10)); apiClient.GetPullRequestsForRepository(user.Login, repo.Name).Returns(prlive); await modelService.InsertUser(new AccountCacheItem(user)); ITrackingCollection <IPullRequestModel> col = new TrackingCollection <IPullRequestModel>(); modelService.GetPullRequests(repo, col); col.ProcessingDelay = TimeSpan.Zero; var count = 0; var done = new ReplaySubject <Unit>(); done.OnNext(Unit.Default); done.Subscribe(); col.Subscribe(t => { if (++count == expected * 2) { done.OnCompleted(); } }, () => { }); await done; //Assert.Collection(col, col.Select(x => new Action<IPullRequestModel>(t => Assert.StartsWith("Live", x.Title))).ToArray()); }
//ConcurrentDictionary<string, ISubject<IEvent>> subjectstore = new ConcurrentDictionary<string, ISubject<IEvent>>(); public DefaultEventBus() { this._eventsource = new ReplaySubject <IEvent>(); }
/// <summary> /// Throttles the source sequence to the specified number of items, /// resetting the count each time a signal is observed /// </summary> /// <typeparam name="T"></typeparam> /// <param name="source"></param> /// <param name="signal">The signaling sequence that resets the item count</param> /// <param name="itemsForEachSignal">The maximum number of items passed through for each signal</param> /// <returns></returns> public static IObservable <T> Throttle <T>(this IObservable <T> source, IObservable <Unit> signal, int itemsForEachSignal) { var deferred = new ConcurrentQueue <T>(); var items = new ReplaySubject <T>(); var sentItems = 0; Func <T, bool> send = fm => { if (Interlocked.Increment(ref sentItems) <= (itemsForEachSignal)) { items.OnNext(fm); return(true); } else { deferred.Enqueue(fm); return(false); } }; var signalSub = signal.Subscribe(_ => { try { Interlocked.Exchange(ref sentItems, 0); while (true) { T next; if (deferred.TryDequeue(out next)) { if (!send(next)) { break; } } else { if (deferred.IsEmpty) { break; } } } } catch (Exception e) { items.OnError(e); } }); var sourceSub = source.Subscribe(fm => { send(fm); }, error => { items.OnError(error); signalSub.Dispose(); }, onCompleted: () => { items.OnCompleted(); signalSub.Dispose(); }); return(items); }
/// <summary> /// Gather information about valid plugins inside the selected directory /// </summary> /// <param name="pluginDirectory">Directory containing the plugins to gather info from. Usually BepInEx directory inside game root.</param> /// <param name="cancellationToken">Token used to abort the search</param> public static IObservable <PluginInfo> TryLoadPlugins(string pluginDirectory, CancellationToken cancellationToken) { var subject = new ReplaySubject <PluginInfo>(); if (!Directory.Exists(pluginDirectory) || cancellationToken.IsCancellationRequested) { subject.OnCompleted(); return(subject); } void ReadPluginsAsync() { try { var files = Directory.EnumerateFiles(pluginDirectory, "*.*", SearchOption.TopDirectoryOnly); var bep5PluginsDir = Path.Combine(pluginDirectory, "plugins"); if (Directory.Exists(bep5PluginsDir)) { files = files.Concat(Directory.EnumerateFiles(bep5PluginsDir, "*.*", SearchOption.AllDirectories)); } foreach (var file in files) { try { var ext = Path.GetExtension(file); if (!IsValidPluginExtension(ext)) { continue; } foreach (var pluginInfo in LoadFromFile(file)) { subject.OnNext(pluginInfo); } } catch (SystemException ex) { Console.WriteLine(ex); } if (cancellationToken.IsCancellationRequested) { break; } } subject.OnCompleted(); } catch (UnauthorizedAccessException ex) { MessageBox.Show("Could not load information about plugins because access to the plugins folder was denied. Check the permissions of your plugins folder and try again.\n\n" + ex.Message, "Load plugins", MessageBoxButtons.OK, MessageBoxIcon.Warning); Console.WriteLine(ex); subject.OnError(ex); } catch (SecurityException ex) { MessageBox.Show("Could not load information about plugins because access to the plugins folder was denied. Check the permissions of your plugins folder and try again.\n\n" + ex.Message, "Load plugins", MessageBoxButtons.OK, MessageBoxIcon.Warning); Console.WriteLine(ex); subject.OnError(ex); } catch (IOException ex) { Console.WriteLine(ex); subject.OnError(ex); } } try { Task.Run((Action)ReadPluginsAsync, cancellationToken); } catch (TaskCanceledException) { } return(subject); }
public EventListener(HomeAssistantWebSocketApi owner, string type) { _owner = owner; _type = type; _events = new ReplaySubject <HomeAssistantEvent>(0, _owner._scheduler); }
private static void WriteSequenceToConsole(ReplaySubject <string> subject) { subject.Subscribe(Console.WriteLine); }
public PinViewModel() { _pin = new StringBuilder(); _pinSubject = new ReplaySubject <string>(); }
public DeltaHeightResponseObserver(ILogger logger, IPeerQueryTipRequest peerQueryTipRequest) : base(logger) { _peerQueryTipRequest = peerQueryTipRequest; ResponseMessageSubject = new ReplaySubject <IPeerClientMessageDto>(1); }
public TailViewModel([NotNull] ILogger logger, [NotNull] ISchedulerProvider schedulerProvider, [NotNull] IFileWatcher fileWatcher, [NotNull] ISelectionMonitor selectionMonitor, [NotNull] IClipboardHandler clipboardHandler, [NotNull] ISearchInfoCollection searchInfoCollection, [NotNull] IInlineViewerFactory inlineViewerFactory, [NotNull] ISetting <GeneralOptions> generalOptions, [NotNull] ISearchMetadataCollection searchMetadataCollection, [NotNull] IStateBucketService stateBucketService, [NotNull] SearchOptionsViewModel searchOptionsViewModel, [NotNull] ITailViewStateRestorer restorer, [NotNull] SearchHints searchHints, [NotNull] ITailViewStateControllerFactory tailViewStateControllerFactory, [NotNull] IThemeProvider themeProvider) { if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (schedulerProvider == null) { throw new ArgumentNullException(nameof(schedulerProvider)); } if (fileWatcher == null) { throw new ArgumentNullException(nameof(fileWatcher)); } if (selectionMonitor == null) { throw new ArgumentNullException(nameof(selectionMonitor)); } if (clipboardHandler == null) { throw new ArgumentNullException(nameof(clipboardHandler)); } if (searchInfoCollection == null) { throw new ArgumentNullException(nameof(searchInfoCollection)); } if (inlineViewerFactory == null) { throw new ArgumentNullException(nameof(inlineViewerFactory)); } if (generalOptions == null) { throw new ArgumentNullException(nameof(generalOptions)); } if (searchMetadataCollection == null) { throw new ArgumentNullException(nameof(searchMetadataCollection)); } if (stateBucketService == null) { throw new ArgumentNullException(nameof(stateBucketService)); } if (searchOptionsViewModel == null) { throw new ArgumentNullException(nameof(searchOptionsViewModel)); } if (searchHints == null) { throw new ArgumentNullException(nameof(searchHints)); } if (themeProvider == null) { throw new ArgumentNullException(nameof(themeProvider)); } Name = fileWatcher.FullName; SelectionMonitor = selectionMonitor; SearchOptions = searchOptionsViewModel; SearchHints = searchHints; CopyToClipboardCommand = new Command(() => clipboardHandler.WriteToClipboard(selectionMonitor.GetSelectedText())); OpenFileCommand = new Command(() => Process.Start(fileWatcher.FullName)); OpenFolderCommand = new Command(() => Process.Start(fileWatcher.Folder)); CopyPathToClipboardCommand = new Command(() => clipboardHandler.WriteToClipboard(fileWatcher.FullName)); UnClearCommand = new Command(fileWatcher.Reset); ClearCommand = new Command(fileWatcher.Clear); KeyAutoTail = new Command(() => { AutoTail = true; }); SearchCollection = new SearchCollection(searchInfoCollection, schedulerProvider); SearchMetadataCollection = searchMetadataCollection; var horizonalScrollArgs = new ReplaySubject <TextScrollInfo>(1); HorizonalScrollChanged = args => horizonalScrollArgs.OnNext(args); _tailViewStateControllerFactory = tailViewStateControllerFactory; //Move these 2 highlight fields to a service as all views require them UsingDarkTheme = generalOptions.Value .ObserveOn(schedulerProvider.MainThread) .Select(options => options.Theme == Theme.Dark) .ForBinding(); HighlightTail = generalOptions.Value .ObserveOn(schedulerProvider.MainThread) .Select(options => options.HighlightTail) .ForBinding(); //this deals with state when loading the system at start up and at shut-down _persister = new TailViewPersister(this, restorer); //An observable which acts as a scroll command var autoChanged = this.WhenValueChanged(vm => vm.AutoTail); var scroller = _userScrollRequested.CombineLatest(autoChanged, (user, auto) => { var mode = AutoTail ? ScrollReason.Tail : ScrollReason.User; return(new ScrollRequest(mode, user.PageSize, user.FirstIndex)); }) .Do(x => logger.Info("Scrolling to {0}/{1}", x.FirstIndex, x.PageSize)) .DistinctUntilChanged(); FileStatus = fileWatcher.Status.ForBinding(); //command to add the current search to the tail collection var searchInvoker = SearchHints.SearchRequested.Subscribe(request => searchInfoCollection.Add(request.Text, request.UseRegEx)); //User feedback to show file size FileSizeText = fileWatcher.Latest.Select(fn => fn.Size) .Select(size => size.FormatWithAbbreviation()) .DistinctUntilChanged() .ForBinding(); //tailer is the main object used to tail, scroll and filter in a file var selectedProvider = SearchCollection.Latest.ObserveOn(schedulerProvider.Background); var lineScroller = new LineScroller(selectedProvider, scroller); MaximumChars = lineScroller.MaximumLines() .ObserveOn(schedulerProvider.MainThread) .ForBinding(); //load lines into observable collection var lineProxyFactory = new LineProxyFactory(new TextFormatter(searchMetadataCollection), new LineMatches(searchMetadataCollection), horizonalScrollArgs.DistinctUntilChanged(), themeProvider); var loader = lineScroller.Lines.Connect() .LogChanges(logger, "Received") .Transform(lineProxyFactory.Create, new ParallelisationOptions(ParallelType.Ordered, 3)) .LogChanges(logger, "Sorting") .Sort(SortExpressionComparer <LineProxy> .Ascending(proxy => proxy)) .ObserveOn(schedulerProvider.MainThread) .Bind(out _data, 100) .LogChanges(logger, "Bound") .DisposeMany() .LogErrors(logger) .Subscribe(); //monitor matching lines and start index, Count = searchInfoCollection.All.Select(latest => latest.Count).ForBinding(); CountText = searchInfoCollection.All.Select(latest => $"{latest.Count.ToString("##,###")} lines").ForBinding(); LatestCount = SearchCollection.Latest.Select(latest => latest.Count).ForBinding(); ////track first visible index var firstIndexMonitor = lineScroller.Lines.Connect() .Buffer(TimeSpan.FromMilliseconds(25)).FlattenBufferResult() .ToCollection() .Select(lines => lines.Count == 0 ? 0 : lines.Select(l => l.Index).Max() - lines.Count + 1) .ObserveOn(schedulerProvider.MainThread) .Subscribe(first => { FirstIndex = first; }); //Create objects required for inline viewing var isUserDefinedChanged = SearchCollection.WhenValueChanged(sc => sc.Selected) .Where(selected => selected != null) .Select(selected => selected.IsUserDefined) .DistinctUntilChanged() .Replay(1) .RefCount(); var showInline = this.WhenValueChanged(vm => vm.ShowInline); var inlineViewerVisible = isUserDefinedChanged.CombineLatest(showInline, (userDefined, showInlne) => userDefined && showInlne); CanViewInline = isUserDefinedChanged.ForBinding(); InlineViewerVisible = inlineViewerVisible.ForBinding(); //return an empty line provider unless user is viewing inline - this saves needless trips to the file var inline = searchInfoCollection.All.CombineLatest(inlineViewerVisible, (index, ud) => ud ? index : new EmptyLineProvider()); InlineViewer = inlineViewerFactory.Create(inline, this.WhenValueChanged(vm => vm.SelectedItem), searchMetadataCollection); _cleanUp = new CompositeDisposable(lineScroller, loader, firstIndexMonitor, FileStatus, Count, LatestCount, FileSizeText, CanViewInline, InlineViewer, InlineViewerVisible, SearchCollection, searchInfoCollection, HighlightTail, UsingDarkTheme, searchHints, searchMetadataCollection, SelectionMonitor, SearchOptions, searchInvoker, MaximumChars, _stateMonitor, horizonalScrollArgs.SetAsComplete(), _userScrollRequested.SetAsComplete()); }
public void ReplaySubjectRxOfficial() { // OnCompletedPattern { var subject = new ReplaySubject <int>(); var onNext = new List <int>(); var exception = new List <Exception>(); int onCompletedCallCount = 0; var _ = subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); subject.OnNext(1000); onNext.Is(1, 10, 100, 1000); // replay subscription onNext.Clear(); _.Dispose(); subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Is(1, 10, 100, 1000); subject.OnCompleted(); onCompletedCallCount.Is(1); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); onNext.Count.Is(4); subject.OnCompleted(); subject.OnError(new Exception()); exception.Count.Is(0); onCompletedCallCount.Is(1); // ++subscription onNext.Clear(); onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Is(1, 10, 100, 1000); exception.Count.Is(0); onCompletedCallCount.Is(1); } // OnErrorPattern { var subject = new ReplaySubject <int>(); var onNext = new List <int>(); var exception = new List <Exception>(); int onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); subject.OnNext(1000); onNext.Is(1, 10, 100, 1000); subject.OnError(new Exception()); exception.Count.Is(1); subject.OnNext(1); subject.OnNext(10); subject.OnNext(100); onNext.Count.Is(4); subject.OnCompleted(); subject.OnError(new Exception()); exception.Count.Is(1); onCompletedCallCount.Is(0); // ++subscription onNext.Clear(); exception.Clear(); onCompletedCallCount = 0; subject.Subscribe(x => onNext.Add(x), x => exception.Add(x), () => onCompletedCallCount++); onNext.Is(1, 10, 100, 1000); exception.Count.Is(1); onCompletedCallCount.Is(0); } }
public MixViewModel(Mix mixModel, IPlaybackController playbackController, IMediaLibraryBrowser mediaLibraryBrowser, IObservable <bool> userLoggedInObservable) { mixModel.CurrentTrackIndexObservable.Subscribe(x => { // if we're playing a track that has already been added CurrentTrackIndex = x; UpdateCurrentTrackIndicator(); }); mixModel.LikedByCurrentUserObservable.Subscribe(x => LikedByCurrentUser = x); this.Model = mixModel; Play = ReactiveCommand.Create(_ => true); Play.Subscribe(_ => playbackController.Play(Model)); ToggleLike = Model != Mix.NoMixAvailable ? new ReactiveAsyncCommand(userLoggedInObservable, 1) : new ReactiveAsyncCommand(Observable.Return(false), 1); ToggleLike.RegisterAsyncAction(_ => mediaLibraryBrowser.ToggleLike(Model)); this.isUserRequested = ConfigurationManager.AppSettings["AudioPlayer"] == null || !ConfigurationManager.AppSettings["AudioPlayer"].Equals("DirectX WMI 3.14169"); ReplaySubject <bool> skippingSongAllowed = new ReplaySubject <bool>(1); //skipping not allowed if there are no tracks in the mix Model.CurrentTrackIndexObservable.Select(trackIndex => trackIndex < Model.Tracks.Count && trackIndex >= 0 ? Model.Tracks[trackIndex].IsSkipAllowed : false).Subscribe(skippingSongAllowed.OnNext); NextSong = new ReactiveAsyncCommand(skippingSongAllowed, 1); NextSong.RegisterAsyncAction(_ => { try { playbackController.NextSong(isUserRequested); } catch (Exception e) { log.Error("Unable to go to the next song", e); } }); Tracks = new DispatchedReactiveCollection <TrackViewModel>(); // merge current items and future ones Observable.Merge(Model.Tracks.ToObservable(), Model.Tracks.ItemsAdded) .Select(CreateTrackViewModel) .Subscribe(trackViewModel => { Tracks.Add(trackViewModel); UpdateCurrentTrackIndicator(); }); Download = ReactiveCommand.Create(_ => Model != Mix.NoMixAvailable); Download.Subscribe(_ => { string destinationFolder = FileSystemBrowser.GetSaveToDirectory(); if (String.IsNullOrEmpty(destinationFolder)) { return; } destinationFolder += Path.DirectorySeparatorChar + Model.Name; FileSystemBrowser.TryCreateDirectory(destinationFolder); Tracks // .Where( // trackViewModel => // trackViewModel.TrackLocation.Equals(FileLocation.Online.ToString())) .ToObservable() .Subscribe(trackViewModel => SaveTrack(trackViewModel, destinationFolder)); }); FileSystemBrowser = new FileSystemBrowser(); WebAccessProxy = new WebAccessProxy(); // _TotalNumberOfTracks = Tracks.CollectionCountChanged // .ToProperty(this, x => x.TotalNumberOfTracks); CurrentTrackIndexAsString = "0"; skippingSongAllowed.OnNext(false); }
static void Main(string[] args) { Console.WriteLine("Linq, ToObservable"); Console.WriteLine("===================="); var enumerable = new List <int> { 1, 2, 3 }; var observable = enumerable.ToObservable(); observable .Where(i => i < 3) .Sum() .Subscribe(Console.WriteLine); Console.WriteLine(""); Console.WriteLine("Observable.Never, Automatic end Task"); Console.WriteLine("=========================================="); var neverObservable = Observable.Never <int>(); //Same var subjectNever = new Subject <int>(); Console.WriteLine(""); Console.WriteLine("Observable.Empty, Manual end Task"); Console.WriteLine("=========================================="); var emptyObservable = Observable.Empty <int>(); //Same var subjectEmpty = new Subject <int>(); subjectEmpty.OnCompleted(); Console.WriteLine(""); Console.WriteLine("Observable.Return, Automatic Return and end Task"); Console.WriteLine("======================================================="); var returnObservable = Observable.Return(1); returnObservable.Subscribe(iterator => Console.WriteLine("Observable.Return Iterator : " + iterator)); //Same var subjectReturn = new ReplaySubject <int>(); subjectReturn.OnNext(1); subjectReturn.OnCompleted(); returnObservable.Subscribe(iterator => Console.WriteLine("Same subjectReturn Iterator : " + iterator)); Console.WriteLine(""); Console.WriteLine("Observable.Throw, return Error"); Console.WriteLine("======================================================="); var throwObservable = Observable.Throw <int>(new Exception("throwObservable")); //throwObservable.Subscribe(iterator => Console.WriteLine(iterator)); //Same var subjectThrow = new ReplaySubject <int>(); subjectThrow.OnError(new Exception("subjectThrow")); //subjectThrow.Subscribe(iterator => Console.WriteLine(iterator)); Console.WriteLine(""); Console.WriteLine("Create"); Console.WriteLine("======================================================="); // Subject var subject = new ReplaySubject <int>(); subject.OnNext(1); subject.OnNext(2); subject.OnCompleted(); // Same var enumerableCreate = new List <int> { 1, 2 }; var observableEnumeration = enumerableCreate.ToObservable(); observableEnumeration.Subscribe(iterator => Console.WriteLine("ToObservable Iterator : " + iterator)); // Same var created = Observable.Create <int>(observable => { observable.OnNext(1); observable.OnNext(2); observable.OnCompleted(); return(() => { }); }); created.Subscribe(iterator => Console.WriteLine("Observable.Create Iterator : " + iterator)); Console.WriteLine(""); Console.WriteLine("Range"); Console.WriteLine("======================================================="); var rangeObservable = Observable.Range(0, 10); rangeObservable.Subscribe(iterator => Console.WriteLine("Observable.Range Iterator : " + iterator)); //Same var createObservable = Observable.Create <int>(observable => { for (var i = 0; i < 10; i++) { observable.OnNext(i); } observable.OnCompleted(); return(() => { }); }); createObservable.Subscribe(iterator => Console.WriteLine("Observable.Create Iterator : " + iterator)); //Same var forObservable = Observable.Generate(0, i => i < 10, i => i + 1, i => i); forObservable.Subscribe(iterator => Console.WriteLine("Observable.Generate Iterator : " + iterator)); Console.WriteLine(""); Console.WriteLine("Time"); Console.WriteLine("======================================================="); var timeObserver = Observable.Interval(TimeSpan.FromSeconds(1)); //timeObserver.Subscribe(iterator => Console.WriteLine("Observable.Interval Iterator : " + iterator)); //Same var timerObserver = Observable.Timer(TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(1)); //timerObserver.Subscribe(iterator => Console.WriteLine("Observable.Timer Iterator : " + iterator)); Console.WriteLine(""); Console.WriteLine("Async"); Console.WriteLine("======================================================="); var asyncObservable = Observable.ToAsync <string, int, string>(FunctionThatTakesALongTime)("ToAsync", 2); asyncObservable.Subscribe(r => Console.WriteLine("Observable.ToAsync Result : " + r)); var asyncObservable2 = Observable.ToAsync <string, int, string>(FunctionThatTakesALongTime)("ToAsync", 10); asyncObservable2.Subscribe(r => Console.WriteLine("Observable.ToAsync Result2 : " + r)); WebRequest request = WebRequest.Create(urlEmployeesApi); var responseObservable = Observable.ToAsync <WebResponse>(request.GetResponse)(); responseObservable.Subscribe(response => { using (Stream dataStream = response.GetResponseStream()) { StreamReader reader = new StreamReader(dataStream); string responseFromServer = reader.ReadToEnd(); Console.WriteLine("responseObservable : " + responseFromServer); } }, (err) => { Console.WriteLine("responseObservable : " + err.Message); }); Console.ReadLine(); }
public DeltaHistoryResponseObserver(ILogger logger, IPeerDeltaHistoryRequest deltaHistoryRequest) : base(logger) { _deltaHistoryRequest = deltaHistoryRequest; ResponseMessageSubject = new ReplaySubject <IPeerClientMessageDto>(1); }
public CpuUsageProvider(PulseConfiguration pulseConfig) { _dataStream = new ReplaySubject <ProcessData>(); }
public HotObservable(Action <ReplaySubject <T> > work, IScheduler scheduler) { subject = new ReplaySubject <T> (scheduler); scheduler_disposable = scheduler.Schedule(() => work(subject)); }
public DataRepository() { //give the current value if there's any(including null) _subject = new ReplaySubject <T>(1); _single = Observable.Throw <T>(new InvalidOperationException($"Value is not set yet for {GetType().Name}")); }