protected async Task <bool> RunFunctionIfOpenAsyncT_MT(Func <Task> funcAsync) { if (!_isOpen) { return(false); } try { await _isOpenSemaphore.WaitAsync(CancToken); //.ConfigureAwait(false); if (_isOpen && funcAsync != null) { await Task.Run(funcAsync, CancToken).ConfigureAwait(false); return(true); } } catch (OperationCanceledException) { } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } return(false); }
private async Task <bool> SetIsEnabledAsync(bool enable) { if (!_isOpen || IsEnabled == enable) { return(false); } try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (_isOpen && IsEnabled != enable) { IsEnabledAllowed = enable; return(true); } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } return(false); }
// LOLLO NOTE important! The Mutex can work across AppDomains (ie across main app and background task) but only if you give it a name! // Also, if you declare initially owned true, the second thread trying to cross it will stay locked forever. So, declare it false. // All this is not well documented. public static async Task LoadAsync() { string errorMessage = string.Empty; try { await _suspensionSemaphore.WaitAsync().ConfigureAwait(false); if (_isLoaded) { return; } var file = await ApplicationData.Current.LocalCacheFolder.CreateFileAsync(SessionDataFilename, CreationCollisionOption.OpenIfExists).AsTask().ConfigureAwait(false); //string ssss = null; //this is useful when you debug and want to see the file as a string //using (IInputStream inStream = await file.OpenSequentialReadAsync()) //{ // using (StreamReader streamReader = new StreamReader(inStream.AsStreamForRead())) // { // ssss = streamReader.ReadToEnd(); // } //} using (IInputStream inStream = await file.OpenSequentialReadAsync().AsTask().ConfigureAwait(false)) { using (var iinStream = inStream.AsStreamForRead()) { DataContractSerializer serializer = new DataContractSerializer(typeof(PersistentData)); iinStream.Position = 0; PersistentData newPersistentData = (PersistentData)(serializer.ReadObject(iinStream)); await iinStream.FlushAsync().ConfigureAwait(false); PersistentData.GetInstanceWithProperties(newPersistentData); } } Debug.WriteLine("ended reading settings"); } catch (System.Xml.XmlException ex) { errorMessage = "could not restore the settings"; await Logger.AddAsync(ex.ToString(), Logger.FileErrorLogFilename); } catch (Exception ex) { errorMessage = "could not restore the settings"; await Logger.AddAsync(ex.ToString(), Logger.FileErrorLogFilename); } finally { PersistentData.GetInstance().LastMessage = errorMessage; IsLoaded = true; SemaphoreSlimSafeRelease.TryRelease(_suspensionSemaphore); } }
public async Task <bool> CloseAsync(object args = null) { if (!_isOpen) { return(await RunFunctionIfOpenAsyncA(delegate { IsEnabledAllowed = false; }).ConfigureAwait(false)); } lock (_ctsLocker) { _cts?.CancelSafe(true); } try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (_isOpen) { lock (_ctsLocker) { _cts?.Dispose(); _cts = null; _cancToken = new CancellationToken(true); // CancellationToken is not nullable and not disposable } await UnregisterBackEventHandlersAsync(); IsEnabledAllowed = false; IsOpen = false; await CloseMayOverrideAsync(args).ConfigureAwait(false); return(true); } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } } finally { lock (_isOpenSemaphoreLocker) { SemaphoreSlimSafeRelease.TryDispose(_isOpenSemaphore); _isOpenSemaphore = null; } } return(false); }
public async Task <bool> OpenAsync(object args = null) { if (_isOpen) { return(await RunFunctionIfOpenAsyncA(delegate { IsEnabledAllowed = true; }).ConfigureAwait(false)); } lock (_isOpenSemaphoreLocker) { if (!SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { _isOpenSemaphore = new SemaphoreSlimSafeRelease(1, 1); } } try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (!_isOpen) { lock (_ctsLocker) { _cts?.Dispose(); _cts = new SafeCancellationTokenSource(); _cancToken = _cts.Token; } await OpenMayOverrideAsync(args).ConfigureAwait(false); IsOpen = true; IsEnabledAllowed = true; await RegisterBackEventHandlersAsync().ConfigureAwait(false); //Logger.Add_TPL($"OpenableObservablePage.OpenAsync: {GetType().Name} is now open", Logger.AppEventsLogFilename, Logger.Severity.Info, false); return(true); } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } return(false); }
public async Task <bool> OpenAsync(object args = null) { if (!_isOpen) { lock (_isOpenSemaphoreLocker) { if (!SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { _isOpenSemaphore = new SemaphoreSlimSafeRelease(1, 1); } } try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (!_isOpen) { lock (_ctsLocker) { _cts?.Dispose(); _cts = new SafeCancellationTokenSource(); _cancToken = _cts.Token; } await OpenMayOverrideAsync(args).ConfigureAwait(false); IsOpen = true; IsEnabledAllowed = true; return(true); } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } } if (_isOpen) { await SetIsEnabledAsync(true).ConfigureAwait(false); } return(false); }
//protected Func<Task> _runAsSoonAsOpen = null; #endregion properties #region open close public async Task<bool> OpenAsync(object args = null) { if (_isOpen) return false; if (!SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) _isOpenSemaphore = new SemaphoreSlimSafeRelease(1, 1); try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (!_isOpen) { lock (_ctsLocker) { _cts?.Dispose(); _cts = new SafeCancellationTokenSource(); _cancToken = _cts.Token; } await OpenMayOverrideAsync(args).ConfigureAwait(false); IsOpen = true; //try //{ // var runAsSoonAsOpen = _runAsSoonAsOpen; // if (runAsSoonAsOpen != null) // { // Task asSoonAsOpen = Task.Run(runAsSoonAsOpen, CancToken); // } //} //catch { } //finally { _runAsSoonAsOpen = null; } return true; } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } return false; }
public static async Task SaveAsync() { try { await _suspensionSemaphore.WaitAsync().ConfigureAwait(false); IsLoaded = false; var allDataOriginal = PersistentData.GetInstance(); using (var memoryStream = new MemoryStream()) { DataContractSerializer sessionDataSerializer = new DataContractSerializer(typeof(PersistentData)); // DataContractSerializer serializer = new DataContractSerializer(typeof(PersistentData), new DataContractSerializerSettings() { SerializeReadOnlyTypes = true }); // DataContractSerializer sessionDataSerializer = new DataContractSerializer(typeof(PersistentData), _knownTypes); // DataContractSerializer sessionDataSerializer = new DataContractSerializer(typeof(PersistentData), new DataContractSerializerSettings() { KnownTypes = _knownTypes, SerializeReadOnlyTypes = true, PreserveObjectReferences = true }); sessionDataSerializer.WriteObject(memoryStream, allDataOriginal); StorageFile sessionDataFile = await ApplicationData.Current.LocalCacheFolder.CreateFileAsync( SessionDataFilename, CreationCollisionOption.ReplaceExisting).AsTask().ConfigureAwait(false); using (Stream fileStream = await sessionDataFile.OpenStreamForWriteAsync().ConfigureAwait(false)) { memoryStream.Seek(0, SeekOrigin.Begin); await memoryStream.CopyToAsync(fileStream).ConfigureAwait(false); await memoryStream.FlushAsync().ConfigureAwait(false); await fileStream.FlushAsync().ConfigureAwait(false); } } Debug.WriteLine("ended saving settings"); } catch (Exception ex) { Logger.Add_TPL(ex.ToString(), Logger.FileErrorLogFilename); } finally { SemaphoreSlimSafeRelease.TryRelease(_suspensionSemaphore); } }
protected async Task <BoolWhenOpen> RunFunctionIfOpenThreeStateAsyncT(Func <Task> funcAsync) { if (!_isOpen) { return(BoolWhenOpen.ObjectClosed); } try { await _isOpenSemaphore.WaitAsync(CancToken); //.ConfigureAwait(false); if (_isOpen) { await funcAsync().ConfigureAwait(false); return(BoolWhenOpen.Yes); } } catch (OperationCanceledException) { return(BoolWhenOpen.ObjectClosed); } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) { await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); return(BoolWhenOpen.Error); } } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } return(BoolWhenOpen.ObjectClosed); }
public async Task<bool> CloseAsync() { if (!_isOpen) return false; lock (_ctsLocker) { _cts?.CancelSafe(true); } try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (_isOpen) { lock (_ctsLocker) { _cts?.Dispose(); _cts = null; _cancToken = new CancellationToken(true); // CancellationToken is not nullable and not disposable } IsOpen = false; await CloseMayOverrideAsync().ConfigureAwait(false); return true; } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } finally { SemaphoreSlimSafeRelease.TryDispose(_isOpenSemaphore); _isOpenSemaphore = null; } return false; }
public async Task<bool> OpenAsync(object args = null) { if (!_isOpen) { if (!SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) _isOpenSemaphore = new SemaphoreSlimSafeRelease(1, 1); try { await _isOpenSemaphore.WaitAsync().ConfigureAwait(false); if (!_isOpen) { lock (_ctsLocker) { _cts?.Dispose(); _cts = new SafeCancellationTokenSource(); _cancToken = _cts.Token; } await OpenMayOverrideAsync(args).ConfigureAwait(false); IsOpen = true; IsEnabledAllowed = true; return true; } } catch (Exception ex) { if (SemaphoreSlimSafeRelease.IsAlive(_isOpenSemaphore)) await Logger.AddAsync(GetType().Name + ex.ToString(), Logger.ForegroundLogFilename); } finally { SemaphoreSlimSafeRelease.TryRelease(_isOpenSemaphore); } } if (_isOpen) await SetIsEnabledAsync(true).ConfigureAwait(false); return false; }