Skip to content

Commit 8ca525b

Browse files
I-RzR-II-RzR-I
authored
Merge pull request #3 from I-RzR-I/feature/AddImprovements
Feature/add improvements
2 parents 77585cc + dd8661c commit 8ca525b

16 files changed

Lines changed: 2851 additions & 6 deletions

‎docs/CHANGELOG.md‎

Lines changed: 6 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,10 @@
1+
### v1.1.2.4376
2+
-> Add `Func<Exception, Task<TResult>>` and `Func<Exception, TResult>` execute in catch block; <br/>
3+
14
### v1.1.1.7383
2-
-> Add Func&lt;Task&lt;TResult&gt;&gt; execute in finally block; <br/>
3-
-> Add Funct&lt;Task&gt; execute in finally block; <br/>
5+
-> Add `Func<Task<TResult>>` execute in finally block; <br/>
6+
-> Add `Func<Task>` execute in finally block; <br/>
7+
-> Add `Action` execute in finally block; <br/>
48
-> Small adjustments in finally block action execution; <br/>
59

610
### v1.1.0.0

‎src/TryToExecute/CodeExec/Abstract/Action/TryToExecuteActionFinally.cs‎

Lines changed: 105 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -232,6 +232,55 @@ protected virtual TResult TryToExecute<TResult>(
232232
}
233233
}
234234

235+
/// -------------------------------------------------------------------------------------------------
236+
/// <summary>
237+
/// Try to execute.
238+
/// </summary>
239+
/// <typeparam name="TResult">Type of the result.</typeparam>
240+
/// <param name="execFunc">The execute function.</param>
241+
/// <param name="onFailureResult">The on failure result.</param>
242+
/// <param name="finallyExecAction">The finally execute action.</param>
243+
/// <param name="forceCallGarbageCollector">
244+
/// (Optional) True to force call garbage collector.
245+
/// </param>
246+
/// <returns>
247+
/// A TResult.
248+
/// </returns>
249+
/// =================================================================================================
250+
protected virtual TResult TryToExecute<TResult>(
251+
Func<TResult> execFunc,
252+
Func<Exception, TResult> onFailureResult,
253+
Action finallyExecAction,
254+
bool forceCallGarbageCollector = false)
255+
{
256+
execFunc.ThrowIfArgNull(nameof(execFunc));
257+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
258+
259+
try
260+
{
261+
return execFunc.Invoke();
262+
}
263+
catch (Exception e)
264+
{
265+
#if DEBUG
266+
Debug.WriteLine(e);
267+
#if NETSTANDARD1_3_OR_GREATER
268+
Console.WriteLine(e);
269+
#endif
270+
#endif
271+
272+
return onFailureResult.Invoke(e);
273+
}
274+
finally
275+
{
276+
if (finallyExecAction.IsNotNull())
277+
finallyExecAction?.Invoke();
278+
279+
if (forceCallGarbageCollector.IsTrue())
280+
TryToExecuteAppHelper.ForceCallGC();
281+
}
282+
}
283+
235284
#if NETSTANDARD2_0_OR_GREATER
236285
/// -------------------------------------------------------------------------------------------------
237286
/// <summary>
@@ -287,5 +336,61 @@ protected virtual TResult TryToExecute<TResult, TLogger>(
287336
}
288337
}
289338
#endif
339+
340+
#if NETSTANDARD2_0_OR_GREATER
341+
/// -------------------------------------------------------------------------------------------------
342+
/// <summary>
343+
/// Try to execute.
344+
/// </summary>
345+
/// <typeparam name="TResult">Type of the result.</typeparam>
346+
/// <typeparam name="TLogger">Type of the logger.</typeparam>
347+
/// <param name="execFunc">The execute function.</param>
348+
/// <param name="onFailureResult">The on failure result.</param>
349+
/// <param name="exceptionLogger">The exception logger.</param>
350+
/// <param name="finallyExecAction">The finally execute action.</param>
351+
/// <param name="forceCallGarbageCollector">
352+
/// (Optional) True to force call garbage collector.
353+
/// </param>
354+
/// <returns>
355+
/// A TResult.
356+
/// </returns>
357+
/// =================================================================================================
358+
protected virtual TResult TryToExecute<TResult, TLogger>(
359+
Func<TResult> execFunc,
360+
Func<Exception, TResult> onFailureResult,
361+
ILogger<TLogger> exceptionLogger,
362+
Action finallyExecAction,
363+
bool forceCallGarbageCollector = false)
364+
{
365+
execFunc.ThrowIfArgNull(nameof(execFunc));
366+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
367+
exceptionLogger.ThrowIfArgNull(nameof(exceptionLogger));
368+
369+
try
370+
{
371+
return execFunc.Invoke();
372+
}
373+
catch (Exception e)
374+
{
375+
#if DEBUG
376+
Debug.WriteLine(e);
377+
#if NETSTANDARD1_3_OR_GREATER
378+
Console.WriteLine(e);
379+
#endif
380+
#endif
381+
exceptionLogger.LogError(e, DefaultMessageHelper.InternalErrorOnTryExecute);
382+
383+
return onFailureResult.Invoke(e);
384+
}
385+
finally
386+
{
387+
if (finallyExecAction.IsNotNull())
388+
finallyExecAction?.Invoke();
389+
390+
if (forceCallGarbageCollector.IsTrue())
391+
TryToExecuteAppHelper.ForceCallGC();
392+
}
393+
}
394+
#endif
290395
}
291396
}

