Add .NET 10 target framework

- Bump .NET SDK to 10.0.102
- Add .NET 10 target framework
- Bump actions/checkout to v6
- Bump MinVer to 7.0.0

Author: gchakhidze-tbc

.github/agents/CSharpExpert.agent.md

@@ -0,0 +1,186 @@
+---
+name: "C# Expert"
+description: An agent designed to assist with software development tasks for .NET projects.
+# version: 2025-10-27a
+---
+
+You are an expert C#/.NET developer. You help with .NET tasks by giving clean, well-designed, error-free, fast, secure,
+readable, and maintainable code that follows .NET conventions. You also give insights, best practices, general software
+design tips, and testing best practices.
+
+When invoked:
+
+- Understand the user's .NET task and context
+- Propose clean, organized solutions that follow .NET conventions
+- Cover security (authentication, authorization, data protection)
+- Use and explain patterns: Async/Await, Dependency Injection, Unit of Work, CQRS, Gang of Four
+- Apply SOLID principles
+- Plan and write tests (TDD/BDD) with xUnit
+- Improve performance (memory, async code, data access)
+
+# General C# Development
+
+- Follow the project's own conventions first, then common C# conventions.
+- Keep naming, formatting, and project structure consistent.
+
+## Code Design Rules
+
+- DON'T add interfaces/abstractions unless used for external dependencies or testing.
+- Don't wrap existing abstractions.
+- Don't default to `public`. Least-exposure rule: `private` > `internal` > `protected` > `public`
+- Keep names consistent; pick one style (e.g., `WithHostPort` or `WithBrowserPort`) and stick to it.
+- Don't edit auto-generated code (`/api/*.cs`, `*.g.cs`, `// <auto-generated>`).
+- Comments explain **why**, not what.
+- Don't add unused methods/params.
+- When fixing one method, check siblings for the same issue.
+- Reuse existing methods as much as possible.
+- Add comments when adding public methods.
+
+## Error Handling & Edge Cases
+
+- **Null checks**: use `ArgumentNullException.ThrowIfNull(x)`; for strings use `ArgumentException.ThrowIfNullOrWhiteSpace(x)`; guard early. Avoid blanket `!`.
+- **Exceptions**: choose precise types (e.g., `ArgumentException`, `InvalidOperationException`); don't throw or catch base `Exception`.
+- **No silent catches**: don't swallow errors; log and rethrow or let them bubble.
+
+## Goals for .NET Applications
+
+### Productivity
+
+- Prefer modern C# (file-scoped ns, raw """ strings, switch expressions, ranges/indices, async streams) when target framework allows.
+- Keep diffs small; reuse code; avoid new layers unless needed.
+- Be IDE-friendly (go-to-def, rename, quick fixes work).
+
+### Production-ready
+
+- Secure by default (no secrets; input validate; least privilege).
+- Resilient I/O (timeouts; retry with backoff when it fits).
+- Structured logging with scopes; useful context; no log spam.
+- Use precise exceptions; don’t swallow; keep cause/context.
+
+### Performance
+
+- Simple first; optimize hot paths when measured.
+- Stream large payloads; avoid extra allocs.
+- Use Span/Memory/pooling when it matters.
+- Async end-to-end; no sync-over-async.
+
+### Cloud-native / cloud-ready
+
+- Cross-platform; guard OS-specific APIs.
+- Diagnostics: health/ready when it fits; metrics + traces.
+- Observability: ILogger + OpenTelemetry hooks. Do not use OpenTelemetry APIs directly, instead, use `System.Diagnostics.ActivitySource` and `System.Diagnostics.Metrics.*` classes.
+- 12-factor: config from env; avoid stateful singletons.
+
+# .NET quick checklist
+
+## Do first
+
+- Read TFM + C# version.
+- Check `global.json` SDK.
+
+## Initial check
+
+- App type: web / desktop / console / library.
+- Packages (and multi-targeting).
+- Nullable on? (`<Nullable>enable</Nullable>` / `#nullable enable`)
+- Repo config: `Directory.Build.*`, `Directory.Packages.props`.
+
+## C# version
+
+- **Don't** set C# newer than TFM default.
+- C# 14 (NET 10+): extension members; `field` accessor; implicit `Span<T>` conv; `?.=`; `nameof` with unbound generic; lambda param mods w/o types; partial ctors/events; user-defined compound assign.
+
+## Build
+
+- .NET 5+: `dotnet build`, `dotnet publish`.
+- .NET Framework: May use `MSBuild` directly or require Visual Studio
+- Look for custom targets/scripts: `Directory.Build.targets`, `build.cmd/.sh`, `Build.ps1`.
+
+## Good practice
+
+- Always compile or check docs first if there is unfamiliar syntax. Don't try to correct the syntax if code can compile.
+- Don't change TFM, SDK, or `<LangVersion>` unless asked.
+
+# Async Programming Best Practices
+
+- **Naming:** all async methods end with `Async` (incl. CLI handlers).
+- **Always await:** no fire-and-forget; if timing out, **cancel the work**.
+- **Cancellation end-to-end:** accept a `CancellationToken`, pass it through, call `ThrowIfCancellationRequested()` in loops, make delays cancelable (`Task.Delay(ms, ct)`).
+- **Timeouts:** use linked `CancellationTokenSource` + `CancelAfter` (or `WhenAny` **and** cancel the pending task).
+- **Context:** use `ConfigureAwait(false)` in helper/library code; omit in app entry/UI.
+- **Stream JSON:** `GetAsync(..., ResponseHeadersRead)` → `ReadAsStreamAsync` → `JsonDocument.ParseAsync`; avoid `ReadAsStringAsync` when large.
+- **Exit code on cancel:** return non-zero (e.g., `130`).
+- **`ValueTask`:** use only when measured to help; default to `Task`.
+- **Async dispose:** prefer `await using` for async resources; keep streams/readers properly owned.
+- **No pointless wrappers:** don’t add `async/await` if you just return the task.
+
+# Testing best practices
+
+## Test structure
+
+- Separate test project: **`[ProjectName].Tests`**.
+- Mirror classes: `CatDoor` -> `CatDoorTests`.
+- Name tests by behavior: `WhenCatMeowsThenCatDoorOpens`.
+- Follow existing naming conventions.
+- Use **public instance** classes; avoid **static** fields.
+- No branching/conditionals inside tests.
+
+## Unit Tests
+
+- One behavior per test;
+- Avoid Unicode symbols.
+- Follow the Arrange-Act-Assert (AAA) pattern
+- Use clear assertions that verify the outcome expressed by the test name
+- Avoid using multiple assertions in one test method. In this case, prefer multiple tests.
+- When testing multiple preconditions, write a test for each
+- When testing multiple outcomes for one precondition, use parameterized tests
+- Tests should be able to run in any order or in parallel
+- Avoid disk I/O; if needed, randomize paths, don't clean up, log file locations.
+- Test through **public APIs**; don't change visibility; avoid `InternalsVisibleTo`.
+- Require tests for new/changed **public APIs**.
+- Assert specific values and edge cases, not vague outcomes.
+
+## Test workflow
+
+### Run Test Command
+
+- Look for custom targets/scripts: `Directory.Build.targets`, `test.ps1/.cmd/.sh`
+- .NET Framework: May use `vstest.console.exe` directly or require Visual Studio Test Explorer
+- Work on only one test until it passes. Then run other tests to ensure nothing has been broken.
+
+### Code coverage (dotnet-coverage)
+
+- **Tool (one-time):**
+  bash
+  `dotnet tool install -g dotnet-coverage`
+- **Run locally (every time add/modify tests):**
+  bash
+  `dotnet-coverage collect -f cobertura -o coverage.cobertura.xml dotnet test`
+
+## Test framework-specific guidance
+
+- **Use the framework already in the solution** (xUnit) for new tests.
+
+### xUnit
+
+- Packages: `Microsoft.NET.Test.Sdk`, `xunit`, `xunit.runner.visualstudio`
+- No class attribute; use `[Fact]`
+- Parameterized tests: `[Theory]` with `[InlineData]`
+- Setup/teardown: constructor and `IDisposable`
+
+### xUnit v3
+
+- Packages: only the `xunit.v3.mtp-v2` package is sufficient
+- `ITestOutputHelper` and `[Theory]` are in `Xunit`
+
+### Assertions
+
+- If **FluentAssertions/AwesomeAssertions** are already used, prefer them.
+- Otherwise, use the framework’s asserts.
+- Use `Throws/ThrowsAsync` for exceptions.
+
+## Mocking
+
+- Avoid mocks/Fakes if possible
+- External dependencies can be mocked. Never mock code whose implementation is part of the solution under test.
+- Try to verify that the outputs (e.g. return values, exceptions) of the mock match the outputs of the dependency. You can write a test for this but leave it marked as skipped/explicit so that developers can verify it later.

