Skip to content

Commit 3064f53

Browse files
I-RzR-II-RzR-I
committed
Add func>task>tresult execute in finally block.
1 parent 5070ba6 commit 3064f53

2 files changed

Lines changed: 702 additions & 0 deletions

File tree

‎src/TryToExecute/CodeExec/Abstract/Func/TryToExecuteFuncFinallyAsync.cs‎

Lines changed: 351 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,351 @@
1+
// ***********************************************************************
2+
// Assembly : RzR.Shared.Extensions.TryToExecute
3+
// Author : RzR
4+
// Created On : 2024-12-05 19:05
5+
//
6+
// Last Modified By : RzR
7+
// Last Modified On : 2024-12-05 19:05
8+
// ***********************************************************************
9+
// <copyright file="TryToExecuteFuncFinallyAsync.cs" company="RzR SOFT & TECH">
10+
// Copyright © RzR. All rights reserved.
11+
// </copyright>
12+
//
13+
// <summary>
14+
// </summary>
15+
// ***********************************************************************
16+
17+
#region U S A G E S
18+
19+
using System;
20+
using System.Diagnostics;
21+
using System.Threading.Tasks;
22+
using TryToExecute.Extensions;
23+
using TryToExecute.Helpers;
24+
25+
#if NETSTANDARD2_0_OR_GREATER
26+
using Microsoft.Extensions.Logging;
27+
#endif
28+
29+
// ReSharper disable CheckNamespace
30+
31+
#endregion
32+
33+
namespace TryToExecute.CodeExec
34+
{
35+
/// <inheritdoc cref="CodeExec.TryCatchExecuteBase"/>
36+
public abstract partial class TryCatchExecuteBase
37+
{
38+
/// -------------------------------------------------------------------------------------------------
39+
/// <summary>
40+
/// Try to execute asynchronous.
41+
/// </summary>
42+
/// <typeparam name="TResult">Type of the result.</typeparam>
43+
/// <param name="execFunc">The execute function.</param>
44+
/// <param name="onFailureResult">The on failure result.</param>
45+
/// <param name="finallyExecFunc">The finally execute function.</param>
46+
/// <param name="forceCallGarbageCollector">
47+
/// (Optional) True to force call garbage collector.
48+
/// </param>
49+
/// <returns>
50+
/// A TResult.
51+
/// </returns>
52+
/// =================================================================================================
53+
protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
54+
Func<Task<TResult>> execFunc,
55+
TResult onFailureResult,
56+
Func<Task<TResult>> finallyExecFunc,
57+
bool forceCallGarbageCollector = false)
58+
{
59+
execFunc.ThrowIfArgNull(nameof(execFunc));
60+
finallyExecFunc.ThrowIfArgNull(nameof(finallyExecFunc));
61+
62+
try
63+
{
64+
return await execFunc.Invoke();
65+
}
66+
catch (Exception e)
67+
{
68+
#if DEBUG
69+
Debug.WriteLine(e);
70+
#if NETSTANDARD1_3_OR_GREATER
71+
Console.WriteLine(e);
72+
#endif
73+
#endif
74+
75+
return onFailureResult;
76+
}
77+
finally
78+
{
79+
await finallyExecFunc.Invoke();
80+
81+
if (forceCallGarbageCollector.IsTrue())
82+
TryToExecuteAppHelper.ForceCallGC();
83+
}
84+
}
85+
86+
#if NETSTANDARD2_0_OR_GREATER
87+
/// -------------------------------------------------------------------------------------------------
88+
/// <summary>
89+
/// Try to execute asynchronous.
90+
/// </summary>
91+
/// <typeparam name="TResult">Type of the result.</typeparam>
92+
/// <typeparam name="TLogger">Type of the logger.</typeparam>
93+
/// <param name="execFunc">The execute function.</param>
94+
/// <param name="onFailureResult">The on failure result.</param>
95+
/// <param name="exceptionLogger">The exception logger.</param>
96+
/// <param name="finallyExecFunc">The finally execute function.</param>
97+
/// <param name="forceCallGarbageCollector">
98+
/// (Optional) True to force call garbage collector.
99+
/// </param>
100+
/// <returns>
101+
/// A TResult.
102+
/// </returns>
103+
/// =================================================================================================
104+
protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
105+
Func<Task<TResult>> execFunc,
106+
TResult onFailureResult,
107+
ILogger<TLogger> exceptionLogger,
108+
Func<Task<TResult>> finallyExecFunc,
109+
bool forceCallGarbageCollector = false)
110+
{
111+
execFunc.ThrowIfArgNull(nameof(execFunc));
112+
finallyExecFunc.ThrowIfArgNull(nameof(finallyExecFunc));
113+
exceptionLogger.ThrowIfArgNull(nameof(exceptionLogger));
114+
115+
try
116+
{
117+
return await execFunc.Invoke();
118+
}
119+
catch (Exception e)
120+
{
121+
#if DEBUG
122+
Debug.WriteLine(e);
123+
#if NETSTANDARD1_3_OR_GREATER
124+
Console.WriteLine(e);
125+
#endif
126+
#endif
127+
exceptionLogger.LogError(e, DefaultMessageHelper.InternalErrorOnTryExecute);
128+
129+
return onFailureResult;
130+
}
131+
finally
132+
{
133+
await finallyExecFunc.Invoke();
134+
135+
if (forceCallGarbageCollector.IsTrue())
136+
TryToExecuteAppHelper.ForceCallGC();
137+
}
138+
}
139+
#endif
140+
141+
/// -------------------------------------------------------------------------------------------------
142+
/// <summary>
143+
/// Try to execute asynchronous.
144+
/// </summary>
145+
/// <typeparam name="TResult">Type of the result.</typeparam>
146+
/// <param name="execFunc">The execute function.</param>
147+
/// <param name="onFailureResult">The on failure result.</param>
148+
/// <param name="finallyExecFunc">The finally execute function.</param>
149+
/// <param name="forceCallGarbageCollector">
150+
/// (Optional) True to force call garbage collector.
151+
/// </param>
152+
/// <returns>
153+
/// A TResult.
154+
/// </returns>
155+
/// =================================================================================================
156+
protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
157+
Func<Task<TResult>> execFunc,
158+
Func<TResult> onFailureResult,
159+
Func<Task<TResult>> finallyExecFunc,
160+
bool forceCallGarbageCollector = false)
161+
{
162+
execFunc.ThrowIfArgNull(nameof(execFunc));
163+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
164+
finallyExecFunc.ThrowIfArgNull(nameof(finallyExecFunc));
165+
166+
try
167+
{
168+
return await execFunc.Invoke();
169+
}
170+
catch (Exception e)
171+
{
172+
#if DEBUG
173+
Debug.WriteLine(e);
174+
#if NETSTANDARD1_3_OR_GREATER
175+
Console.WriteLine(e);
176+
#endif
177+
#endif
178+
179+
return onFailureResult.Invoke();
180+
}
181+
finally
182+
{
183+
await finallyExecFunc.Invoke();
184+
185+
if (forceCallGarbageCollector.IsTrue())
186+
TryToExecuteAppHelper.ForceCallGC();
187+
}
188+
}
189+
190+
#if NETSTANDARD2_0_OR_GREATER
191+
/// -------------------------------------------------------------------------------------------------
192+
/// <summary>
193+
/// Try to execute asynchronous.
194+
/// </summary>
195+
/// <typeparam name="TResult">Type of the result.</typeparam>
196+
/// <typeparam name="TLogger">Type of the logger.</typeparam>
197+
/// <param name="execFunc">The execute function.</param>
198+
/// <param name="onFailureResult">The on failure result.</param>
199+
/// <param name="exceptionLogger">The exception logger.</param>
200+
/// <param name="finallyExecFunc">The finally execute function.</param>
201+
/// <param name="forceCallGarbageCollector">
202+
/// (Optional) True to force call garbage collector.
203+
/// </param>
204+
/// <returns>
205+
/// A TResult.
206+
/// </returns>
207+
/// =================================================================================================
208+
protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
209+
Func<Task<TResult>> execFunc,
210+
Func<TResult> onFailureResult,
211+
ILogger<TLogger> exceptionLogger,
212+
Func<Task<TResult>> finallyExecFunc,
213+
bool forceCallGarbageCollector = false)
214+
{
215+
execFunc.ThrowIfArgNull(nameof(execFunc));
216+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
217+
finallyExecFunc.ThrowIfArgNull(nameof(finallyExecFunc));
218+
exceptionLogger.ThrowIfArgNull(nameof(exceptionLogger));
219+
220+
try
221+
{
222+
return await execFunc.Invoke();
223+
}
224+
catch (Exception e)
225+
{
226+
#if DEBUG
227+
Debug.WriteLine(e);
228+
#if NETSTANDARD1_3_OR_GREATER
229+
Console.WriteLine(e);
230+
#endif
231+
#endif
232+
exceptionLogger.LogError(e, DefaultMessageHelper.InternalErrorOnTryExecute);
233+
234+
return onFailureResult.Invoke();
235+
}
236+
finally
237+
{
238+
await finallyExecFunc.Invoke();
239+
240+
if (forceCallGarbageCollector.IsTrue())
241+
TryToExecuteAppHelper.ForceCallGC();
242+
}
243+
}
244+
#endif
245+
246+
/// -------------------------------------------------------------------------------------------------
247+
/// <summary>
248+
/// Try to execute asynchronous.
249+
/// </summary>
250+
/// <typeparam name="TResult">Type of the result.</typeparam>
251+
/// <param name="execFunc">The execute function.</param>
252+
/// <param name="onFailureResult">The on failure result.</param>
253+
/// <param name="finallyExecFunc">The finally execute function.</param>
254+
/// <param name="forceCallGarbageCollector">
255+
/// (Optional) True to force call garbage collector.
256+
/// </param>
257+
/// <returns>
258+
/// A TResult.
259+
/// </returns>
260+
/// =================================================================================================
261+
protected virtual async Task<TResult> TryToExecuteAsync<TResult>(
262+
Func<Task<TResult>> execFunc,
263+
Func<Task<TResult>> onFailureResult,
264+
Func<Task<TResult>> finallyExecFunc,
265+
bool forceCallGarbageCollector = false)
266+
{
267+
execFunc.ThrowIfArgNull(nameof(execFunc));
268+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
269+
finallyExecFunc.ThrowIfArgNull(nameof(finallyExecFunc));
270+
271+
try
272+
{
273+
return await execFunc.Invoke();
274+
}
275+
catch (Exception e)
276+
{
277+
#if DEBUG
278+
Debug.WriteLine(e);
279+
#if NETSTANDARD1_3_OR_GREATER
280+
Console.WriteLine(e);
281+
#endif
282+
#endif
283+
284+
return await onFailureResult.Invoke();
285+
}
286+
finally
287+
{
288+
await finallyExecFunc.Invoke();
289+
290+
if (forceCallGarbageCollector.IsTrue())
291+
TryToExecuteAppHelper.ForceCallGC();
292+
}
293+
}
294+
295+
#if NETSTANDARD2_0_OR_GREATER
296+
/// -------------------------------------------------------------------------------------------------
297+
/// <summary>
298+
/// Try to execute asynchronous.
299+
/// </summary>
300+
/// <typeparam name="TResult">Type of the result.</typeparam>
301+
/// <typeparam name="TLogger">Type of the logger.</typeparam>
302+
/// <param name="execFunc">The execute function.</param>
303+
/// <param name="onFailureResult">The on failure result.</param>
304+
/// <param name="exceptionLogger">The exception logger.</param>
305+
/// <param name="finallyExecFunc">The finally execute function.</param>
306+
/// <param name="forceCallGarbageCollector">
307+
/// (Optional) True to force call garbage collector.
308+
/// </param>
309+
/// <returns>
310+
/// A TResult.
311+
/// </returns>
312+
/// =================================================================================================
313+
protected virtual async Task<TResult> TryToExecuteAsync<TResult, TLogger>(
314+
Func<Task<TResult>> execFunc,
315+
Func<Task<TResult>> onFailureResult,
316+
ILogger<TLogger> exceptionLogger,
317+
Func<Task<TResult>> finallyExecFunc,
318+
bool forceCallGarbageCollector = false)
319+
{
320+
execFunc.ThrowIfArgNull(nameof(execFunc));
321+
onFailureResult.ThrowIfArgNull(nameof(onFailureResult));
322+
exceptionLogger.ThrowIfArgNull(nameof(exceptionLogger));
323+
finallyExecFunc.ThrowIfArgNull(nameof(finallyExecFunc));
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 await onFailureResult.Invoke();
340+
}
341+
finally
342+
{
343+
await finallyExecFunc.Invoke();
344+
345+
if (forceCallGarbageCollector.IsTrue())
346+
TryToExecuteAppHelper.ForceCallGC();
347+
}
348+
}
349+
#endif
350+
}
351+
}

0 commit comments

Comments
 (0)