private void OnPropertyChanged()
{
var handler = Interlocked.CompareExchange(ref PropertyChanged, null, null);
if (handler != null)
{
handler(this, EventArgsFactory.GetPropertyChangedEventArgs("CanExecute"));
}
}
protected virtual void RaisePropertyChanged([CallerMemberName] string property_name = "")
{
var handler = Interlocked.CompareExchange(ref this.PropertyChanged, null, null);
if (handler != null)
{
var args = EventArgsFactory.GetPropertyChangedEventArgs(property_name);
handler(this, args);
}
}
/// <summary>
/// Invokes the delegate given (if not <see langword="null" />) with protection against exceptions thrown by
/// the invoked methods.
/// </summary>
/// <typeparam name="T">
/// The type of the event args to pass.
/// </typeparam>
/// <param name="handler">
/// The delegate to call.
/// </param>
/// <param name="eventName">
/// The name of the event being raised.
/// </param>
/// <param name="sender">
/// The object to pass as the sender.
/// </param>
/// <param name="eventArgFactory">
/// A factory for generating event args.
/// </param>
/// <param name="usage">
/// The way in which to use the factory to generate args.
/// </param>
/// <returns>
/// <see langword="true" /> if at least one delegate was successfully invoked, <see langword="false" /> otherwise.
/// </returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Invalid value passed in the <paramref name="usage" /> argument.
/// </exception>
public static bool SafeInvoke <T>([CanBeNull] this Delegate handler, [NotNull] string eventName, [CanBeNull] object sender,
EventArgsFactory <T> eventArgFactory, ArgsUsageKind usage) where T : EventArgs
{
eventName.Validate(nameof(eventName), StringIs.NotNullEmptyOrWhiteSpace);
eventArgFactory.Validate(nameof(eventArgFactory), ObjectIs.NotNull);
if (ReferenceEquals(handler, null))
{
return(false);
}
var delegates = handler.GetInvocationList();
object[]? args = null;
bool generateArgs;
switch (usage)
{
case ArgsUsageKind.Reuse:
args = new[] { sender, eventArgFactory() };
generateArgs = false;
break;
case ArgsUsageKind.UniqueInstance:
generateArgs = true;
break;
default:
throw new ArgumentOutOfRangeException(nameof(usage), usage, string.Format(Resources.Exceptions.DelegateExtensions_InvalidUsage, nameof(usage), System.Globalization.CultureInfo.CurrentCulture));
}
var raised = false;
foreach (var callback in delegates)
{
try
{
if (generateArgs)
{
args = new[] { sender, eventArgFactory() };
}
callback.DynamicInvoke(args);
raised = true;
}
#pragma warning disable CA1031 // Do not catch general exception types
catch (Exception ex)
{
ex.Data.Add("CallingDelegate", GetDescription(callback));
ExceptionManager.OnUnhandledException(ex);
}
#pragma warning restore CA1031 // Do not catch general exception types
}
return(raised);
}
private void OnPropertyChanged() => PropertyChanged?.Invoke(this, EventArgsFactory.GetPropertyChangedEventArgs(nameof(CanExecute)));
/// <summary>
/// Invokes the delegate given (if not <see langword="null" />) with protection against exceptions thrown by the
/// invoked methods.
/// </summary>
/// <typeparam name="T">The type of the event args to pass.</typeparam>
/// <param name="handler">The delegate to call.</param>
/// <param name="eventName">The name of the event being raised.</param>
/// <param name="sender">The object to pass as the sender.</param>
/// <param name="usage">The way in which to use the factory to generate args.</param>
/// <param name="eventArgFactory">A factory for generating event args.</param>
/// <returns><see langword="true" /> if at least one delegate was successfully invoked, <see langword="false" /> otherwise.</returns>
/// <exception cref="ArgumentOutOfRangeException">
/// Thrown if an invalid value passed in the <paramref name="usage" />
/// argument.
/// </exception>
/// <exception cref="System.ArgumentNullException"><paramref name="eventName" /> is <see langword="null" />.</exception>
/// <exception cref="System.ArgumentException">
/// <paramref name="eventName" /> is zero-length or contains only white space
/// characters.
/// </exception>
/// <exception cref="System.ArgumentNullException"><paramref name="eventArgFactory" /> is <see langword="null" />.</exception>
public static bool SafeInvoke <T>([CanBeNull] this Delegate handler, [NotNull] string eventName, [CanBeNull] object sender, ArgsUsage usage, EventArgsFactory <T> eventArgFactory)
where T : EventArgs
{
eventName.Validate(nameof(eventName), StringIs.NotNullEmptyOrWhiteSpace);
eventArgFactory.Validate(nameof(eventArgFactory), ObjectIs.NotNull);
// An empty invocation list is null.
if (ReferenceEquals(handler, null))
{
return(false);
}
var delegates = handler.GetInvocationList();
// All non-null invocation lists are also non-empty, so no need to test here.
object[] args = null;
bool generateArgs;
switch (usage)
{
case ArgsUsage.Reuse:
args = new[] { sender, eventArgFactory() };
generateArgs = false;
break;
case ArgsUsage.UniqueInstance:
generateArgs = true;
break;
default:
throw new ArgumentOutOfRangeException(nameof(usage), usage, $@"'{nameof(usage)}' argument contains invalid value: {usage}.");
}
var raised = false;
var checkForHandled = typeof(HandledEventArgs).IsAssignableFrom(typeof(T));
foreach (var callback in delegates)
{
try
{
if (generateArgs)
{
args = new[] { sender, eventArgFactory() };
}
callback.DynamicInvoke(args);
raised = true;
if (checkForHandled && (((HandledEventArgs)args[1]).State == HandledEventState.HandledAndCeaseRaising))
{
break;
}
}
catch (ThreadAbortException)
{
// Ignore thread abort exceptions, but do stop processing any further.
break;
}
catch (Exception ex)
{
if (typeof(UnhandledExceptionEventArgs).IsAssignableFrom(typeof(T)))
{
// If we already in the process of raising an exception just ignore anything further.
continue;
}
// If an event handler has raised an exception report it, but carry on.
ExceptionManager.OnUnhandledException(ex, $@"Error whilst '{eventName}' event was being handled by {GetDescription(callback)}.");
}
}
return(raised);
}
private void OnPropertyChanged()
{
Interlocked.CompareExchange(ref PropertyChanged, null, null)
?.Invoke(this, EventArgsFactory.GetPropertyChangedEventArgs("CanExecute"));
}
private async void tlsServer_BackupAll(object sender, EventArgsFactory.BackupEventArgs e)
{
if (!CanContinue(_oInstance)) return;
var server = _oInstance;
// Ask to activate sys dbs if no user dbs are available
if (server.DatabasesCollection.Count == 0)
{
var dr = MessageBox.Show(NO_USER_DATABASES, "No user databases", MessageBoxButtons.YesNo);
if (!dr.Equals(DialogResult.Yes)) return;
tlsEnableSystemDbs.PerformClick();
return;
}
// I need a copy in case the collection changes during the async operations
var listDatabases = new List<SqlDatabase>(server.DatabasesCollection);
var checkedOk = 0;
UIOperationStarted(sender, server, listDatabases.Count);
foreach (var database in listDatabases)
{
var status = String.Format("({0}/{1})", listDatabases.IndexOf(database) + 1, listDatabases.Count);
if (database.Status != "ONLINE")
{
SetStatus(sender, database, status, "SKIPPED", WRONG_DATABASE_STATE + string.Format("({0})", database.Status));
continue;
}
var par = new List<string>();
if (e == null) e = new EventArgsFactory.BackupEventArgs();
if (e.Compress) par.Add("COMPRESSION");
if (e.Format) par.Add("FORMAT");
var token = GetCancellationToken(SqlInstance.ListServers.IndexOf(server));
var db = database;
var backup = Task.Run(() => db.BackupAsync(par, token));
try
{
await backup; // TODO: fix EXCEPTION if in single user
if (token.IsCancellationRequested)
{
token.ThrowIfCancellationRequested();
}
SetStatus(sender, db, status, "COMPLETED", database.Name + " backed up.");
checkedOk++;
}
catch (OperationCanceledException)
{
SetStatus(sender, db, status, "CANCEL");
break;
}
catch (SqlException ex)
{
SetStatus(sender, db, status, "ERROR", ex.Message);
}
catch (Exception ex)
{
SetStatus(sender, db, status, "EXCEPTION", ex.Message);
}
finally
{
_progressBars[SqlInstance.ListServers.IndexOf(server)].Increment(1);
//dgvDatabases.Refresh();
}
}
UIOperationClosed(sender, server, true, String.Format("Backed up successfully: {0}/{1}", checkedOk, listDatabases.Count));
}
private async void Database_Backup(object sender, EventArgsFactory.BackupEventArgs e)
{
if (!CanContinue(_oDatabase)) return;
if (_oDatabase.Status != "ONLINE")
{
SetStatus(sender, _oDatabase, "END", "SKIPPED", WRONG_DATABASE_STATE + string.Format("({0})", _oDatabase.Status));
return;
}
var database = _oDatabase;
var now = DateTime.Now;
var par = new List<string>();
if (e != null)
{
if (e.Compress) par.Add("COMPRESSION");
if (e.Format) par.Add("FORMAT");
}
UIOperationStarted(sender, database);
try
{
var token = GetCancellationToken(SqlInstance.ListServers.IndexOf(database.Parent));
var backup = Task.Run(() => database.BackupAsync(par, token));
await backup;
if (token.IsCancellationRequested)
{
token.ThrowIfCancellationRequested();
}
SetStatus(sender, database, "END", "COMPLETED", string.Format("Database {0} backed up in {1} seconds", database.Name,
((DateTime.Now - now).Seconds)));
}
catch (OperationCanceledException)
{
SetStatus(sender, database, "END", "CANCEL");
}
catch (SqlException ex)
{
SetStatus(sender, database, "END", "ERROR", ex.Message);
}
catch (Exception ex)
{
SetStatus(sender, database, "END", "EXCEPTION", ex.Message);
}
UIOperationClosed(sender, database);
}