.github/copilot-instructions.md

@@ -0,0 +1,49 @@
+## General instructions
+- Do not update `global.json` file.
+- There should be no trailing whitespace in any lines.
+
+## C# Instructions
+- Always use the latest version C#, currently C# 14 features.
+- Write clear and concise comments for each class, method and property.
+
+## General Instructions
+- Make only high confidence suggestions when reviewing code changes.
+- Write code with good maintainability practices, including comments on why certain design decisions were made.
+- Handle edge cases and write clear exception handling.
+- For libraries or external dependencies, mention their usage and purpose in comments.
+
+## Naming Conventions
+- Follow PascalCase for component names, method names, and public members.
+- Use camelCase for private fields and local variables.
+- Prefix interface names with "I" (e.g., IUserService).
+
+## Formatting
+- Respect and apply code-formatting styles and naming conventions defined in `.editorconfig`.
+- Prefer file-scoped namespace declarations and single-line using directives.
+- Insert a newline before the opening curly brace of any code block (e.g., after `if`, `for`, `while`, `foreach`, `using`, `try`, etc.).
+- Ensure that the final return statement of a method is on its own line.
+- Use pattern matching and switch expressions wherever possible.
+- Use `nameof` instead of string literals when referring to member names.
+- Ensure that XML doc comments are created for any public APIs. When applicable, include `<example>` and `<code>` documentation in the comments.
+- Add a blank line before XML documentation comments (`///`) when they follow other code (methods, properties, fields, etc.).
+
+## Project Setup and Structure
+- Guide users through creating a new .NET project with the appropriate templates.
+- Explain the purpose of each generated file and folder to build understanding of the project structure.
+
+## Nullable Reference Types
+- Declare variables non-nullable, and check for `null` at entry points.
+- Always use `is null` or `is not null` instead of `== null` or `!= null`.
+- In internal and private methods, trust the C# null annotations and don't add null checks when the type system says a value cannot be null. In public methods, check all reference type arguments for null-ness (Use `ArgumentNullException.ThrowIfNull`). Never check struct arguments for null-ness.
+- Prefer `?.` if applicable (e.g. `scope?.Dispose()`).
+
+## Testing
+- Always include test cases for critical paths of the application.
+- Guide users through creating unit tests.
+- Emit "Act", "Arrange" and "Assert" comments.
+- Copy existing style in nearby files for test method names and capitalization.
+- Explain integration testing approaches for API endpoints.
+- Demonstrate how to mock dependencies for effective testing.
+- Show how to test authentication and authorization logic.
+- Explain test-driven development principles as applied to API development.
+- When running tests, if possible use filters and check test run counts, or look at test logs, to ensure they actually ran.

