Beispiel #1
0
        protected async override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);

            eventHandlers
            .Add <CurrencyCreated>(this)
            .Add <CurrencyDefaultChanged>(this)
            .Add <CurrencyExchangeRateSet>(this)
            .Add <CurrencyExchangeRateRemoved>(this)
            .Add <CurrencySymbolChanged>(this)
            .Add <CurrencyDeleted>(this);

            CurrencyParameter parameter = (CurrencyParameter)e.Parameter;

            IEnumerable <CurrencyModel> models = await queryDispatcher.QueryAsync(new ListAllCurrency());

            ViewModel = new CurrencyListViewModel(navigator);

            foreach (CurrencyModel model in models)
            {
                ViewModel.Items.Add(new CurrencyEditViewModel(navigator, commandDispatcher, messageBuilder, queryDispatcher, model.UniqueCode, model.Symbol));
            }

            UpdateStandalone();

            CurrencyModel defaultModel = models.FirstOrDefault(c => c.IsDefault);

            if (defaultModel != null)
            {
                UpdateDefaultCurrency(defaultModel.UniqueCode);
            }

            ContentLoaded?.Invoke(this, EventArgs.Empty);
        }
Beispiel #2
0
        public static UiThreadEventHandler <T> AddUiThread <T>(this IEventHandlerCollection handlers, IEventHandler <T> handler, CoreDispatcher synchronizer)
        {
            Ensure.NotNull(handlers, "handlers");
            UiThreadEventHandler <T> threadHandler = new UiThreadEventHandler <T>(handler, synchronizer);

            handlers.Add <T>(threadHandler);
            return(threadHandler);
        }
        /// <summary>
        /// Returns continuation task that is completed when <paramref name="eventHandlers"/> gets
        /// notification for event of the type <typeparamref name="T"/> and <paramref name="filter"/> is satisfied.
        /// </summary>
        /// <typeparam name="T">The type of the event (can contain <see cref="Envelope"/> or <see cref="IEventHandlerContext{T}"/>).</typeparam>
        /// <param name="eventHandlers">The collection of an event handlers.</param>
        /// <param name="filter">The event filter, only the event for which returns true is used to complete the task.</param>
        /// <param name="token">The continuation task cancellation token.</param>
        /// <returns>
        /// Continuation task that is completed when <paramref name="eventHandlers"/> gets
        /// notification for event of the type <typeparamref name="T"/> and <paramref name="filter"/> is satisfied.
        /// </returns>
        public static Task <T> Await <T>(this IEventHandlerCollection eventHandlers, Func <T, bool> filter, CancellationToken token)
        {
            Ensure.NotNull(eventHandlers, "eventHandlers");
            Ensure.NotNull(filter, "filter");
            Ensure.NotNull(token, "token");

            TaskCompletionSource <T> source = new TaskCompletionSource <T>();

            eventHandlers.Add(new AwaitEventHandler <T>(eventHandlers, source, token, filter));

            return(source.Task);
        }