Refaktorisierung von CRUDControllerBase zur Vereinfachung der Generizität und Entfernung nicht benötigter Typparameter.

DigitalData.Core.API/BasicCRUDControllerBase.cs

@@ -6,14 +6,13 @@ namespace DigitalData.Core.API
 {
     [ApiController]
     [Route("api/[controller]")]
-    public class BasicCRUDControllerBase<TOriginalController, TCRUDService, TCRUDRepository, TDto, TEntity, TId> : CRUDControllerBase<TOriginalController, TCRUDService, TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
+    public class BasicCRUDControllerBase<TCRUDService, TCRUDRepository, TDto, TEntity, TId> : CRUDControllerBase<TCRUDService, TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
-        where TOriginalController : CRUDControllerBase<TOriginalController, TCRUDService, TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
         where TCRUDService : ICRUDService<TCRUDRepository, TDto, TDto, TDto, TEntity, TId>
         where TCRUDRepository : ICRUDRepository<TEntity, TId>
         where TDto : class
         where TEntity : class
     {
-        public BasicCRUDControllerBase(ILogger<TOriginalController> logger, TCRUDService service) : base(logger, service)
+        public BasicCRUDControllerBase(ILogger logger, TCRUDService service) : base(logger, service)
         {
         }
     }

DigitalData.Core.API/CRUDControllerBase.cs

@@ -8,7 +8,6 @@ namespace DigitalData.Core.API
     /// <summary>
     /// A base controller class providing generic CRUD (Create, Read, Update, Delete) operations for a specified entity type.
     /// </summary>
-    /// <typeparam name="TOriginalController">The derived controller type implementing this base class.</typeparam>
     /// <typeparam name="TCRUDService">The derived CRUD service type implementing ICRUDService<TCreateDto, TReadDto, TUpdateDto, TEntity, TId>.</typeparam>
     /// <typeparam name="TCreateDto">The Data Transfer Object type for create operations.</typeparam>
     /// <typeparam name="TReadDto">The Data Transfer Object type for read operations.</typeparam>
@@ -17,8 +16,7 @@ namespace DigitalData.Core.API
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
-    public class CRUDControllerBase<TOriginalController, TCRUDService, TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
+    public class CRUDControllerBase<TCRUDService, TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId> : ControllerBase
-        where TOriginalController : CRUDControllerBase<TOriginalController, TCRUDService, TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
         where TCRUDService : ICRUDService<TCRUDRepository, TCreateDto, TReadDto, TUpdateDto, TEntity, TId>
         where TCRUDRepository : ICRUDRepository<TEntity, TId>
         where TCreateDto : class
@@ -26,7 +24,7 @@ namespace DigitalData.Core.API
         where TUpdateDto : class
         where TEntity : class
     {
-        protected readonly ILogger<TOriginalController> _logger;
+        protected readonly ILogger _logger;
         protected readonly TCRUDService _service;
 
         /// <summary>
@@ -35,7 +33,7 @@ namespace DigitalData.Core.API
         /// <param name="logger">The logger to be used by the controller.</param>
         /// <param name="service">The CRUD service handling business logic for the entity.</param>
         public CRUDControllerBase(
-            ILogger<TOriginalController> logger,
+            ILogger logger,
             TCRUDService service)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
@@ -50,16 +48,19 @@ namespace DigitalData.Core.API
         [HttpPost]
         public virtual async Task<IActionResult> Create(TCreateDto createDto)
         {
-            var result = await _service.CreateAsync(createDto);
+            return await _service.CreateAsync(createDto).ThenAsync<TId, IActionResult>(
-            if (result.IsSuccess)
+                Success: id =>
-            {
+                {
-                var createdResource = new { Id = result.Data };
+                    var createdResource = new { Id = id };
-                var actionName = nameof(GetById);
+                    var actionName = nameof(GetById);
-                var routeValues = new { id = createdResource.Id };
+                    var routeValues = new { id = createdResource.Id };
-                return CreatedAtAction(actionName, routeValues, createdResource);
+                    return CreatedAtAction(actionName, routeValues, createdResource);
-            }
+                },
-
+                Fail: (messages, notices) =>
-            return BadRequest(result);
+                {
+                    _logger.LogNotice(notices);
+                    return BadRequest(messages);
+                });
         }
 
         /// <summary>
@@ -70,12 +71,13 @@ namespace DigitalData.Core.API
         [HttpGet("{id}")]
         public virtual async Task<IActionResult> GetById([FromRoute] TId id)
         {
-            var result = await _service.ReadByIdAsync(id);
+            return await _service.ReadByIdAsync(id).ThenAsync(
-            if (result.IsSuccess)
+                Success: Ok,
-            {
+                Fail: IActionResult (messages, notices) =>
-                return Ok(result);
+                {
-            }
+                    _logger.LogNotice(notices);
-            return NotFound(result);
+                    return NotFound(messages);
+                });
         }
 
         /// <summary>
@@ -85,12 +87,13 @@ namespace DigitalData.Core.API
         [HttpGet]
         public virtual async Task<IActionResult> GetAll()
         {
-            var result = await _service.ReadAllAsync();
+            return await _service.ReadAllAsync().ThenAsync(
-            if (result.IsSuccess)
+                Success: Ok,
-            {
+                Fail: IActionResult (messages, notices) =>
-                return Ok(result);
+                {
-            }
+                    _logger.LogNotice(notices);
-            return NotFound(result);
+                    return NotFound(messages);
+                });
         }
 
         /// <summary>
@@ -101,12 +104,13 @@ namespace DigitalData.Core.API
         [HttpPut]
         public virtual async Task<IActionResult> Update(TUpdateDto updateDto)
         {
-            var result = await _service.UpdateAsync(updateDto);
+            return await _service.UpdateAsync(updateDto).ThenAsync(
-            if (result.IsSuccess)
+                Success: Ok,
-            {
+                Fail: IActionResult (messages, notices) =>
-                return Ok(result);
+                {
-            }
+                    _logger.LogNotice(notices);
-            return BadRequest(result);
+                    return BadRequest(messages);
+                });
         }
 
         /// <summary>
@@ -117,13 +121,13 @@ namespace DigitalData.Core.API
         [HttpDelete("{id}")]
         public virtual async Task<IActionResult> Delete([FromRoute] TId id)
         {
-            var result = await _service.DeleteAsyncById(id);
+            return await _service.DeleteAsyncById(id).ThenAsync(
-            if (result.IsSuccess)
+                Success: Ok,
-            {
+                Fail: IActionResult (messages, notices) =>
-                return Ok(result);
+                {
-            }
+                    _logger.LogNotice(notices);
-            return BadRequest(result);
+                    return BadRequest(messages);
+                });
         }
-
     }
 }