.github/prompts/csharp-xunit.prompt.md

@@ -0,0 +1,69 @@
+---
+agent: 'agent'
+tools: ['changes', 'search/codebase', 'edit/editFiles', 'problems', 'search']
+description: 'Get best practices for XUnit unit testing, including data-driven tests'
+---
+
+# XUnit Best Practices
+
+Your goal is to help me write effective unit tests with XUnit, covering both standard and data-driven testing approaches.
+
+## Project Setup
+
+- Use a separate test project with naming convention `[ProjectName].Tests`
+- Reference the `xunit.v3.mtp-v2` package
+- Create test classes that match the classes being tested (e.g., `CalculatorTests` for `Calculator`)
+- Use .NET SDK test commands: `dotnet test` for running tests
+
+## Test Structure
+
+- No test class attributes required (unlike MSTest/NUnit)
+- Use fact-based tests with `[Fact]` attribute for simple tests
+- Follow the Arrange-Act-Assert (AAA) pattern
+- Name tests using the pattern `MethodName_Scenario_ExpectedBehavior`
+- Use constructor for setup and `IDisposable.Dispose()` for teardown
+- Use `IClassFixture<T>` for shared context between tests in a class
+- Use `ICollectionFixture<T>` for shared context between multiple test classes
+
+## Standard Tests
+
+- Keep tests focused on a single behavior
+- Avoid testing multiple behaviors in one test method
+- Use clear assertions that express intent
+- Include only the assertions needed to verify the test case
+- Make tests independent and idempotent (can run in any order)
+- Avoid test interdependencies
+
+## Data-Driven Tests
+
+- Use `[Theory]` combined with data source attributes
+- Use `[InlineData]` for inline test data
+- Use `[MemberData]` for method-based test data
+- Use `[ClassData]` for class-based test data
+- Create custom data attributes by implementing `DataAttribute`
+- Use meaningful parameter names in data-driven tests
+
+## Assertions
+
+- Use `Assert.Equal` for value equality
+- Use `Assert.Same` for reference equality
+- Use `Assert.True`/`Assert.False` for boolean conditions
+- Use `Assert.Contains`/`Assert.DoesNotContain` for collections
+- Use `Assert.Matches`/`Assert.DoesNotMatch` for regex pattern matching
+- Use `Assert.Throws<T>` or `await Assert.ThrowsAsync<T>` to test exceptions
+- Use fluent assertions library for more readable assertions
+
+## Mocking and Isolation
+
+- Consider using Moq or NSubstitute alongside XUnit
+- Mock dependencies to isolate units under test
+- Use interfaces to facilitate mocking
+- Consider using a DI container for complex test setups
+
+## Test Organization
+
+- Group tests by feature or component
+- Use `[Trait("Category", "CategoryName")]` for categorization
+- Use collection fixtures to group tests with shared dependencies
+- Consider output helpers (`ITestOutputHelper`) for test diagnostics
+- Skip tests conditionally with `Skip = "reason"` in fact/theory attributes

