From 1fc45702106ec161ba1aeb20eae1de629d8945d5 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 22:45:19 +0100
Subject: [PATCH 01/24] Add ReCClient class and update project dependencies

Added `ReCClient` class to handle HTTP requests with JSON
serialization/deserialization support. Updated `ReC.Client.csproj`
to include `System.Net.Http` (v4.3.4) and `System.Text.Json`
(v9.0.11) as package references. Introduced conditional `using`
directives for `NETFRAMEWORK` compatibility.
---
 src/ReC.Client/ReC.Client.csproj |  5 +++++
 src/ReC.Client/ReCClient.cs      | 22 ++++++++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 src/ReC.Client/ReCClient.cs

diff --git a/src/ReC.Client/ReC.Client.csproj b/src/ReC.Client/ReC.Client.csproj
index 983eb2b..6b41f2e 100644
--- a/src/ReC.Client/ReC.Client.csproj
+++ b/src/ReC.Client/ReC.Client.csproj
@@ -8,4 +8,9 @@
 		<ImplicitUsings>enable</ImplicitUsings>
 		<Nullable>enable</Nullable>
 	</PropertyGroup>
+
+	<ItemGroup>
+	  <PackageReference Include="System.Net.Http" Version="4.3.4" />
+	  <PackageReference Include="System.Text.Json" Version="9.0.11" />
+	</ItemGroup>
 </Project>
diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
new file mode 100644
index 0000000..99165a7
--- /dev/null
+++ b/src/ReC.Client/ReCClient.cs
@@ -0,0 +1,22 @@
+using System.Text.Json;
+#if NETFRAMEWORK
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+#else
+#endif
+
+namespace ReC.Client
+{
+    public class ReCClient
+    {
+        private readonly HttpClient _http;
+        private readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions() { PropertyNameCaseInsensitive = true };
+
+        public ReCClient(HttpClient http)
+        {
+            _http = http ?? throw new ArgumentNullException(nameof(http));
+        }
+    }
+}

From e774afc85e7f4be8533e7d8865f9786635b153da Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:02:45 +0100
Subject: [PATCH 02/24] Add InvokeRecActionAsync method to ReCClient class

Added the `InvokeRecActionAsync` method to the `ReCClient` class in the `ReC.Client` namespace. This method performs an asynchronous HTTP POST request to the `api/RecAction/invoke/{profileId}` endpoint. It accepts a `profileId` parameter to specify the profile ID and an optional `CancellationToken` for task cancellation. The method ensures the HTTP response indicates success by calling `EnsureSuccessStatusCode()`. Included XML documentation comments for clarity and maintainability.
---
 src/ReC.Client/ReCClient.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 99165a7..767ae33 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -18,5 +18,17 @@ namespace ReC.Client
         {
             _http = http ?? throw new ArgumentNullException(nameof(http));
         }
+
+        /// <summary>
+        /// POST api/RecAction/invoke/{profileId}
+        /// </summary>
+        /// <param name="profileId"></param>
+        /// <param name="ct"></param>
+        /// <returns></returns>
+        public async Task InvokeRecActionAsync(int profileId, CancellationToken ct = default)
+        {
+            var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, ct);
+            resp.EnsureSuccessStatusCode();
+        }
     }
 }

From 73059d4554a7f17870c9e26b51aee4da6cd6a90b Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:03:03 +0100
Subject: [PATCH 03/24] Add InvokeRecActionFakeAsync method to ReCClient

A new asynchronous method `InvokeRecActionFakeAsync` was added to the `ReC.Client` namespace in `ReCClient.cs`. This method sends a POST request to the `api/RecAction/invoke/fake` endpoint. It includes XML documentation comments and accepts an optional `CancellationToken` parameter. The method ensures the response has a successful status code.
---
 src/ReC.Client/ReCClient.cs | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 767ae33..e680b72 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -30,5 +30,16 @@ namespace ReC.Client
             var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, ct);
             resp.EnsureSuccessStatusCode();
         }
+
+        /// <summary>
+        /// POST api/RecAction/invoke/fake
+        /// </summary>
+        /// <param name="ct"></param>
+        /// <returns></returns>
+        public async Task InvokeRecActionFakeAsync(CancellationToken ct = default)
+        {
+            var resp = await _http.PostAsync($"api/RecAction/invoke/fake", content: null, ct);
+            resp.EnsureSuccessStatusCode();
+        }
     }
-}
+}
\ No newline at end of file

From c0c0650feec31d5185a7fe28adf538603b1c3677 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:11:35 +0100
Subject: [PATCH 04/24] Refactor ReCClient to use IHttpClientFactory

Updated ReCClient to use IHttpClientFactory for improved
resource management and testability. Added package
references for `Microsoft.Extensions.Http`, `System.Net.Http`,
and `System.Text.Json` to support HTTP client functionality
and JSON serialization. Included `System.Xml.Linq` for
potential XML-related operations. Updated constructor logic
to create `HttpClient` instances via the factory pattern.
---
 src/ReC.Client/ReC.Client.csproj | 1 +
 src/ReC.Client/ReCClient.cs      | 6 ++++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/ReC.Client/ReC.Client.csproj b/src/ReC.Client/ReC.Client.csproj
