public Model()
{
Execution = new ModelExecution()
{
HandleTimeout = TimeoutHandle,
HandleUnhandledException = HandleError
};
}
public Model(IModelState modelState)
{
Execution = new ModelExecution()
{
HandleTimeout = TimeoutHandle,
HandleUnhandledException = HandleError
};
ModelState = modelState;
}
public async static Task <T> ModelExecute <T>(this IModelExecution sender, IModelExecute <T> execute, [CallerMemberName] string name = "")
{
return(await ModelExecute(sender,
operation : execute.Operation,
handleUnhandledException : sender.HandleUnhandledException,
handleTimeout : sender.HandleTimeout,
insights : sender.Insights,
name : name,
timeoutMilliseconds : execute.TimeoutMilliseconds
));
}
public Model(IDisplayService displayService, IApplicationInsights applicationInsights, IErrorHandlingService errorHandlingService, IModelState modelState)
{
_displayService = displayService;
_errorHandlingService = errorHandlingService;
_applicationInsights = applicationInsights;
ModelState = modelState;
Execution = new ModelExecution()
{
HandleTimeout = TimeoutHandle,
HandleUnhandledException = HandleError
};
}
public Model(IExrinContainer exrinContainer, IModelState modelState)
{
if (exrinContainer == null)
throw new ArgumentNullException(nameof(IExrinContainer));
_displayService = exrinContainer.DisplayService;
_errorHandlingService = exrinContainer.ErrorHandlingService;
_applicationInsights = exrinContainer.ApplicationInsights;
ModelState = modelState;
Execution = new ModelExecution()
{
HandleTimeout = TimeoutHandle,
HandleUnhandledException = HandleError
};
}
public Model(IExrinContainer exrinContainer, IModelState modelState)
{
if (exrinContainer == null)
{
throw new ArgumentNullException(nameof(IExrinContainer));
}
_displayService = exrinContainer.DisplayService;
_errorHandlingService = exrinContainer.ErrorHandlingService;
_applicationInsights = exrinContainer.ApplicationInsights;
ModelState = modelState;
Execution = new ModelExecution()
{
HandleTimeout = TimeoutHandle,
HandleUnhandledException = HandleError
};
}
/// <summary>
/// Singular Operation
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="sender"></param>
/// <param name="operation"></param>
/// <param name="handleUnhandledException"></param>
/// <param name="handleTimeout"></param>
/// <param name="timeoutMilliseconds"></param>
/// <param name="insights"></param>
/// <param name="name"></param>
/// <param name="parameter"></param>
/// <returns></returns>
private static async Task <T> ModelExecute <T>(IModelExecution sender,
IOperation <T> operation,
Func <Exception, Task <bool> > handleUnhandledException = null,
Func <ITimeoutEvent, Task> handleTimeout = null,
int timeoutMilliseconds = 0,
IApplicationInsights insights = null,
string name = ""
)
{
if (sender == null)
{
throw new Exception($"The IModelExecution sender can not be null");
}
// Background thread
Task insight = Task.Run(() =>
{
try
{
if (insights != null)
{
insights.TrackEvent(name, $"User activated {name}");
}
}
catch (Exception ex)
{
Debug.WriteLine($"insights.TrackEvent({name}) {ex.Message}");
}
});
List <Func <IResult, Task> > rollbacks = new List <Func <IResult, Task> >();
bool transactionRunning = false;
// Setup Cancellation of Tasks if long running
var task = new CancellationTokenSource();
var exceptionState = new PropertyArgs()
{
Value = false
};
if (timeoutMilliseconds > 0)
{
if (handleTimeout != null)
{
task.Token.Register(async(state) => { if (!(bool)((PropertyArgs)state).Value)
{
await handleTimeout(new TimeoutEvent("", timeoutMilliseconds));
}
}, exceptionState);
}
else if (handleUnhandledException != null)
{
task.Token.Register(async(state) => { if (!(bool)((PropertyArgs)state).Value)
{
await handleUnhandledException(new TimeoutException());
}
}, exceptionState);
}
else
{
throw new Exception($"You must specify either {nameof(handleTimeout)} or {nameof(handleUnhandledException)} to handle a timeout.");
}
task.CancelAfter(timeoutMilliseconds);
}
T result = default(T);
try
{
// Transaction Block
transactionRunning = true;
if (operation.Function != null)
{
try
{
await Task.Run(async() => { result = await operation.Function(task.Token); }, task.Token); // Background Thread
}
catch
{
exceptionState.Value = true; // Stops registered cancel function from running, since this is exception not timeout
task?.Cancel(); // Cancel all tasks
throw; // Go to unhandled exception
}
}
transactionRunning = false;
// End of Transaction Block
}
catch (Exception e)
{
if (handleUnhandledException == null)
{
throw;
}
var handled = await handleUnhandledException(e);
if (!handled)
{
throw;
}
}
finally
{
try
{
task?.Dispose();
if (transactionRunning)
{
await operation.Rollback();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
return(result);
}
