diff --git a/.docfx/Dockerfile.docfx b/.docfx/Dockerfile.docfx
index 29307d0..14b7583 100644
--- a/.docfx/Dockerfile.docfx
+++ b/.docfx/Dockerfile.docfx
@@ -1,14 +1,16 @@
-FROM --platform=$BUILDPLATFORM nginx:1.27.5-alpine AS base
+ARG NGINX_VERSION=1.29.3-alpine
+
+FROM --platform=$BUILDPLATFORM nginx:${NGINX_VERSION} AS base
RUN rm -rf /usr/share/nginx/html/*
-FROM --platform=$BUILDPLATFORM codebeltnet/docfx:2.78.3 AS build
+FROM --platform=$BUILDPLATFORM codebeltnet/docfx:2.78.4 AS build
ADD [".", "docfx"]
RUN cd docfx; \
docfx build
-FROM nginx:1.27.5-alpine AS final
+FROM nginx:${NGINX_VERSION} AS final
WORKDIR /usr/share/nginx/html
COPY --from=build /build/docfx/wwwroot /usr/share/nginx/html
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..12b771e
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,579 @@
+---
+description: 'Writing Unit Tests in ClassLibrary1'
+applyTo: "**/*.{cs,csproj}"
+---
+
+# Writing Unit Tests in ClassLibrary1
+This document provides instructions for writing unit tests in the ClassLibrary1 codebase. Please follow these guidelines to ensure consistency and maintainability.
+
+## 1. Base Class
+
+**Always inherit from the `Test` base class** for all unit test classes.
+This ensures consistent setup, teardown, and output handling across all tests.
+
+> Important: Do NOT add `using Xunit.Abstractions`. xUnit v3 no longer exposes that namespace; including it is incorrect and will cause compilation errors. Use the `Codebelt.Extensions.Xunit` Test base class and `using Xunit;` as shown in the examples below. If you need access to test output, rely on the Test base class (which accepts the appropriate output helper) rather than importing `Xunit.Abstractions`.
+
+```csharp
+using Codebelt.Extensions.Xunit;
+using Xunit;
+
+namespace Your.Namespace
+{
+ public class YourTestClass : Test
+ {
+ public YourTestClass(ITestOutputHelper output) : base(output)
+ {
+ }
+
+ // Your tests here
+ }
+}
+```
+
+## 2. Test Method Attributes
+
+- Use `[Fact]` for standard unit tests.
+- Use `[Theory]` with `[InlineData]` or other data sources for parameterized tests.
+
+## 3. Naming Conventions
+
+- **Test classes**: End with `Test` (e.g., `DateSpanTest`).
+- **Test methods**: Use descriptive names that state the expected behavior (e.g., `ShouldReturnTrue_WhenConditionIsMet`).
+
+## 4. Assertions
+
+- Use `Assert` methods from xUnit for all assertions.
+- Prefer explicit and expressive assertions (e.g., `Assert.Equal`, `Assert.NotNull`, `Assert.Contains`).
+
+## 5. File and Namespace Organization
+
+- Place test files in the appropriate test project and folder structure.
+- Use namespaces that mirror the source code structure. The namespace of a test file MUST match the namespace of the System Under Test (SUT). Do NOT append ".Tests", ".Benchmarks" or similar suffixes to the namespace. Only the assembly/project name should indicate that the file is a test/benchmark (for example: ClassLibrary1.Foo.Tests assembly, but namespace ClassLibrary1.Foo).
+ - Example: If the SUT class is declared as:
+ ```csharp
+ namespace ClassLibrary1.Foo.Bar
+ {
+ public class Zoo { /* ... */ }
+ }
+ ```
+ then the corresponding unit test class must use the exact same namespace:
+ ```csharp
+ namespace ClassLibrary1.Foo.Bar
+ {
+ public class ZooTest : Test { /* ... */ }
+ }
+ ```
+ - Do NOT use:
+ ```csharp
+ namespace ClassLibrary1.Foo.Bar.Tests { /* ... */ } // ❌
+ namespace ClassLibrary1.Foo.Bar.Benchmarks { /* ... */ } // ❌
+ ```
+- The unit tests for the ClassLibrary1.Foo assembly live in the ClassLibrary1.Foo.Tests assembly.
+- The functional tests for the ClassLibrary1.Foo assembly live in the ClassLibrary1.Foo.FunctionalTests assembly.
+- Test class names end with Test and live in the same namespace as the class being tested, e.g., the unit tests for the Boo class that resides in the ClassLibrary1.Foo assembly would be named BooTest and placed in the ClassLibrary1.Foo namespace in the ClassLibrary1.Foo.Tests assembly.
+- Modify the associated .csproj file to override the root namespace so the compiled namespace matches the SUT. Example:
+ ```xml
+
+ ClassLibrary1.Foo
+
+ ```
+- When generating test scaffolding automatically, resolve the SUT's namespace from the source file (or project/assembly metadata) and use that exact namespace in the test file header.
+
+- Notes:
+ - This rule ensures type discovery and XML doc links behave consistently and reduces confusion when reading tests.
+ - Keep folder structure aligned with the production code layout to make locating SUT <-> test pairs straightforward.
+
+## 6. Example Test
+
+```csharp
+using System;
+using System.Globalization;
+using Codebelt.Extensions.Xunit;
+using Xunit;
+
+namespace ClassLibrary1
+{
+ ///
+ /// Tests for the class.
+ ///
+ public class DateSpanTest : Test
+ {
+ public DateSpanTest(ITestOutputHelper output) : base(output)
+ {
+ }
+
+ [Fact]
+ public void Parse_ShouldGetOneMonthOfDifference_UsingIso8601String()
+ {
+ var start = new DateTime(2021, 3, 5).ToString("O");
+ var end = new DateTime(2021, 4, 5).ToString("O");
+
+ var span = DateSpan.Parse(start, end);
+
+ Assert.Equal("0:01:31:00:00:00.0", span.ToString());
+ Assert.Equal(0, span.Years);
+ Assert.Equal(1, span.Months);
+ Assert.Equal(31, span.Days);
+ Assert.Equal(0, span.Hours);
+ Assert.Equal(0, span.Minutes);
+ Assert.Equal(0, span.Seconds);
+ Assert.Equal(0, span.Milliseconds);
+
+ Assert.Equal(0.08493150684931507, span.TotalYears);
+ Assert.Equal(1, span.TotalMonths);
+ Assert.Equal(31, span.TotalDays);
+ Assert.Equal(744, span.TotalHours);
+ Assert.Equal(44640, span.TotalMinutes);
+ Assert.Equal(2678400, span.TotalSeconds);
+ Assert.Equal(2678400000, span.TotalMilliseconds);
+
+ Assert.Equal(6, span.GetWeeks());
+ Assert.Equal(-1566296493, span.GetHashCode());
+
+ TestOutput.WriteLine(span.ToString());
+ }
+ }
+}
+```
+
+## 7. Additional Guidelines
+
+- Keep tests focused and isolated.
+- Do not rely on external systems except for xUnit itself and Codebelt.Extensions.Xunit (and derived from this).
+- Ensure tests are deterministic and repeatable.
+
+## 8. Test Doubles
+
+- Preferred test doubles include dummies, fakes, stubs and spies if and when the design allows it.
+- Under special circumstances, mock can be used (using Moq library).
+- Before overriding methods, verify that the method is virtual or abstract; this rule also applies to mocks.
+- Never mock IMarshaller; always use a new instance of JsonMarshaller.
+
+---
+description: 'Writing Performance Tests in ClassLibrary1'
+applyTo: "tuning/**, **/*Benchmark*.cs"
+---
+
+# Writing Performance Tests in ClassLibrary1
+This document provides guidance for writing performance tests (benchmarks) in the ClassLibrary1 codebase using BenchmarkDotNet. Follow these guidelines to keep benchmarks consistent, readable, and comparable.
+
+## 1. Naming and Placement
+
+- Place micro- and component-benchmarks under the `tuning/` folder or in projects named `*.Benchmarks`.
+- Place benchmark files in the appropriate benchmark project and folder structure.
+- Use namespaces that mirror the source code structure, e.g. do not suffix with `Benchmarks`.
+- Namespace rule: DO NOT append `.Benchmarks` to the namespace. Benchmarks must live in the same namespace as the production assembly. Example: if the production assembly uses `namespace ClassLibrary1.Security.Cryptography`, the benchmark file should also use:
+ ```
+ namespace ClassLibrary1.Security.Cryptography
+ {
+ public class Sha512256Benchmark { /* ... */ }
+ }
+ ```
+The class name may end with `Benchmark`, but the namespace must match the assembly (no `.Benchmarks` suffix).
+- The benchmarks for the ClassLibrary1.Bar assembly live in the ClassLibrary1.Bar.Benchmarks assembly.
+- Benchmark class names end with Benchmark and live in the same namespace as the class being measured, e.g., the benchmarks for the Zoo class that resides in the ClassLibrary1.Bar assembly would be named ZooBenchmark and placed in the ClassLibrary1.Bar namespace in the ClassLibrary1.Bar.Benchmarks assembly.
+- Modify the associated .csproj file to override the root namespace, e.g., ClassLibrary1.Bar.
+
+## 2. Attributes and Configuration
+
+- Use `BenchmarkDotNet` attributes to express intent and collect relevant metrics:
+ - `[MemoryDiagnoser]` to capture memory allocations.
+ - `[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]` to group related benchmarks.
+ - `[Params]` for input sizes or variations to exercise multiple scenarios.
+ - `[GlobalSetup]` for one-time initialization that's not part of measured work.
+ - `[Benchmark]` on methods representing measured operations; consider `Baseline = true` and `Description` to improve report clarity.
+- Keep benchmark configuration minimal and explicit; prefer in-class attributes over large shared configs unless re-used widely.
+
+## 3. Structure and Best Practices
+
+- Keep benchmarks focused: each `Benchmark` method should measure a single logical operation.
+- Avoid doing expensive setup work inside a measured method; use `[GlobalSetup]`, `[IterationSetup]`, or cached fields instead.
+- Use `Params` to cover micro, mid and macro input sizes (for example: small, medium, large) and verify performance trends across them.
+- Use small, deterministic data sets and avoid external systems (network, disk, DB). If external systems are necessary, mark them clearly and do not include them in CI benchmark runs by default.
+- Capture results that are meaningful: time, allocations, and if needed custom counters. Prefer `MemoryDiagnoser` and descriptive `Description` values.
+
+## 4. Naming Conventions for Methods
+
+- Method names should be descriptive and indicate the scenario, e.g., `Parse_Short`, `ComputeHash_Large`.
+- When comparing implementations, mark one method with `Baseline = true` and use similar names so reports are easy to read.
+
+## 5. Example Benchmark
+
+```csharp
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+
+namespace ClassLibrary1
+{
+ [MemoryDiagnoser]
+ [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+ public class SampleOperationBenchmark
+ {
+ [Params(8, 256, 4096)]
+ public int Count { get; set; }
+
+ private byte[] _payload;
+
+ [GlobalSetup]
+ public void Setup()
+ {
+ _payload = new byte[Count];
+ // deterministic initialization
+ }
+
+ [Benchmark(Baseline = true, Description = "Operation - baseline")]
+ public int Operation_Baseline() => SampleOperation.Process(_payload);
+
+ [Benchmark(Description = "Operation - optimized")]
+ public int Operation_Optimized() => SampleOperation.ProcessOptimized(_payload);
+ }
+}
+```
+
+## 6. Reporting and CI
+
+- Benchmarks are primarily for local and tuning runs; be cautious about running heavy BenchmarkDotNet workloads in CI. Prefer targeted runs or harnesses for CI where appropriate.
+- Keep benchmark projects isolated (e.g., `tuning/*.csproj`) so they don't affect package builds or production artifacts.
+
+## 7. Additional Guidelines
+
+- Keep benchmarks readable and well-documented; add comments explaining non-obvious choices.
+- If a benchmark exposes regressions or optimizations, add a short note in the benchmark file referencing the relevant issue or PR.
+- For any shared helpers for benchmarking, prefer small utility classes inside the `tuning` projects rather than cross-cutting changes to production code.
+
+For further examples, refer to the benchmark files under the `tuning/` folder.
+
+---
+description: 'Writing XML documentation in ClassLibrary1'
+applyTo: "**/*.cs"
+---
+
+# Writing XML documentation in ClassLibrary1
+This document provides instructions for writing XML documentation.
+
+## 1. Documentation Style
+
+- Use the same documentation style as found throughout the codebase.
+- Add XML doc comments to public and protected classes and methods where appropriate.
+- Example:
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Cuemon.Collections.Generic;
+using Cuemon.Configuration;
+using Cuemon.IO;
+using Cuemon.Text;
+
+namespace Cuemon.Security
+{
+ ///
+ /// Represents the base class from which all implementations of hash algorithms and checksums should derive.
+ ///
+ /// The type of the configured options.
+ ///
+ ///
+ ///
+ public abstract class Hash : Hash, IConfigurable where TOptions : ConvertibleOptions, new()
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The which may be configured.
+ protected Hash(Action setup)
+ {
+ Options = Patterns.Configure(setup);
+ }
+
+ ///
+ /// Gets the configured options of this instance.
+ ///
+ /// The configured options of this instance.
+ public TOptions Options { get; }
+
+
+ ///
+ /// The endian-initializer of this instance.
+ ///
+ /// An instance of the configured options.
+ protected sealed override void EndianInitializer(EndianOptions options)
+ {
+ options.ByteOrder = Options.ByteOrder;
+ }
+ }
+
+ ///
+ /// Represents the base class that defines the public facing structure to expose.
+ ///
+ ///
+ public abstract class Hash : IHash
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ protected Hash()
+ {
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(bool input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(byte input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(char input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(DateTime input)
+ {
+ return ComputeHash(Convertible.GetBytes(input));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(DBNull input)
+ {
+ return ComputeHash(Convertible.GetBytes(input));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(decimal input)
+ {
+ return ComputeHash(Convertible.GetBytes(input));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(double input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(short input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(int input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(long input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(sbyte input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(float input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(ushort input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(uint input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(ulong input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// The which may be configured.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(string input, Action setup = null)
+ {
+ return ComputeHash(Convertible.GetBytes(input, setup));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(Enum input)
+ {
+ return ComputeHash(Convertible.GetBytes(input, EndianInitializer));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(params IConvertible[] input)
+ {
+ return ComputeHash(Arguments.ToEnumerableOf(input));
+ }
+
+ ///
+ /// Computes the hash value for the specified sequence of .
+ ///
+ /// The sequence of to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(IEnumerable input)
+ {
+ return ComputeHash(Convertible.GetBytes(input));
+ }
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public abstract HashResult ComputeHash(byte[] input);
+
+ ///
+ /// Computes the hash value for the specified .
+ ///
+ /// The to compute the hash code for.
+ /// A containing the computed hash code of the specified .
+ public virtual HashResult ComputeHash(Stream input)
+ {
+ return ComputeHash(Patterns.SafeInvoke(() => new MemoryStream(), destination =>
+ {
+ Decorator.Enclose(input).CopyStream(destination);
+ return destination;
+ }).ToArray());
+ }
+
+ ///
+ /// Defines the initializer that must implement.
+ ///
+ /// An instance of the configured options.
+ protected abstract void EndianInitializer(EndianOptions options);
+ }
+}
+
+namespace Cuemon.Security
+{
+ ///
+ /// Configuration options for .
+ ///
+ public class FowlerNollVoOptions : ConvertibleOptions
+ {
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ ///
+ /// The following table shows the initial property values for an instance of .
+ ///
+ ///
+ /// Property
+ /// Initial Value
+ ///
+ /// -
+ ///
+ ///
+ ///
+ /// -
+ ///
+ ///
+ ///
+ ///
+ ///
+ public FowlerNollVoOptions()
+ {
+ Algorithm = FowlerNollVoAlgorithm.Fnv1a;
+ ByteOrder = Endianness.BigEndian;
+ }
+
+ ///
+ /// Gets or sets the algorithm of the Fowler-Noll-Vo hash function.
+ ///
+ /// The algorithm of the Fowler-Noll-Vo hash function.
+ public FowlerNollVoAlgorithm Algorithm { get; set; }
+ }
+}
+```
diff --git a/.github/workflows/pipelines.yml b/.github/workflows/ci-pipeline.yml
similarity index 84%
rename from .github/workflows/pipelines.yml
rename to .github/workflows/ci-pipeline.yml
index 3a214af..6229782 100644
--- a/.github/workflows/pipelines.yml
+++ b/.github/workflows/ci-pipeline.yml
@@ -1,12 +1,7 @@
-name: ClassLibrary1 CI/CD Pipeline
+name: ClassLibrary1 CI Pipeline
on:
pull_request:
branches: [main]
- paths-ignore:
- - .codecov/**
- - .docfx/**
- - .nuget/**
- - '**/*.md'
workflow_dispatch:
inputs:
configuration:
@@ -18,13 +13,16 @@ on:
- Debug
- Release
+permissions:
+ contents: read
+
jobs:
build:
name: call-build
strategy:
matrix:
configuration: [Debug, Release]
- uses: codebeltnet/jobs-dotnet-build/.github/workflows/default.yml@v2
+ uses: codebeltnet/jobs-dotnet-build/.github/workflows/default.yml@v3
with:
configuration: ${{ matrix.configuration }}
strong-name-key-filename: classlibrary1.snk
@@ -36,7 +34,7 @@ jobs:
strategy:
matrix:
configuration: [Debug, Release]
- uses: codebeltnet/jobs-dotnet-pack/.github/workflows/default.yml@v2
+ uses: codebeltnet/jobs-dotnet-pack/.github/workflows/default.yml@v3
with:
configuration: ${{ matrix.configuration }}
version: ${{ needs.build.outputs.version }}
@@ -47,9 +45,9 @@ jobs:
strategy:
fail-fast: false
matrix:
- os: [ubuntu-24.04, windows-2022]
+ os: [ubuntu-24.04, windows-2025, ubuntu-24-04-arm, windows-11-arm]
configuration: [Debug, Release]
- uses: codebeltnet/jobs-dotnet-test/.github/workflows/default.yml@v2
+ uses: codebeltnet/jobs-dotnet-test/.github/workflows/default.yml@v3
with:
configuration: ${{ matrix.configuration }}
runs-on: ${{ matrix.os }}
@@ -58,10 +56,10 @@ jobs:
sonarcloud:
name: call-sonarcloud
needs: [build, test]
- uses: codebeltnet/jobs-sonarcloud/.github/workflows/default.yml@v1
+ uses: codebeltnet/jobs-sonarcloud/.github/workflows/default.yml@v3
with:
- organization: geekle
- projectKey: aws-signature-v4
+ organization: yourorg
+ projectKey: classlibrary1
version: ${{ needs.build.outputs.version }}
secrets: inherit
@@ -70,13 +68,13 @@ jobs:
needs: [build, test]
uses: codebeltnet/jobs-codecov/.github/workflows/default.yml@v1
with:
- repository: codebeltnet/aws-signature-v4
+ repository: yourorg/classlibrary1
secrets: inherit
codeql:
name: call-codeql
needs: [build, test]
- uses: codebeltnet/jobs-codeql/.github/workflows/default.yml@v1
+ uses: codebeltnet/jobs-codeql/.github/workflows/default.yml@v3
permissions:
security-events: write
diff --git a/.nuget/ClassLibrary1/PackageReleaseNotes.txt b/.nuget/ClassLibrary1/PackageReleaseNotes.txt
index bacf126..e2457b4 100644
--- a/.nuget/ClassLibrary1/PackageReleaseNotes.txt
+++ b/.nuget/ClassLibrary1/PackageReleaseNotes.txt
@@ -1,5 +1,5 @@
Version: 0.1.0
-Availability: .NET 8
+Availability: .NET 10
# ALM
- CHANGED Dependencies have been upgraded to the latest compatible versions for all supported target frameworks (TFMs)
diff --git a/Directory.Build.props b/Directory.Build.props
index 2f07e61..933c608 100644
--- a/Directory.Build.props
+++ b/Directory.Build.props
@@ -2,6 +2,9 @@
$(MSBuildProjectName.EndsWith('Tests'))
+ $(MSBuildProjectName.EndsWith('Benchmarks'))
+ $(MSBuildProjectDirectory.ToLower().StartsWith('$(MSBuildThisFileDirectory.ToLower())src'))
+ $(MSBuildProjectDirectory.ToLower().StartsWith('$(MSBuildThisFileDirectory.ToLower())tooling'))
$([MSBuild]::IsOSPlatform('Linux'))
$([MSBuild]::IsOSPlatform('Windows'))
true
@@ -14,9 +17,9 @@
true
-
- net8.0
- Copyright © ClassLibrary1 2024. All rights reserved.
+
+ net10.0
+ Copyright © ClassLibrary1 2025. All rights reserved.
ClassLibrary1
ClassLibrary1
ClassLibrary1
@@ -34,43 +37,60 @@
true
true
$(MSBuildThisFileDirectory)ClassLibrary1.snk
- 7035,CA2260
+ true
+ latest
+ Recommended
+ 7035,CA2260,S6618
+ v
+ true
-
+
- net8.0
+ net10.0
- net8.0
+ net10.0
false
+ Exe
false
false
false
true
- 0
none
- NU1701,NETSDK1206
+ NU1701,NU1902,NU1903
false
+ false
+ true
+
+
+
+ 0
+
+
+
+ false
+ Exe
+ true
-
-
+
+
all
@@ -80,7 +100,19 @@
all
runtime; build; native; contentfiles; analyzers; buildtransitive
-
+
+
+
+
+
+
+
+ net10.0
+
+
+
+
+
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 3a55d32..536d017 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -3,13 +3,15 @@
true
+
+
-
-
-
+
+
+
\ No newline at end of file
diff --git a/testenvironments.json b/testenvironments.json
index 0214cf5..2bc34cb 100644
--- a/testenvironments.json
+++ b/testenvironments.json
@@ -9,7 +9,7 @@
{
"name": "Docker-Ubuntu",
"type": "docker",
- "dockerImage": "gimlichael/ubuntu-testrunner:net8.0.409-9.0.300"
+ "dockerImage": "gimlichael/ubuntu-testrunner:net8.0.416-9.0.307-10.0.100"
}
]
}