index 6b41f2e..0b561b9 100644
--- a/src/ReC.Client/ReC.Client.csproj
+++ b/src/ReC.Client/ReC.Client.csproj
@@ -10,6 +10,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
+	  <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
 	  <PackageReference Include="System.Net.Http" Version="4.3.4" />
 	  <PackageReference Include="System.Text.Json" Version="9.0.11" />
 	</ItemGroup>
diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index e680b72..e314da5 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -1,4 +1,6 @@
 using System.Text.Json;
+using System.Xml.Linq;
+
 #if NETFRAMEWORK
 using System;
 using System.Net.Http;
@@ -14,9 +16,9 @@ namespace ReC.Client
         private readonly HttpClient _http;
         private readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions() { PropertyNameCaseInsensitive = true };
 
-        public ReCClient(HttpClient http)
+        public ReCClient(IHttpClientFactory httpClientFactory)
         {
-            _http = http ?? throw new ArgumentNullException(nameof(http));
+            _http = httpClientFactory.CreateClient();
         }
 
         /// <summary>

From 4ee79d6cd8af966cab2f0ef0bc1fd6dbcccc026d Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:17:45 +0100
Subject: [PATCH 05/24] Refactor ReCClient for cleaner and more flexible design

- Removed unused `System.Xml.Linq` namespace import.
- Simplified code by removing `#if NETFRAMEWORK` directives.
- Added `ClientName` field to uniquely identify HTTP clients.
- Updated constructor to use named HTTP client with `ClientName`.
- Removed unused `_jsonOptions` field for better code clarity.
---
 src/ReC.Client/ReCClient.cs | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index e314da5..adcbf09 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -1,12 +1,9 @@
 using System.Text.Json;
-using System.Xml.Linq;
-
 #if NETFRAMEWORK
 using System;
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
-#else
 #endif
 
 namespace ReC.Client
@@ -14,11 +11,12 @@ namespace ReC.Client
     public class ReCClient
     {
         private readonly HttpClient _http;
-        private readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions() { PropertyNameCaseInsensitive = true };
+
+        public static readonly string ClientName = Guid.NewGuid().ToString();
 
         public ReCClient(IHttpClientFactory httpClientFactory)
         {
-            _http = httpClientFactory.CreateClient();
+            _http = httpClientFactory.CreateClient(ClientName);
         }
 
         /// <summary>

From 8cad1df95dd4b7eea3e5151ee64456685729c0d9 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:23:17 +0100
Subject: [PATCH 06/24] Add DependencyInjection support for ReCClient

Introduced a `DependencyInjection` class in the `ReC.Client`
namespace to enable dependency injection for `ReCClient`.

Added an `AddRecClient` extension method for `IServiceCollection`
to register an `HttpClient` with a configurable `apiUri` as the
base address.

Included conditional `using System;` for .NET Framework
compatibility and added `Microsoft.Extensions.DependencyInjection`
to support DI services.
---
 src/ReC.Client/DependencyInjection.cs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 src/ReC.Client/DependencyInjection.cs

diff --git a/src/ReC.Client/DependencyInjection.cs b/src/ReC.Client/DependencyInjection.cs
new file mode 100644
index 0000000..8e12a67
--- /dev/null
+++ b/src/ReC.Client/DependencyInjection.cs
@@ -0,0 +1,18 @@
+using Microsoft.Extensions.DependencyInjection;
+#if NETFRAMEWORK
+using System;
+#endif
+
+namespace ReC.Client
+{
+    public static class DependencyInjection
+    {
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri)
+        {
+            return services.AddHttpClient(ReCClient.ClientName, client =>
+            {
+                client.BaseAddress = new Uri(apiUri);
+            });
+        }
+    }
+}

From f8dd16454f420f29cbdfb055964242a96df11b7c Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:24:44 +0100
Subject: [PATCH 07/24] Add AddRecClient method and conditional using directive

Added a `using System.Net.Http;` directive within a `#if NETFRAMEWORK` block in `DependencyInjection.cs` to ensure compatibility with .NET Framework.

Introduced the `AddRecClient` extension method in the `DependencyInjection` class to enable custom configuration of `HttpClient` instances via an `Action<HttpClient>` delegate.
---
 src/ReC.Client/DependencyInjection.cs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/ReC.Client/DependencyInjection.cs b/src/ReC.Client/DependencyInjection.cs
index 8e12a67..1b9c122 100644
--- a/src/ReC.Client/DependencyInjection.cs
+++ b/src/ReC.Client/DependencyInjection.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.DependencyInjection;
 #if NETFRAMEWORK
 using System;
+using System.Net.Http;
 #endif
 
 namespace ReC.Client
@@ -14,5 +15,10 @@ namespace ReC.Client
                 client.BaseAddress = new Uri(apiUri);
             });
         }
+
+        public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient)
+        {
+            return services.AddHttpClient(ReCClient.ClientName, configureClient);
+        }
     }
-}
+}
\ No newline at end of file

From 475acc0a563adf4d6cada87097910669ff57f410 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:29:43 +0100
Subject: [PATCH 08/24] Remove InvokeRecActionFakeAsync method

Removed the `InvokeRecActionFakeAsync` method, which was used to invoke a fake RecAction via the `api/RecAction/invoke/fake` endpoint. This method is no longer needed or relevant.