‎src/TryToExecute/CodeExec/Abstract/Action/TryToExecuteActionFinallyAsync.cs‎

Lines changed: 210 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,55 @@ protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
188188
}
189189
}
190190

191+
/// -------------------------------------------------------------------------------------------------
192+
/// <summary>
193+
/// Try to execute asynchronous.
194+
/// </summary>
195+
/// <typeparam name="TResult">Type of the result.</typeparam>
196+
/// <param name="execFunc">The execute function.</param>
197+
/// <param name="onFailureResult">The on failure result.</param>
198+
/// <param name="finallyExecAction">The finally execute action.</param>
199+
/// <param name="forceCallGarbageCollector">
200+
/// (Optional) True to force call garbage collector.
201+
/// </param>
202+
/// <returns>
203+
/// A TResult.
204+
/// </returns>
205+
/// =================================================================================================
206+
protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
207+
Func<Task<TResult>> execFunc,
208+
Func<Exception, TResult> onFailureResult,
209+
Action finallyExecAction,
210+
bool forceCallGarbageCollector = false)
211+
{
212+
execFunc.ThrowIfArgNull(nameof(execFunc));
213+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
214+
215+
try
216+
{
217+
return await execFunc.Invoke();
218+
}
219+
catch (Exception e)
220+
{
221+
#if DEBUG
222+
Debug.WriteLine(e);
223+
#if NETSTANDARD1_3_OR_GREATER
224+
Console.WriteLine(e);
225+
#endif
226+
#endif
227+
228+
return onFailureResult.Invoke(e);
229+
}
230+
finally
231+
{
232+
if (finallyExecAction.IsNotNull())
233+
finallyExecAction?.Invoke();
234+
235+
if (forceCallGarbageCollector.IsTrue())
236+
TryToExecuteAppHelper.ForceCallGC();
237+
}
238+
}
239+
191240
#if NETSTANDARD2_0_OR_GREATER
192241
/// -------------------------------------------------------------------------------------------------
193242
/// <summary>
@@ -244,6 +293,62 @@ protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
244293
}
245294
#endif
246295

296+
#if NETSTANDARD2_0_OR_GREATER
297+
/// -------------------------------------------------------------------------------------------------
298+
/// <summary>
299+
/// Try to execute asynchronous.
300+
/// </summary>
301+
/// <typeparam name="TResult">Type of the result.</typeparam>
302+
/// <typeparam name="TLogger">Type of the logger.</typeparam>
303+
/// <param name="execFunc">The execute function.</param>
304+
/// <param name="onFailureResult">The on failure result.</param>
305+
/// <param name="exceptionLogger">The exception logger.</param>
306+
/// <param name="finallyExecAction">The finally execute action.</param>
307+
/// <param name="forceCallGarbageCollector">
308+
/// (Optional) True to force call garbage collector.
309+
/// </param>
310+
/// <returns>
311+
/// A TResult.
312+
/// </returns>
313+
/// =================================================================================================
314+
protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
315+
Func<Task<TResult>> execFunc,
316+
Func<Exception, TResult> onFailureResult,
317+
ILogger<TLogger> exceptionLogger,
318+
Action finallyExecAction,
319+
bool forceCallGarbageCollector = false)
320+
{
321+
execFunc.ThrowIfArgNull(nameof(execFunc));
322+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
323+
exceptionLogger.ThrowIfArgNull(nameof(exceptionLogger));
324+
325+
try
326+
{
327+
return await execFunc.Invoke();
328+
}
329+
catch (Exception e)
330+
{
331+
#if DEBUG
332+
Debug.WriteLine(e);
333+
#if NETSTANDARD1_3_OR_GREATER
334+
Console.WriteLine(e);
335+
#endif
336+
#endif
337+
exceptionLogger.LogError(e, DefaultMessageHelper.InternalErrorOnTryExecute);
338+
339+
return onFailureResult.Invoke(e);
340+
}
341+
finally
342+
{
343+
if (finallyExecAction.IsNotNull())
344+
finallyExecAction?.Invoke();
345+
346+
if (forceCallGarbageCollector.IsTrue())
347+
TryToExecuteAppHelper.ForceCallGC();
348+
}
349+
}
350+
#endif
351+
247352
/// -------------------------------------------------------------------------------------------------
248353
/// <summary>
249354
/// Try to execute asynchronous.
@@ -293,6 +398,55 @@ protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
293398
}
294399
}
295400

