private void PlaceOrderAction() { try { /*ThreadingHelpers.InvokeOnMainThread(async () => * { * AppInitialiserService.SetInitialiser<ProductCataloguePageViewModel>((ProductCataloguePageViewModel vm) => * { * vm.UserDetails = UserDetails; * vm.ProductTypes = App.MasterData.ProductTypeMaster; * }); * * await AppNavigationService.GoToAsync(nameof(ProductCataloguePage).ToLower()); * });*/ ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(SupplierCataloguePage).ToLower(), (SupplierCataloguePageViewModel vm) => { vm.UserDetails = UserDetails; vm.ProductTypes = App.MasterData.ProductTypeMaster; }) ); } catch (Exception ex) { } }
private async Task DeleteProductAction(Product item) { var response = await AppPopupInputService.ShowMessageOkCancelAlertPopup("Remove Product", "Are you sure to remove product?", "OK", "CANCEL"); if (!response.Equals("ok", StringComparison.InvariantCultureIgnoreCase)) { return; } ThreadingHelpers.InvokeOnMainThread(() => { Orders.Remove(item); var orders = Orders.ToList(); Orders.Clear(); Orders = null; Orders = orders; if (IsOrderAvailable) { OrderSubmitText = "SUBMIT ORDER"; } else { OrderSubmitText = "PLACE ORDER"; OrdersHeadingText = "No order has been placed."; } } ); }
public void HideLoading() { ThreadingHelpers.InvokeOnMainThread(async() => { int retry = 0; if (_spinnerPageInstance == null) { return; } while (!_isSpinning && retry <= 5) { await Task.Delay(200); retry++; } if (_spinnerPageInstance != null) { await _navigationService.Navigation.RemovePopupPageAsync(_spinnerPageInstance, true); //await _navigationService.Navigation.PopPopupAsyncSafe(_popupNavigation, true); } _spinnerPageInstance = null; _isSpinning = false; }); }
private void AddressSuggestions_Updated(object sender, AddressSuggestionsUpdatedEventArgs eventArgs) { try { ThreadingHelpers.BeginUpdate(MyComboBox); var text = ThreadingHelpers.GetText(MyComboBox); ThreadingHelpers.ClearItems(MyComboBox); foreach (var addressSuggestions in eventArgs.AddressSuggestions) { ThreadingHelpers.AddItem(MyComboBox, addressSuggestions); } ThreadingHelpers.SetDroppedDown(MyComboBox, true); ThreadingHelpers.ClearSelection(MyComboBox); ThreadingHelpers.SetText(MyComboBox, text); ThreadingHelpers.SetSelectionStart(MyComboBox, text.Length); } catch (Exception ex) { Console.WriteLine(ex); } finally { ThreadingHelpers.EndUpdate(MyComboBox); } }
private async Task SupplierTapped(LinCUser item) { try { AppSpinner.ShowLoading(); var response = await _services.UserService.GetUserProducts(UserDetails.UserId, item.UserId, SelectedProductType.ProductTypeId); if (response.Data.Item1 != null && response.Data.Item1.Count > 0) { ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(ProductsPage).ToLower(), (ProductsPageViewModel vm) => { vm.UserDetails = App.UserDetails; vm.Products = response.Data.Item1; vm.SupplierId = item.UserId; }) ); } AppSpinner.HideLoading(); } catch (Exception ex) { } }
private void PlaceOrderAction() { if (IsOrderAvailable) { // Save to backend DB ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(UserDashboardPage).ToLower(), (UserDashboardPageViewModel vm) => { vm.UserDetails = App.UserDetails; vm.Products = this.Products; //vm.Orders = Orders.Where(o => o.IsSubmitted).ToList(); }) ); } else { ThreadingHelpers.InvokeOnMainThread(async() => { AppInitialiserService.SetInitialiser <ProductCataloguePageViewModel>((ProductCataloguePageViewModel vm) => { vm.UserDetails = UserDetails; vm.ProductTypes = App.MasterData.ProductTypeMaster; //vm.ProductList = Products; //vm.Product = new Product(); //vm.ProductTypes = App.MasterData.ProductTypeMaster; }); await AppNavigationService.GoToAsync(nameof(ProductCataloguePage).ToLower()); }); } }
private void SaveNewProductNameAction() { try { ThreadingHelpers.InvokeOnMainThread(() => { //LinCComonModel prdNameObj = new LinCComonModel() { Name = NewProductName, Value = NewProductName, ItemId = string.Empty }; //var controlValues = DefaultProductName.ControlValues.ToList(); //controlValues.Add(prdNameObj); //DefaultProductName.ControlValues.Clear(); //DefaultProductName.ControlValues = null; //DefaultProductName.ControlValues = controlValues; //DefaultProductName.DefaultItem = prdNameObj; //DefaultProductName.SelectedIndex = controlValues.Count - 1; //Product.ProductNameId = string.Empty; //Product.ProductName = prdNameObj.Name; //Product.IsNewProductName = true; NewProductName = string.Empty; ProductNameEntryVisibility = false; }); } catch (Exception) { } }
internal static async Task NavigatePopToRootAsync() { var modalCount = App.NavigationRoot.Navigation.ModalStack.Count; for (int currModal = 0; currModal < modalCount; currModal++) { ThreadingHelpers.InvokeOnMainThread(async() => await App.NavigationRoot.Navigation.PopModalAsync(false)); } }
private void CallCustomerCare() { ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(ChatPage).ToLower(), (ChatPageViewModel vm) => { vm.UserDetails = App.UserDetails; }) ); }
public void ReferencePassingTest() { var data = new DataBag(); ThreadingHelpers.ExecuteOnThread( () => data.X++, 10); Assert.Equal(10, data.X); }
private void ProductCatAction() { ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(ProductCataloguePage).ToLower(), (ProductCataloguePageViewModel vm) => { vm.UserDetails = App.UserDetails; }) ); }
private void Register() { ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(RegistrationPage).ToLower(), (RegistrationPageViewModel vm) => { //vm.UserDetails = new LinCUser(); }) ); }
private void DisplayNetworkError(ViewModelError error) { var alert = new ErrorAlert() { Description = error.Description, Title = _errorTitle, ViewModelType = this.GetType(), Severity = ViewModelError.ErrorSeverity.Warning }; ThreadingHelpers.InvokeOnMainThread(async() => await _popupInputService.ShowMessageOkAlertPopup(alert.Title, alert.Description, "OK")); }
private void IncreaseQuantityAction(Product item) { int qty = item.Quantity; qty += 1; ThreadingHelpers.InvokeOnMainThread(() => { item.Quantity = qty; item.Price = (item.UnitPrice == 0 ? 10:item.UnitPrice) * qty; }); }
private void MyComboBox_KeyPress(object sender, KeyPressEventArgs e) { if (char.IsControl(e.KeyChar)) { return; } var searchString = ThreadingHelpers.GetText(MyComboBox); if (searchString.Length > 1) { Task.Run(() => GetAddressSuggestions(searchString)); } }
public void ShowLoading(bool isCancellable = true) { ThreadingHelpers.InvokeOnMainThread(async() => { if (_spinnerPageInstance == null) { _spinnerPageInstance = new ProgressSpinnerPage(isCancellable); await _navigationService.Navigation.PushPopupAsyncSafe(_spinnerPageInstance, _popupNavigation, true) .ContinueWith((t) => _isSpinning = true); } }); }
private async Task RegisterAction() { //AppSpinner.ShowLoading(); //await GetMasterData(); //AppSpinner.HideLoading(); ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(RegistrationPage).ToLower(), (RegistrationPageViewModel vm) => { //vm.UserDetails = new LinCUser(); }) ); }
static void Main(string[] args) { // Here you can play around with those method, prototype and easily debug Console.WriteLine($"Main thread is {Thread.CurrentThread.ManagedThreadId}"); // Generate a token that's immediately cancelled CancellationTokenSource cts = new CancellationTokenSource(); cts.Cancel(); CancellationToken cancelToken = cts.Token; // new CancellationTokenSource(200).Token /* * ThreadingHelpers.ExecuteOnThread(() => * { * var thread = Thread.CurrentThread; * Console.WriteLine($"Hello from thread {thread.ManagedThreadId} from a pool: {thread.IsThreadPoolThread}"); * Thread.Sleep(1000); * //throw new StackOverflowException(); * }, 3, cancelToken, * (System.Exception exception) => { Console.WriteLine($"<{exception.Message}> occurred !"); }); */ /* * ThreadingHelpers.ExecuteOnThread( * () => throw new NullReferenceException(), * 10, * new CancellationTokenSource(1000).Token, * errorAction: (System.Exception exception) => { Console.WriteLine($"<{exception.Message}> occurred !"); }); */ /* * ThreadingHelpers.ExecuteOnThreadPool(() => * { * var thread = Thread.CurrentThread; * Console.WriteLine( * $"Hello from thread {thread.ManagedThreadId} from a pool: {thread.IsThreadPoolThread}"); * }, 3); */ ThreadingHelpers.ExecuteOnThreadPool( () => Thread.Sleep(100), 3, cancelToken, errorAction: (System.Exception exception) => { Console.WriteLine($"<{exception.Message}> occurred !"); } ); }
private async Task SubmitProductsAction() { if (Products == null || Products.Count == 0) { await AppPopupInputService.ShowMessageOkAlertPopup("Submit Product", "No product available to submit.", "OK"); return; } var selectedPrdCount = Products.Count(p => p.IsSubmitted); if (selectedPrdCount == 0) { await AppPopupInputService.ShowMessageOkAlertPopup("Submit Product", "Please select one product to submit.", "OK"); return; } // save to db try { AppSpinner.ShowLoading(); var response = await _services.UserService.SaveOrders(Products, UserDetails, SupplierId); AppSpinner.HideLoading(); if (response.Data != null) { ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(UserDashboardPage).ToLower(), (UserDashboardPageViewModel vm) => { vm.UserDetails = App.UserDetails; vm.Products = Products; vm.Orders = response.Data; }) ); } else { await AppPopupInputService.ShowMessageOkAlertPopup("Submit Product", "Unable to place order. Please try again.", "OK"); } } catch (Exception ex) { } }
private void DecreaseQuantityAction(Product item) { int qty = item.Quantity; qty -= 1; if (qty < 1) { qty = 1; } ThreadingHelpers.InvokeOnMainThread(() => { item.Quantity = qty; item.Price = item.UnitPrice * qty; }); }
private void AddProductAction() { ThreadingHelpers.InvokeOnMainThread(async() => { AppInitialiserService.SetInitialiser <AddProductPageViewModel>((AddProductPageViewModel vm) => { vm.UserDetails = UserDetails; vm.ProductList = Products; vm.Product = new Product(); vm.ProductTypes = App.MasterData.ProductTypeMaster; vm.IsAddProduct = true; }); await AppNavigationService.GoToAsync(nameof(AddProductPage).ToLower()); }); }
public void TimeoutCancellationTest() { var errorActionMock = new Mock <Action <Exception> >(); CancellationTokenSource cts = new CancellationTokenSource(); cts.CancelAfter(200); ThreadingHelpers.ExecuteOnThreadPool( () => Thread.Sleep(100), 10, cts.Token, errorAction: errorActionMock.Object); errorActionMock.Verify(m => m(It.IsAny <OperationCanceledException>()), Times.Once); }
private void AddProductAction() { ThreadingHelpers.InvokeOnMainThread(async() => { // AppInitialiserService.SetInitialiser<AddProductPageViewModel>((AddProductPageViewModel vm) => // { // vm.UserDetails = UserDetails; // vm.ProductList = Products; // vm.Product = new Product(); // vm.ProductTypes = App.MasterData.ProductTypeMaster; // vm.IsAddProduct = true; // }); await AppNavigationService.GoBackAsync(); }); }
private async Task AddToCartAction() { try { ThreadingHelpers.InvokeOnMainThread(async() => await AppNavigationService.GoToAsync(nameof(CartPage).ToLower(), (CartPageViewModel vm) => { vm.UserDetails = App.UserDetails; vm.Products = this.Products; vm.Orders = this.Products.Where(p => p.ShouldAddToCart).ToList(); }) ); } catch (Exception ex) { } }
static void Main(string[] args) { // Here you can play around with those method, prototype and easily debug Console.WriteLine($"Main thread is {Thread.CurrentThread.ManagedThreadId}"); ThreadingHelpers.ExecuteOnThread(() => { var thread = Thread.CurrentThread; Console.WriteLine($"Hello from thread {thread.ManagedThreadId} from a pool: {thread.IsThreadPoolThread}"); }, 3); ThreadingHelpers.ExecuteOnThreadPool(() => { var thread = Thread.CurrentThread; Console.WriteLine( $"Hello from thread {thread.ManagedThreadId} from a pool: {thread.IsThreadPoolThread}"); }, 3); }
public void RunningOnDifferentThreadTest() { var mainThreadId = Thread.CurrentThread.ManagedThreadId; var testThreadId = 0; bool?testThreadIsFromPool = null; ThreadingHelpers.ExecuteOnThread( () => { Thread.Sleep(100); testThreadId = Thread.CurrentThread.ManagedThreadId; testThreadIsFromPool = Thread.CurrentThread.IsThreadPoolThread; }, 1); Assert.NotEqual(0, testThreadId); Assert.NotEqual(mainThreadId, testThreadId); Assert.NotNull(testThreadIsFromPool); Assert.False(testThreadIsFromPool); }
public async Task DeleteProductAction(Product item) { var response = await AppPopupInputService.ShowMessageOkCancelAlertPopup("Remove Product", "Are you sure to remove product?", "OK", "CANCEL"); if (!response.Equals("ok", StringComparison.InvariantCultureIgnoreCase)) { return; } ThreadingHelpers.InvokeOnMainThread(() => { Products.Remove(item); var prds = Products.ToList(); Products.Clear(); Products = null; Products = prds; } ); }
private async Task EditProductAction(Product item) { AppSpinner.ShowLoading(); await Task.Delay(10); ThreadingHelpers.InvokeOnMainThread(async() => { AppInitialiserService.SetInitialiser <ProductCataloguePageViewModel>((ProductCataloguePageViewModel vm) => { vm.UserDetails = UserDetails; vm.Products = Products; }); await AppNavigationService.GoToAsync(nameof(ProductCataloguePage).ToLower()); //await AppNavigationService.GoBackAsync(); } ); AppSpinner.HideLoading(); }
public async Task EditProductAction(Product item) { AppSpinner.ShowLoading(); await Task.Delay(10); ThreadingHelpers.InvokeOnMainThread(async() => { // AppInitialiserService.SetInitialiser<AddProductPageViewModel>((AddProductPageViewModel vm) => // { // vm.UserDetails = UserDetails; // vm.ProductList = Products; // vm.Product = item; // vm.IsAddProduct = false; // }); await AppNavigationService.GoBackAsync(); } ); AppSpinner.HideLoading(); }
private void AdjustQuantityAction(string item) { int qty = Product.Quantity; if (item.Equals("Minus")) { qty -= 1; } else { qty += 1; } if (qty <= 0) { qty = 1; } ThreadingHelpers.InvokeOnMainThread(() => { Product.Quantity = qty; }); }