DigitalData.Core.API/ReadControllerBase.cs

@@ -7,20 +7,18 @@ namespace DigitalData.Core.API
     /// <summary>
     /// A base controller class providing  Read operation for a specified entity type.
     /// </summary>
-    /// <typeparam name="TOriginalController">The derived controller type implementing this base class.</typeparam>
     /// <typeparam name="TReadDto">The Data Transfer Object type for read operations.</typeparam>
     /// <typeparam name="TEntity">The entity type CRUD operations will be performed on.</typeparam>
     /// <typeparam name="TId">The type of the entity's identifier.</typeparam>
     [ApiController]
     [Route("api/[controller]")]
-    public class ReadControllerBase<TOriginalController, TBasicCRUDService, TCRUDRepository, TReadDto, TEntity, TId> : ControllerBase
+    public class ReadControllerBase<TBasicCRUDService, TCRUDRepository, TReadDto, TEntity, TId> : ControllerBase
-        where TOriginalController : ReadControllerBase<TOriginalController, TBasicCRUDService, TCRUDRepository, TReadDto, TEntity, TId>
         where TBasicCRUDService : IBasicCRUDService<TCRUDRepository, TReadDto, TEntity, TId>
         where TCRUDRepository : ICRUDRepository<TEntity, TId>
         where TReadDto : class
         where TEntity : class
     {
-        protected readonly ILogger<TOriginalController> _logger;
+        protected readonly ILogger _logger;
         protected readonly TBasicCRUDService _service;
 
         /// <summary>
@@ -29,7 +27,7 @@ namespace DigitalData.Core.API
         /// <param name="logger">The logger to be used by the controller.</param>
         /// <param name="service">The CRUD service handling business logic for the entity.</param>
         public ReadControllerBase(
-            ILogger<TOriginalController> logger,
+            ILogger logger,
             TBasicCRUDService service)
         {
             _logger = logger;

DigitalData.Core.DTO/DTOExtensions.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using System.Diagnostics;
 using System.Text;
 
 namespace DigitalData.Core.DTO
@@ -62,28 +63,31 @@ namespace DigitalData.Core.DTO
             return result;
         }
 
-        public static I Then<I>(this Result result, Func<I> Try, Func<List<string>, List<Notice>, I> Catch)
+        public static I Then<I>(this Result result, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
         {
-            return result.IsSuccess ? Try() : Catch(result.Messages, result.Notices);
+            return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
         }
 
-        public static I Then<T, I>(this DataResult<T> result, Func<T, I> Try, Func<List<string>, List<Notice>, I> Catch)
+        public static I Then<T, I>(this DataResult<T> result, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
         {
-            return result.IsSuccess ? Try(result.Data) : Catch(result.Messages, result.Notices);
+            return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
         }
 
-        public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<I> Try, Func<List<string>, List<Notice>, I> Catch)
+        public static async Task<I> ThenAsync<I>(this Task<Result> tResult, Func<I> Success, Func<List<string>, List<Notice>, I> Fail)
         {
             Result result = await tResult;
-            return result.IsSuccess ? Try() : Catch(result.Messages, result.Notices);
+            return result.IsSuccess ? Success() : Fail(result.Messages, result.Notices);
         }
 
-        public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, I> Try, Func<List<string>, List<Notice>, I> Catch)
+        public static async Task<I> ThenAsync<T, I>(this Task<DataResult<T>> tResult, Func<T, I> Success, Func<List<string>, List<Notice>, I> Fail)
         {
             DataResult<T> result = await tResult;
-            return result.IsSuccess ? Try(result.Data) : Catch(result.Messages, result.Notices);
+            return result.IsSuccess ? Success(result.Data) : Fail(result.Messages, result.Notices);
         }
-        
+
+        public static string Join<T>(this IEnumerable<T> values, string start = "", string seperator = ". ", string end = ".") 
+            => new StringBuilder(start).Append(string.Join(seperator, values)).Append(end).ToString();
+
         public static void LogNotice(this ILogger logger, IEnumerable<Notice> notices, string start = ": ", string seperator = ". ", string end = ".\n")
         {
             foreach(LogLevel level in Enum.GetValues(typeof(LogLevel)))