The `InvokeRecActionAsync` method remains in place to handle RecActions for specific profile IDs via the `api/RecAction/invoke/{profileId}` endpoint.
---
 src/ReC.Client/ReCClient.cs | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index adcbf09..d11280f 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -30,16 +30,5 @@ namespace ReC.Client
             var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, ct);
             resp.EnsureSuccessStatusCode();
         }
-
-        /// <summary>
-        /// POST api/RecAction/invoke/fake
-        /// </summary>
-        /// <param name="ct"></param>
-        /// <returns></returns>
-        public async Task InvokeRecActionFakeAsync(CancellationToken ct = default)
-        {
-            var resp = await _http.PostAsync($"api/RecAction/invoke/fake", content: null, ct);
-            resp.EnsureSuccessStatusCode();
-        }
     }
 }
\ No newline at end of file

From 4a1b2214784b358dba795c683d736a6185dd1a87 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:31:17 +0100
Subject: [PATCH 09/24] Rename 'ct' to 'cancellationToken' for clarity

Updated the parameter name in the `InvokeRecActionAsync` method
to `cancellationToken` for better readability and alignment
with standard naming conventions. Adjusted the method signature
and internal usage to reflect this change.
---
 src/ReC.Client/ReCClient.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index d11280f..3482e14 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -23,11 +23,11 @@ namespace ReC.Client
         /// POST api/RecAction/invoke/{profileId}
         /// </summary>
         /// <param name="profileId"></param>
-        /// <param name="ct"></param>
+        /// <param name="cancellationToken"></param>
         /// <returns></returns>
-        public async Task InvokeRecActionAsync(int profileId, CancellationToken ct = default)
+        public async Task InvokeRecActionAsync(int profileId, CancellationToken cancellationToken = default)
         {
-            var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, ct);
+            var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, cancellationToken);
             resp.EnsureSuccessStatusCode();
         }
     }

From b190e4f5e939df5e35978c4fae331e27ea3919b4 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:36:45 +0100
Subject: [PATCH 10/24] Update InvokeRecActionAsync to return success status

The method `InvokeRecActionAsync` in the `ReC.Client` namespace was updated to return a `bool` instead of `Task`. This change allows the method to indicate whether the HTTP request was successful.

- Updated the return type from `Task` to `Task<bool>`.
- Modified the `<returns>` XML documentation to reflect the new behavior.
- Replaced `resp.EnsureSuccessStatusCode()` with `resp.IsSuccessStatusCode` to return the success status directly.
---
 src/ReC.Client/ReCClient.cs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 3482e14..b87c011 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -24,11 +24,11 @@ namespace ReC.Client
         /// </summary>
         /// <param name="profileId"></param>
         /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        public async Task InvokeRecActionAsync(int profileId, CancellationToken cancellationToken = default)
+        /// <returns>True if the request was successful, false otherwise</returns>
+        public async Task<bool> InvokeRecActionAsync(int profileId, CancellationToken cancellationToken = default)
         {
             var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, cancellationToken);
-            resp.EnsureSuccessStatusCode();
+            return resp.IsSuccessStatusCode;
         }
     }
 }
\ No newline at end of file

From 4c8e9be695ed87ed3dd7e113f9e72392accc6abf Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:37:53 +0100
Subject: [PATCH 11/24] Add synchronous InvokeRecAction method

Added a synchronous version of the `InvokeRecAction` method to
the `ReC.Client` namespace in `ReCClient.cs`. This method
invokes the `POST api/RecAction/invoke/{profileId}` endpoint
synchronously using `GetAwaiter().GetResult()` and returns a
boolean indicating success.

Also included XML documentation comments for the new method,
detailing its purpose, parameters, and return value.
---
 src/ReC.Client/ReCClient.cs | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index b87c011..758b2f8 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -30,5 +30,16 @@ namespace ReC.Client
             var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, cancellationToken);
             return resp.IsSuccessStatusCode;
         }
+
+        /// <summary>
+        /// POST api/RecAction/invoke/{profileId} (Synchronous version)
+        /// </summary>
+        /// <param name="profileId"></param>
+        /// <returns>True if the request was successful, false otherwise</returns>
+        public bool InvokeRecAction(int profileId)
+        {
+            var resp = _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null).GetAwaiter().GetResult();
+            return resp.IsSuccessStatusCode;
+        }
     }
 }
\ No newline at end of file

From f4abac1103b43bc71918b95aeef5e9270a4cd6ae Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:39:22 +0100
Subject: [PATCH 12/24] Mark InvokeRecAction as obsolete with guidance

Added the `[Obsolete]` attribute to the `InvokeRecAction` method
in the `ReC.Client` namespace to discourage its use. The attribute
recommends using the `InvokeRecActionAsync` method instead to
avoid potential deadlocks and improve performance.
---
 src/ReC.Client/ReCClient.cs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 758b2f8..4e4bcb8 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -36,6 +36,7 @@ namespace ReC.Client
         /// </summary>
         /// <param name="profileId"></param>
         /// <returns>True if the request was successful, false otherwise</returns>
+        [Obsolete("Use InvokeRecActionAsync instead to avoid potential deadlocks and improve performance.")]
         public bool InvokeRecAction(int profileId)
         {
             var resp = _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null).GetAwaiter().GetResult();

From fb649a5c68904f40f849ae15a7d2c909300d19b6 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:47:28 +0100
Subject: [PATCH 13/24] Add static DI-based ReCClient initialization

