public static IControl CreateDebugControl()
{
var debugControls = DebugControls
.Throttle(TimeSpan.FromMilliseconds(10));
var controls = debugControls
.CachePerElement(getKey: ctrl => ctrl.Value, getValue: ctrl => ctrl.Value.Name)
.SelectPerElement(name =>
CreateDebugItem(name, Command.Enabled(action: () => SelectedControl.OnNext(name))));
var infoPanel = SelectedControl
.CombineLatest(debugControls, (sel, ctrls) => sel.HasValue ? CreateInfoPanel(ctrls[sel.Value]) : CreateNothingSelected())
.Switch();
return(Layout.Dock()
.Left(
Layout.Dock().Top(Header("Debug Controls"))
.Fill(controls.StackFromTop().MakeScrollable())
.WithWidth(200)
.WithPadding(new Thickness <Points>(10))
)
.Left(
Layout.StackFromTop(
Header("Mount Info"),
infoPanel
).WithPadding(new Thickness <Points>(10))
)
.Fill()
.WithPadding(new Thickness <Points>(10)));
}
/// <summary>
/// Limits the rate at which the Behaviour may change value. TODO: This
/// likely violates the meaning of a Behaviour.
/// </summary>
public IObservable <A> Throttle(TimeSpan timeSpan)
{
var r = new BehaviorSubject <A>(Value);
Subject.Throttle(timeSpan).Subscribe(r);
return(r);
}
private void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
{
_AutoScrollSubscriber = AutoScrollSubeject
.Throttle(TimeSpan.FromSeconds(0.25))
.Subscribe(async _ =>
{
using (var releaser = await AutoScrollLock.LockAsync())
{
Debug.WriteLine("1");
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Debug.WriteLine("2");
ScrollToLatest();
Debug.WriteLine("3");
});
Debug.WriteLine("4");
}
}, (_) => { Debug.WriteLine("error"); }, () => { Debug.WriteLine("complete"); });
var child = AssociatedObject.Content as FrameworkElement;
if (child == null)
{
return;
}
child.SizeChanged += Child_SizeChanged;
AssociatedObject.Loaded -= AssociatedObject_Loaded;
AssociatedObject.Unloaded += AssociatedObject_Unloaded;
}
public Folder(IAccount server, string name, string shortName, string separator, bool hasChildren, bool canHaveMessages)
{
server_ = server;
name_ = name;
shortName_ = shortName;
separator_ = separator;
if (hasChildren)
{
subFolders_ = new BehaviorSubject <IEnumerable <Folder> >(new Folder[] { });
}
canHaveMessages_ = canHaveMessages;
if (canHaveMessages)
{
filterIds_ = new BehaviorSubject <IEnumerable <int> >(null);
messages_ = new BehaviorSubject <IEnumerable <MessageHeader> >(new MessageHeader[] { });
Messages = messages_.Throttle(TimeSpan.FromMilliseconds(100), Dependencies.TimeScheduler);
ViewMessages = Observable.CombineLatest(Messages, filterIds_, FilterMessages);
exists_ = new BehaviorSubject <int>(0);
recent_ = new BehaviorSubject <int>(0);
unseen_ = new BehaviorSubject <int>(0);
var msgCount = Messages.Select(msgs => msgs.Count());
// Take the value as either the number of messages in the list or
// just what the server has set for the folder.
Exists = exists_.Merge(msgCount);
var msgsUnRead = Messages.
Select((msgs) =>
{
// Build an observable list of all of the unread values.
return(Observable.CombineLatest(msgs.Select(msg => msg.UnRead)));
}).Switch(). // .. and only listen to the newest one.
Select(unreads =>
{
// .. then count up the unread values in it.
return(unreads.Where(unread => unread == true).Count());
});
// Take the value as either the number of messages with Unread set
// or just what the server has set for the folder.
Unseen = unseen_.Merge(msgsUnRead);
}
}
public void Start()
{
var watcher = new FileSystemWatcher(directory, filesMask);
watcher.Changed += OnFileChanged;
watcher.EnableRaisingEvents = true;
fileChangedSubject
.Throttle(TimeSpan.FromSeconds(1))
.Subscribe(ev =>
{
if (ev != null)
{
StartAction(ev);
}
});
}
public void ObservableThreadsWithThrottleOnCompute()
{
Console.WriteLine("Starting Thread " + Thread.CurrentThread.ManagedThreadId);
BehaviorSubject<int> s1 = new BehaviorSubject<int>(2);
BehaviorSubject<int> s2 = new BehaviorSubject<int>(3);
BehaviorSubject<int> sum = new BehaviorSubject<int>(5);
List<int> computeThreads = new List<int>();
List<int> receiveThreads = new List<int>();
IScheduler computeScheduler = new EventLoopScheduler();
IObservable<int> sumObservable = s1.Throttle(TimeSpan.FromMilliseconds(100), computeScheduler).ObserveOn(computeScheduler).CombineLatest(s2.Throttle(TimeSpan.FromMilliseconds(100), computeScheduler).ObserveOn(computeScheduler), (first, second) =>
{
Console.WriteLine("Computing value " + first + " + " + second + " = " + (first + second) + " on Thread " + Thread.CurrentThread.ManagedThreadId + ".");
computeThreads.Add(Thread.CurrentThread.ManagedThreadId);
return first + second;
});
sumObservable.Subscribe(sum.OnNext);
sum.ObserveOn(new EventLoopScheduler()).Subscribe(v =>
{
Console.WriteLine("Received value " + v + " on Thread " + Thread.CurrentThread.ManagedThreadId + ".");
receiveThreads.Add(Thread.CurrentThread.ManagedThreadId);
});
Thread.Sleep(150);
s2.OnNext(1);
Thread.Sleep(50);
s1.OnNext(4);
Thread.Sleep(150);
s2.OnNext(4);
Thread.Sleep(250);
s1.OnNext(1);
Thread.Sleep(150);
foreach (KeyValuePair<int, int> p in
computeThreads.GroupBy(v => v).Select(g => new KeyValuePair<int, int>(g.Key, g.Count())))
{
Console.WriteLine(p.Value + " computes on Thread " + p.Key);
}
foreach (KeyValuePair<int, int> p in
receiveThreads.GroupBy(v => v).Select(g => new KeyValuePair<int, int>(g.Key, g.Count())))
{
Console.WriteLine(p.Value + " receives on Thread " + p.Key);
}
}
