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);
}
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 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);
}