Introduced dependency injection to the `ReCClient` class by adding `Microsoft.Extensions.DependencyInjection`. Added a static mechanism for creating and managing a `ReCClient` instance, including a `BuildStaticClient` method to configure the HTTP client and a `Static` property to retrieve the client. Implemented error handling to ensure proper initialization of the static service provider.
---
 src/ReC.Client/ReCClient.cs | 40 +++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 4e4bcb8..138bb72 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -1,4 +1,6 @@
 using System.Text.Json;
+using Microsoft.Extensions.DependencyInjection;
+
 #if NETFRAMEWORK
 using System;
 using System.Net.Http;
@@ -42,5 +44,43 @@ namespace ReC.Client
             var resp = _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null).GetAwaiter().GetResult();
             return resp.IsSuccessStatusCode;
         }
+
+        #region Static
+        private static readonly IServiceCollection Services = new ServiceCollection();
+
+        private static IServiceProvider
+#if nullable
+            ?
+#endif
+            ServiceProvider
+#if nullable
+            = null
+#endif
+            ;
+
+        public static void BuildStaticClient(string apiUri)
+        {
+            if(ServiceProvider != null)
+                throw new InvalidOperationException("Static ServiceProvider is already built.");
+
+            Services.AddHttpClient(ClientName, client =>
+            {
+                client.BaseAddress = new Uri(apiUri);
+            });
+            ServiceProvider = Services.BuildServiceProvider();
+        }
+
+        public static ReCClient Static 
+        { 
+            get
+            {
+                if (ServiceProvider == null)
+                    throw new InvalidOperationException("Static ServiceProvider is not built. Call BuildStaticClient first.");
+
+                var httpClientFactory = ServiceProvider.GetRequiredService<IHttpClientFactory>();
+                return new ReCClient(httpClientFactory);
+            } 
+        }
+        #endregion
     }
 }
\ No newline at end of file

From 71368e5c856c33af44d812889803fee1b2360d30 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:51:03 +0100
Subject: [PATCH 14/24] Refactor ServiceProvider with conditional compilation

Updated the `ServiceProvider` field in the `ReC.Client` namespace to use conditional compilation for framework-specific behavior:
- Added `NET8_0_OR_GREATER` directive to define `ServiceProvider` as nullable (`IServiceProvider?`) for .NET 8.0 or greater.
- Retained non-nullable `IServiceProvider` for other frameworks.
- Removed redundant `#if nullable` directives to simplify the code.
- Streamlined initialization logic for better clarity and maintainability.
---
 src/ReC.Client/ReCClient.cs | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 138bb72..9f81ff7 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -48,15 +48,11 @@ namespace ReC.Client
         #region Static
         private static readonly IServiceCollection Services = new ServiceCollection();
 
-        private static IServiceProvider
-#if nullable
-            ?
+#if NET8_0_OR_GREATER
+        private static IServiceProvider? ServiceProvider = null;
+#else
+        private static IServiceProvider ServiceProvider = null;
 #endif
-            ServiceProvider
-#if nullable
-            = null
-#endif
-            ;
 
         public static void BuildStaticClient(string apiUri)
         {

From 10fc56b26285ed6830804794578bdfd30f921e45 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:52:25 +0100
Subject: [PATCH 15/24] Refactor: Rename ServiceProvider to Provider

Renamed the static field `ServiceProvider` to `Provider` across
the `ReC.Client` namespace in `ReCClient.cs` for consistency
and clarity. Updated all occurrences, including declarations,
usages, and exception messages. Adjusted conditional compilation
blocks to reflect the new name. Ensured the `BuildStaticClient`
method and `Static` property use the renamed field appropriately.
---
 src/ReC.Client/ReCClient.cs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 9f81ff7..586f5fc 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -49,31 +49,31 @@ namespace ReC.Client
         private static readonly IServiceCollection Services = new ServiceCollection();
 
 #if NET8_0_OR_GREATER
-        private static IServiceProvider? ServiceProvider = null;
+        private static IServiceProvider? Provider = null;
 #else
-        private static IServiceProvider ServiceProvider = null;
+        private static IServiceProvider Provider = null;
 #endif
 
         public static void BuildStaticClient(string apiUri)
         {
-            if(ServiceProvider != null)
-                throw new InvalidOperationException("Static ServiceProvider is already built.");
+            if(Provider != null)
+                throw new InvalidOperationException("Static Provider is already built.");
 
             Services.AddHttpClient(ClientName, client =>
             {
                 client.BaseAddress = new Uri(apiUri);
             });
-            ServiceProvider = Services.BuildServiceProvider();
+            Provider = Services.BuildServiceProvider();
         }
 
         public static ReCClient Static 
         { 
             get
             {
-                if (ServiceProvider == null)
-                    throw new InvalidOperationException("Static ServiceProvider is not built. Call BuildStaticClient first.");
+                if (Provider == null)
+                    throw new InvalidOperationException("Static Provider is not built. Call BuildStaticClient first.");
 
-                var httpClientFactory = ServiceProvider.GetRequiredService<IHttpClientFactory>();
+                var httpClientFactory = Provider.GetRequiredService<IHttpClientFactory>();
                 return new ReCClient(httpClientFactory);
             } 
         }

From 91c8b98f44f2262ff3011ab136e6efe0ad0f14ff Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:54:16 +0100
Subject: [PATCH 16/24] Refactor ReCClient.Static to Create() method

Replaced the `ReCClient.Static` property with a `ReCClient.Create()` method to improve clarity and align with best practices. The new method retains the same functionality, including throwing an `InvalidOperationException` if the `Provider` is not built. The logic for retrieving the `IHttpClientFactory` and creating a `ReCClient` instance remains unchanged.
---
 src/ReC.Client/ReCClient.cs | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 586f5fc..bde38c9 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -66,16 +66,13 @@ namespace ReC.Client
             Provider = Services.BuildServiceProvider();
         }
 
