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}"));
}