401+
/// -------------------------------------------------------------------------------------------------
402+
/// <summary>
403+
/// Try to execute asynchronous.
404+
/// </summary>
405+
/// <typeparam name="TResult">Type of the result.</typeparam>
406+
/// <param name="execFunc">The execute function.</param>
407+
/// <param name="onFailureResult">The on failure result.</param>
408+
/// <param name="finallyExecAction">The finally execute action.</param>
409+
/// <param name="forceCallGarbageCollector">
410+
/// (Optional) True to force call garbage collector.
411+
/// </param>
412+
/// <returns>
413+
/// A TResult.
414+
/// </returns>
415+
/// =================================================================================================
416+
protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
417+
Func<Task<TResult>> execFunc,
418+
Func<Exception, Task<TResult>> onFailureResult,
419+
Action finallyExecAction,
420+
bool forceCallGarbageCollector = false)
421+
{
422+
execFunc.ThrowIfArgNull(nameof(execFunc));
423+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
424+
425+
try
426+
{
427+
return await execFunc.Invoke();
428+
}
429+
catch (Exception e)
430+
{
431+
#if DEBUG
432+
Debug.WriteLine(e);
433+
#if NETSTANDARD1_3_OR_GREATER
434+
Console.WriteLine(e);
435+
#endif
436+
#endif
437+
438+
return await onFailureResult.Invoke(e);
439+
}
440+
finally
441+
{
442+
if (finallyExecAction.IsNotNull())
443+
finallyExecAction?.Invoke();
444+
445+
if (forceCallGarbageCollector.IsTrue())
446+
TryToExecuteAppHelper.ForceCallGC();
447+
}
448+
}
449+
296450
#if NETSTANDARD2_0_OR_GREATER
297451
/// -------------------------------------------------------------------------------------------------
298452
/// <summary>
@@ -348,5 +502,61 @@ protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
348502
}
349503
}
350504
#endif
505+
506+
#if NETSTANDARD2_0_OR_GREATER
507+
/// -------------------------------------------------------------------------------------------------
508+
/// <summary>
509+
/// Try to execute asynchronous.
510+
/// </summary>
511+
/// <typeparam name="TResult">Type of the result.</typeparam>
512+
/// <typeparam name="TLogger">Type of the logger.</typeparam>
513+
/// <param name="execFunc">The execute function.</param>
514+
/// <param name="onFailureResult">The on failure result.</param>
515+
/// <param name="exceptionLogger">The exception logger.</param>
516+
/// <param name="finallyExecAction">The finally execute action.</param>
517+
/// <param name="forceCallGarbageCollector">
518+
/// (Optional) True to force call garbage collector.
519+
/// </param>
520+
/// <returns>
521+
/// A TResult.
522+
/// </returns>
523+
/// =================================================================================================
524+
protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
525+
Func<Task<TResult>> execFunc,
526+
Func<Exception, Task<TResult>> onFailureResult,
527+
ILogger<TLogger> exceptionLogger,
528+
Action finallyExecAction,
529+
bool forceCallGarbageCollector = false)
530+
{
531+
execFunc.ThrowIfArgNull(nameof(execFunc));
532+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
533+
exceptionLogger.ThrowIfArgNull(nameof(exceptionLogger));
534+
535+
try
536+
{
537+
return await execFunc.Invoke();
538+
}
539+
catch (Exception e)
540+
{
541+
#if DEBUG
542+
Debug.WriteLine(e);
543+
#if NETSTANDARD1_3_OR_GREATER
544+
Console.WriteLine(e);
545+
#endif
546+
#endif
547+
exceptionLogger.LogError(e, DefaultMessageHelper.InternalErrorOnTryExecute);
548+
549+
return await onFailureResult.Invoke(e);
550+
}
551+
finally
552+
{
553+
if (finallyExecAction.IsNotNull())
554+
finallyExecAction?.Invoke();
555+
556+
if (forceCallGarbageCollector.IsTrue())
557+
TryToExecuteAppHelper.ForceCallGC();
558+
}
559+
}
560+
#endif
351561
}
352562
}

0 commit comments

Comments
 (0)