-        public static ReCClient Static 
-        { 
-            get
-            {
-                if (Provider == null)
-                    throw new InvalidOperationException("Static Provider is not built. Call BuildStaticClient first.");
+        public static ReCClient Create()
+        {
+            if (Provider == null)
+                throw new InvalidOperationException("Static Provider is not built. Call BuildStaticClient first.");
 
-                var httpClientFactory = Provider.GetRequiredService<IHttpClientFactory>();
-                return new ReCClient(httpClientFactory);
-            } 
+            var httpClientFactory = Provider.GetRequiredService<IHttpClientFactory>();
+            return new ReCClient(httpClientFactory);
         }
         #endregion
     }

From 5f9e716ca6f65ef3311ecd99baf1c56514549ec1 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Fri, 5 Dec 2025 23:59:11 +0100
Subject: [PATCH 17/24] Enhance ReC.Client library with new features and
 cleanup

- Added comprehensive XML documentation for `DependencyInjection`
  and `ReCClient` classes to improve code readability.
- Introduced overload for `AddRecClient` to allow flexible
  `HttpClient` configuration.
- Added static `BuildStaticClient` and `Create` methods for
  simplified client instantiation.
- Marked synchronous `InvokeRecAction` method as obsolete to
  encourage asynchronous usage.
- Updated `ReC.Client.csproj`:
  - Added `<DocumentationFile>` property for XML doc generation.
  - Downgraded `Microsoft.Extensions.Http` to version 8.0.0.
  - Removed `System.Text.Json` package reference.
- Removed `System.Text.Json` dependency from `ReCClient.cs`.
- Generated unique `HttpClient` name for `ReCClient` instances.
- Performed general code cleanup and improved method remarks.
---
 src/ReC.Client/DependencyInjection.cs | 15 +++++++++
 src/ReC.Client/ReC.Client.csproj      |  4 +--
 src/ReC.Client/ReCClient.cs           | 47 ++++++++++++++++++++++-----
 3 files changed, 55 insertions(+), 11 deletions(-)

diff --git a/src/ReC.Client/DependencyInjection.cs b/src/ReC.Client/DependencyInjection.cs
index 1b9c122..aa1ddd5 100644
--- a/src/ReC.Client/DependencyInjection.cs
+++ b/src/ReC.Client/DependencyInjection.cs
@@ -6,8 +6,17 @@ using System.Net.Http;
 
 namespace ReC.Client
 {
+    /// <summary>
+    /// Provides extension methods for setting up the ReC client in an <see cref="IServiceCollection"/>.
+    /// </summary>
     public static class DependencyInjection
     {
+        /// <summary>
+        /// Adds and configures the <see cref="HttpClient"/> for the <see cref="ReCClient"/> to the specified <see cref="IServiceCollection"/>
+        /// </summary>
+        /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
+        /// <param name="apiUri">The base URI of the ReC API.</param>
+        /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
         public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri)
         {
             return services.AddHttpClient(ReCClient.ClientName, client =>
@@ -16,6 +25,12 @@ namespace ReC.Client
             });
         }
 
