private async void RequestTypes() { if (Property == null) { return; } if (Editors.Count == 0) { SuggestedTypes = new ObservableCollectionEx <ITypeInfo> (); AssignableTypes = new AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > ( Task.FromResult <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > ( new Dictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > ())); SelectedType = null; return; } var types = Editors.GetCommonAssignableTypes(Property, childTypes: true); var assignableTypesTask = types.ContinueWith(t => t.Result.GetTypeTree(), TaskScheduler.Default); AssignableTypes = new AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > (assignableTypesTask); var results = await types; var suggested = new ObservableCollectionEx <ITypeInfo> (results.SuggestedTypes); if (results.AssignableTypes.Count > suggested.Count) { suggested.Add(OtherType); } SuggestedTypes = suggested; SelectedType = (results.SuggestedTypes.Count > 0) ? results.SuggestedTypes[0] : null; }
public ObjectTreeElement(IEditorProvider provider, IObjectEditor editor) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } if (editor == null) { throw new ArgumentNullException(nameof(editor)); } Editor = editor; Children = new AsyncValue <IReadOnlyList <ObjectTreeElement> > (QueryChildrenAsync(provider)); string typeName = $"[{Editor.TargetType.Name}]"; Task <string> nameTask; INameableObject nameable = Editor as INameableObject; if (nameable != null) { nameTask = nameable.GetNameAsync().ContinueWith(t => (!String.IsNullOrWhiteSpace(t.Result)) ? $"{typeName} \"{t.Result}\"" : typeName, TaskScheduler.Default); } else { nameTask = Task.FromResult(typeName); } Name = new AsyncValue <string> (nameTask, typeName); }
public void SyncException() { var asyncValue = new AsyncValue <int>(SyncErrorInput); Assert.AreEqual(LoadState.Unloaded, asyncValue.State); Assert.AreEqual(default(int), asyncValue.Value); var loadHappened = false; asyncValue.ValueLoaded += (sender, args) => { loadHappened = true; }; var errorHappened = false; asyncValue.LoadError += (sender, args) => { errorHappened = true; }; asyncValue.Load(); Assert.IsFalse(loadHappened); Assert.IsTrue(errorHappened); }
public CreateBindingViewModel(TargetPlatform platform, IObjectEditor targetEditor, IPropertyInfo property, PropertyVariation variations = null) : base(platform) { if (platform == null) { throw new ArgumentNullException(nameof(platform)); } if (targetEditor == null) { throw new ArgumentNullException(nameof(targetEditor)); } if (platform.BindingProvider == null) { throw new ArgumentException("Null BindingProvider on TargetPlatform", nameof(platform)); } if (property == null) { throw new ArgumentNullException(nameof(property)); } this.editorProvider = platform.EditorProvider; this.targetEditor = targetEditor; this.property = property; this.provider = platform.BindingProvider; this.variations = variations; PropertyDisplay = String.Format(Resources.CreateDataBindingTitle, $"[{this.targetEditor.TargetType.Name}].{property.Name}"); RequestNamedDisplay(); BindingSources = new AsyncValue <IReadOnlyList <BindingSource> > ( platform.BindingProvider.GetBindingSourcesAsync(targetEditor.Target, property)); RequestBindingObject(); }
public void AsyncValueException() { var tcs = new TaskCompletionSource <bool> (); var asyncValue = new AsyncValue <bool> (tcs.Task, defaultValue: true, scheduler: new SyncScheduler()); Assume.That(asyncValue.Value, Is.True); bool valueChanged = false, runningChanged = false; asyncValue.PropertyChanged += (sender, args) => { if (args.PropertyName == nameof(AsyncValue <string> .Value)) { valueChanged = true; } else if (args.PropertyName == nameof(AsyncValue <string> .IsRunning)) { runningChanged = true; } }; tcs.SetException(new Exception()); Assert.That(asyncValue.Value, Is.True); Assert.That(valueChanged, Is.False, "Value should not signal change when there's an exception"); Assert.That(asyncValue.IsRunning, Is.False); Assert.That(runningChanged, Is.True); }
public TypeSelectorViewModel(AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { if (assignableTypes == null) { throw new ArgumentNullException(nameof(assignableTypes)); } assignableTypes.Task.ContinueWith(t => { this.typeOptions = new SimpleCollectionViewOptions { DisplaySelector = (o) => ((ITypeInfo)o).Name }; this.assemblyView = new SimpleCollectionView(t.Result, this.assemblyOptions = new SimpleCollectionViewOptions { Filter = AssemblyFilter, DisplaySelector = (o) => ((KeyValuePair <IAssemblyInfo, ILookup <string, ITypeInfo> >)o).Key.Name, ChildrenSelector = (o) => ((KeyValuePair <IAssemblyInfo, ILookup <string, ITypeInfo> >)o).Value, ChildOptions = new SimpleCollectionViewOptions { DisplaySelector = (o) => ((IGrouping <string, ITypeInfo>)o).Key, ChildrenSelector = (o) => ((IGrouping <string, ITypeInfo>)o), ChildOptions = this.typeOptions } }); OnPropertyChanged(nameof(Types)); IsLoading = false; }, TaskScheduler.FromCurrentSynchronizationContext()); }
public void IsRunning() { var tcs = new TaskCompletionSource <string> (); var asyncValue = new AsyncValue <string> (tcs.Task, scheduler: new SyncScheduler()); Assume.That(asyncValue.Value, Is.Null); Assert.That(asyncValue.IsRunning, Is.True); bool changed = false; asyncValue.PropertyChanged += (sender, args) => { if (args.PropertyName == nameof(AsyncValue <string> .IsRunning)) { changed = true; } }; const string value = "value"; tcs.SetResult(value); Assume.That(asyncValue.Value, Is.EqualTo(value)); Assert.That(asyncValue.IsRunning, Is.False, "IsRunning did not flip to false"); Assert.That(changed, Is.True, "PropertyChanged did not fire for IsRunning"); }
public void DefaultValue() { var tcs = new TaskCompletionSource <bool> (); var value = new AsyncValue <bool> (tcs.Task, defaultValue: true, scheduler: new SyncScheduler()); Assert.That(value.Value, Is.True); }
private void RunSearch(string value) { if (String.IsNullOrWhiteSpace(value)) { return; } SearchResults = new AsyncValue <IEnumerable <Person> > (this.client.SearchAsync(value), Enumerable.Empty <Person>()); }
public void BasicAsync() { var asyncValue = new AsyncValue<int>(AsyncTestInput); Assert.AreEqual(LoadState.Unloaded, asyncValue.State); Assert.AreEqual(default(int), asyncValue.Value); asyncValue.ValueLoaded += (sender, args) => asyncValue_handleLoad(asyncValue); asyncValue.Load(); Assert.AreEqual(LoadState.Loading, asyncValue.State); }
public AddBuddyViewModel(SocialClient client) { if (client == null) throw new ArgumentNullException ("client"); this.client = client; this.addBuddy = new RelayCommand<Person> (OnAddBuddy, CanAddBuddy); this.searchResults = new AsyncValue<IEnumerable<Person>> ( Task.FromResult (Enumerable.Empty<Person>()), Enumerable.Empty<Person>()); }
public void ValueReplacesDefaultValue(bool value) { var tcs = new TaskCompletionSource <bool> (); var asyncValue = new AsyncValue <bool> (tcs.Task, defaultValue: !value, scheduler: new SyncScheduler()); Assume.That(asyncValue.Value, Is.EqualTo(!value)); tcs.SetResult(value); Assert.That(asyncValue.Value, Is.EqualTo(value)); }
public void BasicAsync() { var asyncValue = new AsyncValue <int>(AsyncTestInput); Assert.AreEqual(LoadState.Unloaded, asyncValue.State); Assert.AreEqual(default(int), asyncValue.Value); asyncValue.ValueLoaded += (sender, args) => asyncValue_handleLoad(asyncValue); asyncValue.Load(); Assert.AreEqual(LoadState.Loading, asyncValue.State); }
public static ITypeInfo RequestType(AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { var w = new TypeSelectorWindow(new TypeSelectorViewModel(assignableTypes)); var result = (NSModalResponse)(int)NSApplication.SharedApplication.RunModalForWindow(w); if (result != NSModalResponse.OK) { return(null); } return(w.selector.ViewModel.SelectedType); }
public void BasicSynchronous() { var asyncValue = new AsyncValue<int>(SyncTestInput); Assert.AreEqual(LoadState.Unloaded, asyncValue.State); Assert.AreEqual(default(int), asyncValue.Value); var loadHappened = false; asyncValue.ValueLoaded += (sender, args) => { loadHappened = true; }; asyncValue.Load(); Assert.IsTrue(loadHappened); }
public MainWindowViewModel ([NotNull] GablarskiSocialClient client) { if (client == null) throw new ArgumentNullException ("client"); this.client = client; this.buddyListViewModel = new BuddyListViewModel (client); this.onlineFilter = new ObservableFilter<Person, WatchList> (this.client.WatchList, p => p.Status != Status.Offline); Servers = new AsyncValue<IEnumerable<ServerEntry>> (ClientData.GetServersAsync(), Enumerable.Empty<ServerEntry>()); AddBuddy = new RelayCommand (() => Messenger.Send (new AddBuddyMessage())); StartChat = new RelayCommand<Person> (OnStartChat); }
public void BasicSynchronous() { var asyncValue = new AsyncValue <int>(SyncTestInput); Assert.AreEqual(LoadState.Unloaded, asyncValue.State); Assert.AreEqual(default(int), asyncValue.Value); var loadHappened = false; asyncValue.ValueLoaded += (sender, args) => { loadHappened = true; }; asyncValue.Load(); Assert.IsTrue(loadHappened); }
public MainWindowViewModel([NotNull] GablarskiSocialClient client) { if (client == null) { throw new ArgumentNullException("client"); } this.client = client; this.buddyListViewModel = new BuddyListViewModel(client); this.onlineFilter = new ObservableFilter <Person, WatchList> (this.client.WatchList, p => p.Status != Status.Offline); Servers = new AsyncValue <IEnumerable <ServerEntry> > (ClientData.GetServersAsync(), Enumerable.Empty <ServerEntry>()); AddBuddy = new RelayCommand(() => Messenger.Send(new AddBuddyMessage())); StartChat = new RelayCommand <Person> (OnStartChat); }
internal static ITypeInfo RequestType(FrameworkElement owner, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { Window hostWindow = Window.GetWindow(owner); var w = new TypeSelectorWindow(owner.Resources.MergedDictionaries, assignableTypes) { Owner = hostWindow, }; if (!w.ShowDialog() ?? false) { return(null); } return(((TypeSelectorViewModel)w.DataContext).SelectedType); }
public AddValueConverterViewModel(TargetPlatform platform, object target, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) : base(assignableTypes) { if (platform == null) { throw new ArgumentNullException(nameof(platform)); } if (target == null) { throw new ArgumentNullException(nameof(target)); } this.platform = platform; this.target = target; this.source = GetDefaultResourceSourceAsync(); }
private async void RequestUpdateSources() { Task task = null; switch (SelectedBindingSource.Type) { case BindingSourceType.SingleObject: case BindingSourceType.Object: SelectedObjectTreeElement = null; ObjectElementRoots = new AsyncValue <IReadOnlyList <ObjectTreeElement> > (GetRootElementsAsync()); task = ObjectElementRoots.Task; break; case BindingSourceType.Type: TypeSelector = new TypeSelectorViewModel(new AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > (GetBindingSourceTypesAsync())); break; case BindingSourceType.Resource: SelectedResource = null; SourceResources = new AsyncValue <ILookup <ResourceSource, Resource> > (GetSourceResourcesAsync()); break; } if (task != null) { await task; } switch (SelectedBindingSource.Type) { case BindingSourceType.SingleObject: case BindingSourceType.Object: if (ObjectElementRoots.Value.Count == 1) { var root = ObjectElementRoots.Value[0]; var children = await root.Children.Task; if (children.Count == 0) { SelectedObjectTreeElement = root; } } break; } UpdateShowProperties(); OnPropertyChanged(nameof(ShowLongDescription)); }
public void When_the_same_message_is_handled_by_multiple_consequenters_it_is_delivered_to_each_only_once() { var aggregateId = Any.Guid(); var consequenter1WasCalled = new AsyncValue <bool>(); var consequenter2WasCalled = new AsyncValue <bool>(); var consequenter1CallCount = 0; var consequenter2CallCount = 0; var consequenter1 = Consequenter.Create <Order.Fulfilled>(e => { if (e.AggregateId == aggregateId) { Interlocked.Increment(ref consequenter1CallCount); consequenter1WasCalled.Set(true); } }) .Named(MethodBase.GetCurrentMethod().Name + "-1") .UseServiceBusForDurability(settings, configuration: configuration); var consequenter2 = Consequenter.Create <Order.Fulfilled>(e => { if (e.AggregateId == aggregateId) { Interlocked.Increment(ref consequenter2CallCount); consequenter2WasCalled.Set(true); } }) .Named(MethodBase.GetCurrentMethod().Name + "-2") .UseServiceBusForDurability(settings, configuration: configuration); using (var catchup = CreateReadModelCatchup <CommandSchedulerDbContext>(consequenter1, consequenter2)) { Events.Write(1, i => new Order.Fulfilled { AggregateId = aggregateId }); catchup.Run(); // give the service bus messages times to be delivered Task.WaitAll(new Task[] { consequenter1WasCalled, consequenter2WasCalled }, DefaultTimeout()); consequenter1CallCount.Should().Be(1); consequenter2CallCount.Should().Be(1); } }
internal static ITypeInfo RequestType(PropertyEditorPanel owner, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { Window hostWindow = Window.GetWindow(owner); var w = new TypeSelectorWindow(owner.Resources.MergedDictionaries, assignableTypes) { Owner = hostWindow, }; w.Resources.MergedDictionaries.AddItems(owner.Resources.MergedDictionaries); if (!w.ShowDialog() ?? false) { return(null); } return(w.tree.SelectedItem as ITypeInfo); }
public async Task Catchup_can_be_used_with_intercepted_consequenters_to_queue_event_messages_on_the_service_bus() { var onCancelledCalled = new AsyncValue <bool>(); var onCreatedCalled = new AsyncValue <bool>(); var onDeliveredCalled = new AsyncValue <bool>(); var anonymousConsequenterCalled = new AsyncValue <bool>(); var consequenter1 = new TestConsequenter( onCancelled: e => onCancelledCalled.Set(true), onCreated: e => onCreatedCalled.Set(true), onDelivered: e => onDeliveredCalled.Set(true)) .UseServiceBusForDurability(settings, configuration: configuration); var name = MethodBase.GetCurrentMethod().Name; var consequenter2 = Consequenter.Create <Order.Fulfilled>(e => anonymousConsequenterCalled.Set(true)) .Named(name) .UseServiceBusForDurability(settings, configuration: configuration); using (var catchup = CreateReadModelCatchup <CommandSchedulerDbContext>( consequenter1, consequenter2)) { Events.Write(1, i => new Order.Created()); Events.Write(1, i => new Order.Delivered()); Events.Write(1, i => new Order.Fulfilled()); Events.Write(1, i => new Order.Cancelled()); catchup.Run(); // give the service bus messages times to be delivered Task.WaitAll(new Task[] { onCancelledCalled, onCreatedCalled, onDeliveredCalled, anonymousConsequenterCalled }, DefaultTimeout()); onCancelledCalled.Result.Should().Be(true); onCreatedCalled.Result.Should().Be(true); onDeliveredCalled.Result.Should().Be(true); anonymousConsequenterCalled.Result.Should().Be(true); } }
protected override void OnAddEditors(IEnumerable <EditorViewModel> editors) { base.OnAddEditors(editors); ValueConverters = new AsyncValue <IReadOnlyList <Resource> > (GetValueConvertersAsync()); var flags = new List <EditorViewModel> (); var regular = new List <EditorViewModel> (); // We do not support grouped properties here foreach (EditorViewModel vm in Properties) { var propvm = vm as PropertyViewModel; if (propvm == null) { continue; } if (BindingEditor.KnownProperties.ContainsKey(propvm.Property)) { continue; } if (propvm.Property.Type == typeof(bool)) { flags.Add(vm); } else { regular.Add(vm); } } BindingProperties = regular; FlagsProperties = flags; BindingSources.Task.ContinueWith(t => { SelectedBindingSource = t.Result.FirstOrDefault(); }, TaskScheduler.FromCurrentSynchronizationContext()); OnPropertyChanged(nameof(Path)); OnPropertyChanged(nameof(SelectedValueConverter)); OnPropertyChanged(nameof(ShowTypeLevel)); }
private void RequestUpdateProperties() { SelectedPropertyElement = null; ITypeInfo type = null; switch (SelectedBindingSource.Type) { case BindingSourceType.Type: type = TypeSelector.SelectedType; break; case BindingSourceType.SingleObject: case BindingSourceType.Object: type = SelectedObjectTreeElement?.Editor.TargetType; break; case BindingSourceType.Resource: if (SelectedResource != null) { type = GetRealType(SelectedResource); } break; default: throw new InvalidOperationException(); } if (type == null) { PropertyRoot = null; return; } Task <PropertyTreeRoot> task = this.editorProvider.GetPropertiesForTypeAsync(type) .ContinueWith(t => new PropertyTreeRoot(this.editorProvider, type, t.Result), TaskScheduler.Default); PropertyRoot = new AsyncValue <PropertyTreeRoot> (task); }
public void SyncException() { var asyncValue = new AsyncValue<int>(SyncErrorInput); Assert.AreEqual(LoadState.Unloaded, asyncValue.State); Assert.AreEqual(default(int), asyncValue.Value); var loadHappened = false; asyncValue.ValueLoaded += (sender, args) => { loadHappened = true; }; var errorHappened = false; asyncValue.LoadError += (sender, args) => { errorHappened = true; }; asyncValue.Load(); Assert.IsFalse(loadHappened); Assert.IsTrue(errorHappened); }
private void RunSearch(string value) { if (String.IsNullOrWhiteSpace (value)) return; SearchResults = new AsyncValue<IEnumerable<Person>> (this.client.SearchAsync (value), Enumerable.Empty<Person>()); }
public static Task <ITypeInfo> RequestAt(this TypeRequestedEventArgs self, IHostResourceProvider hostResources, NSView source, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { var tcs = new TaskCompletionSource <ITypeInfo> (); var vm = new TypeSelectorViewModel(assignableTypes); var selector = new TypeSelectorControl { ViewModel = vm, Appearance = source.EffectiveAppearance }; vm.PropertyChanged += (vms, ve) => { if (ve.PropertyName == nameof(TypeSelectorViewModel.SelectedType)) { tcs.TrySetResult(vm.SelectedType); } }; var popover = new NSPopover { Behavior = NSPopoverBehavior.Transient, Delegate = new PopoverDelegate <ITypeInfo> (tcs), ContentViewController = new NSViewController { View = selector, PreferredContentSize = new CoreGraphics.CGSize(360, 335) }, }; popover.SetAppearance(hostResources.GetVibrantAppearance(source.EffectiveAppearance)); tcs.Task.ContinueWith(t => { popover.PerformClose(popover); popover.Dispose(); }, TaskScheduler.FromCurrentSynchronizationContext()); popover.Show(source.Frame, source.Superview, NSRectEdge.MinYEdge); return(tcs.Task); }
internal CreateValueConverterWindow(IEnumerable <ResourceDictionary> mergedResources, TargetPlatform platform, object target, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { DataContext = new AddValueConverterViewModel(platform, target, assignableTypes); InitializeComponent(); Resources.MergedDictionaries.AddItems(mergedResources); }
internal static Tuple <string, ITypeInfo, ResourceSource> RequestConverter(FrameworkElement owner, TargetPlatform platform, object target, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { Window hostWindow = Window.GetWindow(owner); var w = new CreateValueConverterWindow(owner.Resources.MergedDictionaries, platform, target, assignableTypes) { Owner = hostWindow, }; if (!w.ShowDialog() ?? false) { return(null); } var vm = (AddValueConverterViewModel)w.DataContext; return(new Tuple <string, ITypeInfo, ResourceSource> (w.converterName.Text, vm.SelectedType, vm.Source)); }
/// <summary> /// Resolve the current asynchronous value into an awaitable value. /// </summary> /// <typeparam name="T">The type of the awaitable value.</typeparam> /// <param name="self">The current asynchronous value provider.</param> /// <param name="token">A cancellation token.</param> /// <returns>An awaitable value of the specified type.</returns> public static Task <T> ResolveAsync <T>(this AsyncValue <T> self, CancellationToken token = default(CancellationToken)) { return(self.Invoke(token)); }
internal TypeSelectorWindow(IEnumerable <ResourceDictionary> mergedResources, AsyncValue <IReadOnlyDictionary <IAssemblyInfo, ILookup <string, ITypeInfo> > > assignableTypes) { DataContext = new TypeSelectorViewModel(assignableTypes); InitializeComponent(); Resources.MergedDictionaries.AddItems(mergedResources); }