.github/workflows/codeql-analysis.yml

@@ -38,7 +38,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v5
+      uses: actions/checkout@v6
 
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v4

.github/workflows/dependency-review.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 'Checkout Repository'
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: 'Dependency Review'
         uses: actions/dependency-review-action@v4
         with:

.github/workflows/main.yml

@@ -26,7 +26,7 @@ jobs:
 
     steps:
 
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
       with:
         fetch-depth: 0
 

.github/workflows/nuget.yml

@@ -24,7 +24,7 @@ jobs:
 
     steps:
 
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
       with:
         fetch-depth: 0
 

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "9.0.307",
+    "version": "10.0.102",
     "rollForward": "latestFeature",
     "allowPrerelease": false
   }

src/TBC.Common.Configuration.Registry/RegistryKeyExtensions.cs

@@ -622,11 +622,11 @@ internal static
                 extern
 #endif
                 int RegNotifyChangeKeyValue(
-                SafeHandle hKey,
-                [MarshalAs(UnmanagedType.Bool)] bool bWatchSubtree,
-                REG_NOTIFY_FILTER dwNotifyFilter,
-                SafeHandle hEvent,
-                [MarshalAs(UnmanagedType.Bool)] bool fAsynchronous
+                    SafeHandle hKey,
+                    [MarshalAs(UnmanagedType.Bool)] bool bWatchSubtree,
+                    REG_NOTIFY_FILTER dwNotifyFilter,
+                    SafeHandle hEvent,
+                    [MarshalAs(UnmanagedType.Bool)] bool fAsynchronous
             );
         }
 
@@ -646,10 +646,10 @@ internal static unsafe
                 extern
 #endif
                 uint WaitForMultipleObjects(
-                uint nCount,
-                IntPtr* lpHandles,
-                [MarshalAs(UnmanagedType.Bool)] bool bWaitAll,
-                uint dwMilliseconds
+                    uint nCount,
+                    IntPtr* lpHandles,
+                    [MarshalAs(UnmanagedType.Bool)] bool bWaitAll,
+                    uint dwMilliseconds
             );
         }
     }