+        /// <summary>
+        /// Adds and configures the <see cref="HttpClient"/> for the <see cref="ReCClient"/> to the specified <see cref="IServiceCollection"/>
+        /// </summary>
+        /// <param name="services">The <see cref="IServiceCollection"/> to add the services to.</param>
+        /// <param name="configureClient">An action to configure the <see cref="HttpClient"/>.</param>
+        /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
         public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient)
         {
             return services.AddHttpClient(ReCClient.ClientName, configureClient);
diff --git a/src/ReC.Client/ReC.Client.csproj b/src/ReC.Client/ReC.Client.csproj
index 0b561b9..ea6f807 100644
--- a/src/ReC.Client/ReC.Client.csproj
+++ b/src/ReC.Client/ReC.Client.csproj
@@ -2,6 +2,7 @@
 
 	<PropertyGroup>
 		<TargetFrameworks>net462;net8.0</TargetFrameworks>
+		<DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(MSBuildProjectName).xml</DocumentationFile>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(TargetFramework)' != 'net462'">
@@ -10,8 +11,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
-	  <PackageReference Include="Microsoft.Extensions.Http" Version="10.0.0" />
+	  <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
 	  <PackageReference Include="System.Net.Http" Version="4.3.4" />
-	  <PackageReference Include="System.Text.Json" Version="9.0.11" />
 	</ItemGroup>
 </Project>
diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index bde38c9..9a7faf1 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -1,5 +1,4 @@
-using System.Text.Json;
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 
 #if NETFRAMEWORK
 using System;
@@ -10,23 +9,36 @@ using System.Threading.Tasks;
 
 namespace ReC.Client
 {
+    /// <summary>
+    /// A client for interacting with the ReC API.
+    /// </summary>
     public class ReCClient
     {
         private readonly HttpClient _http;
 
+        /// <summary>
+        /// A unique name for the HttpClient used by the ReCClient.
+        /// </summary>
         public static readonly string ClientName = Guid.NewGuid().ToString();
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReCClient"/> class.
+        /// </summary>
+        /// <param name="httpClientFactory">The factory to create HttpClients.</param>
         public ReCClient(IHttpClientFactory httpClientFactory)
         {
             _http = httpClientFactory.CreateClient(ClientName);
         }
 
         /// <summary>
-        /// POST api/RecAction/invoke/{profileId}
+        /// Asynchronously invokes a ReC action for a specific profile.
         /// </summary>
-        /// <param name="profileId"></param>
-        /// <param name="cancellationToken"></param>
-        /// <returns>True if the request was successful, false otherwise</returns>
+        /// <remarks>
+        /// This method sends a POST request to the <c>api/RecAction/invoke/{profileId}</c> endpoint.
+        /// </remarks>
+        /// <param name="profileId">The ID of the profile to invoke the action for.</param>
+        /// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
+        /// <returns>A <see cref="Task{TResult}"/> that represents the asynchronous operation. The task result is <see langword="true"/> if the request was successful; otherwise, <see langword="false"/>.</returns>
         public async Task<bool> InvokeRecActionAsync(int profileId, CancellationToken cancellationToken = default)
         {
             var resp = await _http.PostAsync($"api/RecAction/invoke/{profileId}", content: null, cancellationToken);
@@ -34,10 +46,14 @@ namespace ReC.Client
         }
 
         /// <summary>
-        /// POST api/RecAction/invoke/{profileId} (Synchronous version)
+        /// Synchronously invokes a ReC action for a specific profile.
         /// </summary>
-        /// <param name="profileId"></param>
-        /// <returns>True if the request was successful, false otherwise</returns>
+        /// <remarks>
+        /// This method sends a POST request to the <c>api/RecAction/invoke/{profileId}</c> endpoint.
+        /// This is the synchronous version of <see cref="InvokeRecActionAsync(int, CancellationToken)"/>.
+        /// </remarks>
+        /// <param name="profileId">The ID of the profile to invoke the action for.</param>
+        /// <returns><see langword="true"/> if the request was successful; otherwise, <see langword="false"/>.</returns>
         [Obsolete("Use InvokeRecActionAsync instead to avoid potential deadlocks and improve performance.")]
         public bool InvokeRecAction(int profileId)
         {
@@ -54,6 +70,14 @@ namespace ReC.Client
         private static IServiceProvider Provider = null;
 #endif
 
+        /// <summary>
+        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be called once during application startup.
+        /// </remarks>
+        /// <param name="apiUri">The base URI of the ReC API.</param>
+        /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
         public static void BuildStaticClient(string apiUri)
         {
             if(Provider != null)
@@ -66,6 +90,11 @@ namespace ReC.Client
             Provider = Services.BuildServiceProvider();
         }
 
+        /// <summary>
+        /// Creates a new <see cref="ReCClient"/> instance using the statically configured provider.
+        /// </summary>
+        /// <returns>A new instance of the <see cref="ReCClient"/>.</returns>
+        /// <exception cref="InvalidOperationException">Thrown if <see cref="BuildStaticClient(string)"/> has not been called yet.</exception>
         public static ReCClient Create()
         {
             if (Provider == null)

From 4a7f2a41fa91494ffdbff3dea50dca050462596b Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:02:30 +0100
Subject: [PATCH 18/24] Mark static provider methods as obsolete

The `BuildStaticClient` and `Create` methods in the `ReC.Client` namespace have been marked with the `[Obsolete]` attribute. These methods now include a message advising developers to use a local service collection instead of the static provider. This change serves as a warning that these methods are outdated and may be removed in future versions, encouraging a transition to a more modern design.
---
 src/ReC.Client/ReCClient.cs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 9a7faf1..795bb00 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -78,6 +78,7 @@ namespace ReC.Client
         /// </remarks>
         /// <param name="apiUri">The base URI of the ReC API.</param>
         /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
+        [Obsolete("Use a local service collection instead of the static provider.")]
         public static void BuildStaticClient(string apiUri)
         {
             if(Provider != null)
@@ -95,6 +96,7 @@ namespace ReC.Client
         /// </summary>
         /// <returns>A new instance of the <see cref="ReCClient"/>.</returns>
         /// <exception cref="InvalidOperationException">Thrown if <see cref="BuildStaticClient(string)"/> has not been called yet.</exception>
+        [Obsolete("Use a local service collection instead of the static provider.")]
         public static ReCClient Create()
         {
             if (Provider == null)

From 23ef1a5797e88fa1304fa71138c408997dbd9a74 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:10:08 +0100
Subject: [PATCH 19/24] Add scoped ReCClient and update project dependencies

Added `services.AddScoped<ReCClient>()` to both `AddRecClient`
method overloads in `DependencyInjection.cs` to ensure proper
scoped registration of `ReCClient`.

Updated `ReC.Client.csproj` to include necessary package
references for dependency injection and HTTP client support:
- `Microsoft.Extensions.DependencyInjection` (v10.0.0)
- `Microsoft.Extensions.Http` (v8.0.0)
- `System.Net.Http` (v4.3.4)
---
 src/ReC.Client/DependencyInjection.cs | 2 ++
 src/ReC.Client/ReC.Client.csproj      | 1 +
 2 files changed, 3 insertions(+)

diff --git a/src/ReC.Client/DependencyInjection.cs b/src/ReC.Client/DependencyInjection.cs
index aa1ddd5..d747007 100644
--- a/src/ReC.Client/DependencyInjection.cs
+++ b/src/ReC.Client/DependencyInjection.cs
@@ -19,6 +19,7 @@ namespace ReC.Client
         /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
         public static IHttpClientBuilder AddRecClient(this IServiceCollection services, string apiUri)
         {
+            services.AddScoped<ReCClient>();
             return services.AddHttpClient(ReCClient.ClientName, client =>
             {
                 client.BaseAddress = new Uri(apiUri);
@@ -33,6 +34,7 @@ namespace ReC.Client
         /// <returns>An <see cref="IHttpClientBuilder"/> that can be used to configure the client.</returns>
         public static IHttpClientBuilder AddRecClient(this IServiceCollection services, Action<HttpClient> configureClient)
         {
+            services.AddScoped<ReCClient>();
             return services.AddHttpClient(ReCClient.ClientName, configureClient);
         }
     }
diff --git a/src/ReC.Client/ReC.Client.csproj b/src/ReC.Client/ReC.Client.csproj
index ea6f807..db8b30f 100644
--- a/src/ReC.Client/ReC.Client.csproj
+++ b/src/ReC.Client/ReC.Client.csproj
@@ -11,6 +11,7 @@
 	</PropertyGroup>
 
 	<ItemGroup>
+	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
 	  <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />
 	  <PackageReference Include="System.Net.Http" Version="4.3.4" />
 	</ItemGroup>

From 3f7ebdb632739f23ba16044b5eed5685632796f7 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:10:50 +0100
Subject: [PATCH 20/24] Simplify ReCClient instantiation in Create method

Refactored the `Create` method in the `ReCClient` class to directly resolve a `ReCClient` instance from the dependency injection container using `Provider.GetRequiredService<ReCClient>()`.

Removed the intermediate step of retrieving an `IHttpClientFactory` and manually creating a `ReCClient` object. This change reduces boilerplate code and assumes `ReCClient` is already registered in the container, improving maintainability.
---
 src/ReC.Client/ReCClient.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 795bb00..59218e8 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -102,8 +102,7 @@ namespace ReC.Client
             if (Provider == null)
                 throw new InvalidOperationException("Static Provider is not built. Call BuildStaticClient first.");
 
-            var httpClientFactory = Provider.GetRequiredService<IHttpClientFactory>();
-            return new ReCClient(httpClientFactory);
+            return Provider.GetRequiredService<ReCClient>();
         }
         #endregion
     }

From 470902911ea0c22c76392f33952cbd7e2ba9ca38 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:12:36 +0100
Subject: [PATCH 21/24] Refactor HTTP client setup in BuildStaticClient

Simplified the HTTP client configuration in the `BuildStaticClient` method of the `ReC.Client` namespace. Replaced the explicit use of `Services.AddHttpClient` with a call to `Services.AddRecClient(apiUri)`. This change improves code readability and reusability by encapsulating the HTTP client setup logic in a dedicated method or extension.
---
 src/ReC.Client/ReCClient.cs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 59218e8..92e6cb8 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -84,10 +84,7 @@ namespace ReC.Client
             if(Provider != null)
                 throw new InvalidOperationException("Static Provider is already built.");
 
-            Services.AddHttpClient(ClientName, client =>
-            {
-                client.BaseAddress = new Uri(apiUri);
-            });
+            Services.AddRecClient(apiUri);
             Provider = Services.BuildServiceProvider();
         }
 

From bdd78be66ce0f2097e54c92cef4350b972162715 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:13:50 +0100
Subject: [PATCH 22/24] Add static BuildStaticClient method with Obsolete
 warning

A new static method `BuildStaticClient(Action<HttpClient> configureClient)`
was added to the `ReC.Client` namespace in `ReCClient.cs`. This method
configures and builds a static `IServiceProvider` for creating `ReCClient`
instances. It includes XML documentation detailing its purpose, usage,
and parameters, and warns that it should only be called once during
application startup.

The method accepts an `Action<HttpClient>` parameter for `HttpClient`
configuration and throws an `InvalidOperationException` if the static
provider is already built. It is marked `[Obsolete]` to encourage the
use of a local service collection instead of the static provider.

Additionally, the XML documentation for the `ReCClient` creation method
was updated to reference the new `BuildStaticClient` method.
---
 src/ReC.Client/ReCClient.cs | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/ReC.Client/ReCClient.cs b/src/ReC.Client/ReCClient.cs
index 92e6cb8..4249c15 100644
--- a/src/ReC.Client/ReCClient.cs
+++ b/src/ReC.Client/ReCClient.cs
@@ -88,6 +88,24 @@ namespace ReC.Client
             Provider = Services.BuildServiceProvider();
         }
 
+        /// <summary>
+        /// Configures and builds the static <see cref="IServiceProvider"/> for creating <see cref="ReCClient"/> instances.
+        /// </summary>
+        /// <remarks>
+        /// This method should only be called once during application startup.
+        /// </remarks>
+        /// <param name="configureClient">An action to configure the <see cref="HttpClient"/>.</param>
+        /// <exception cref="InvalidOperationException">Thrown if the static provider has already been built.</exception>
+        [Obsolete("Use a local service collection instead of the static provider.")]
+        public static void BuildStaticClient(Action<HttpClient> configureClient)
+        {
+            if (Provider != null)
+                throw new InvalidOperationException("Static Provider is already built.");
+
+            Services.AddRecClient(configureClient);
+            Provider = Services.BuildServiceProvider();
+        }
+
         /// <summary>
         /// Creates a new <see cref="ReCClient"/> instance using the statically configured provider.
         /// </summary>

From 1f8142852e8841315001e60e98132c39a6e37c43 Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:41:48 +0100
Subject: [PATCH 23/24] Add packaging metadata and solution items project

Added a new "Solution Items" project to the solution file, including an `assets/icon.png` file. Updated `ReC.Client.csproj` with packaging metadata such as `PackageId`, `Authors`, `Company`, and `Version`. Included `icon.png` in the package and updated `<TargetFrameworks>` to support `net8.0`. Added the `icon.png` file to the project.
---
 ReC.sln                          |   5 +++++
 assets/icon.png                  | Bin 0 -> 7244 bytes
 src/ReC.Client/ReC.Client.csproj |  18 ++++++++++++++++++
 3 files changed, 23 insertions(+)
 create mode 100644 assets/icon.png

diff --git a/ReC.sln b/ReC.sln
index 2f6d98d..7ca5a04 100644
--- a/ReC.sln
+++ b/ReC.sln
@@ -15,6 +15,11 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReC.Application", "src\ReC.
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ReC.Client", "src\ReC.Client\ReC.Client.csproj", "{DA3A6BDD-8045-478F-860B-D1F0EB97F02B}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{8EC462FD-D22E-90A8-E5CE-7E832BA40C5D}"
+	ProjectSection(SolutionItems) = preProject
+		assets\icon.png = assets\icon.png
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
diff --git a/assets/icon.png b/assets/icon.png
new file mode 100644
index 0000000000000000000000000000000000000000..d1ea69e153f6b844b5c41bfe7706a3b6134176fd
GIT binary patch
literal 7244
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

literal 0
HcmV?d00001

diff --git a/src/ReC.Client/ReC.Client.csproj b/src/ReC.Client/ReC.Client.csproj
index db8b30f..7ff09ef 100644
--- a/src/ReC.Client/ReC.Client.csproj
+++ b/src/ReC.Client/ReC.Client.csproj
@@ -3,6 +3,17 @@
 	<PropertyGroup>
 		<TargetFrameworks>net462;net8.0</TargetFrameworks>
 		<DocumentationFile>bin\$(Configuration)\$(TargetFramework)\$(MSBuildProjectName).xml</DocumentationFile>
+		<PackageId>ReC.Client</PackageId>
+		<Authors>Digital Data GmbH</Authors>
+		<Company>Digital Data GmbH</Company>
+		<Product>ReC.Client</Product>
+		<Copyright>Copyright 2025</Copyright>
+		<PackageIcon>icon.png</PackageIcon>
+		<RepositoryUrl>http://git.dd:3000/AppStd/Rec.git</RepositoryUrl>
+		<PackageTags>digital data rec api</PackageTags>
+		<Version>1.0.0-beta</Version>
+		<AssemblyVersion>1.0.0.0</AssemblyVersion>
+		<FileVersion>1.0.0.0</FileVersion>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(TargetFramework)' != 'net462'">
@@ -10,6 +21,13 @@
 		<Nullable>enable</Nullable>
 	</PropertyGroup>
 
+	<ItemGroup>
+	  <None Include="..\..\assets\icon.png">
+	    <Pack>True</Pack>
+	    <PackagePath>\</PackagePath>
+	  </None>
+	</ItemGroup>
+
 	<ItemGroup>
 	  <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
 	  <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.0" />

From 9628b46ba041a58186fc23bdb90cde7ae048bb3c Mon Sep 17 00:00:00 2001
From: Developer 02 <developer02@didaloghe.onmicrosoft.com>
Date: Sat, 6 Dec 2025 00:43:30 +0100
Subject: [PATCH 24/24] Add project description to ReC.Client.csproj

A `<Description>` tag was added to the `ReC.Client.csproj` file.
This tag describes the project as a client library for interacting
with the ReC.API, offering typed HTTP access and DI integration.
This change improves project metadata for better documentation
and package management.
---
 src/ReC.Client/ReC.Client.csproj | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/ReC.Client/ReC.Client.csproj b/src/ReC.Client/ReC.Client.csproj
index 7ff09ef..806b76b 100644
--- a/src/ReC.Client/ReC.Client.csproj
+++ b/src/ReC.Client/ReC.Client.csproj
@@ -14,6 +14,7 @@
 		<Version>1.0.0-beta</Version>
 		<AssemblyVersion>1.0.0.0</AssemblyVersion>
 		<FileVersion>1.0.0.0</FileVersion>
+		<Description>Client-Bibliothek für die Interaktion mit der ReC.API, die typisierten HTTP-Zugriff und DI-Integration bietet.</Description>
 	</PropertyGroup>
 
 	<PropertyGroup Condition="'$(TargetFramework)' != 'net462'">