chore(release): 1.9.0

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "versionize": {
-      "version": "1.18.0",
+      "version": "1.24.0",
       "commands": [
         "versionize"
       ]

.github/workflows/ci.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        dotnet-version: ['8.0.x', '7.0.x', '6.0.x']
+        dotnet-version: ['8.0.x', '6.0.x']
 
     steps:
       - uses: actions/checkout@v2
@@ -21,7 +21,6 @@ jobs:
         with:
           dotnet-version: |
             6.0.x
-            7.0.x
             8.0.x
       - name: Install dependencies
         run: dotnet restore

Base.Tests/Base.Tests.csproj

@@ -10,6 +10,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+        <PackageReference Include="FakeItEasy" Version="8.2.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0" />
         <PackageReference Include="NUnit" Version="4.1.0" />
         <PackageReference Include="NUnit.Analyzers" Version="4.2.0">

Base.Tests/Structures/DataReaderMaybeExtensionTests.cs

@@ -0,0 +1,465 @@
+using System;
+using System.Data;
+using FakeItEasy;
+using FruityFoundation.Base.Structures;
+using NUnit.Framework;
+
+namespace Base.Tests.Structures;
+
+public class DataReaderMaybeExtensionTests
+{
+	[Test]
+	public void DataReader_TryGetBoolean_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetBoolean(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<bool>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetBoolean_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetBoolean(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetBoolean(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<bool>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(true));
+	}
+
+	[Test]
+	public void DataReader_TryGetByte_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetByte(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<byte>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetByte_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetByte(0))
+			.Returns((byte)25);
+
+		// Act
+		var result = fakeDataReader.TryGetByte(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<byte>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo((byte)25));
+	}
+
+	[Test]
+	public void DataReader_TryGetBytes_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetBytes(0, 0, null, 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetBytes_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetBytes(0, 0, A<byte[]>._, 0, 0))
+			.Returns(25);
+
+		// Act
+		var result = fakeDataReader.TryGetBytes(0, 0, [], 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public void DataReader_TryGetChar_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetChar(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<char>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetChar_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetChar(0))
+			.Returns('b');
+
+		// Act
+		var result = fakeDataReader.TryGetChar(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<char>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo('b'));
+	}
+
+	[Test]
+	public void DataReader_TryGetChars_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetChars(0, 0, null, 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetChars_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetChars(0, 0, A<char[]>._, 0, 0))
+			.Returns(25);
+
+		// Act
+		var result = fakeDataReader.TryGetChars(0, 0, [], 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public void DataReader_TryGetDateTime_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetDateTime(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<DateTime>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetDateTime_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetDateTime(0))
+			.Returns(new DateTime(2024, 05, 03, 17, 21, 0, DateTimeKind.Utc));
+
+		// Act
+		var result = fakeDataReader.TryGetDateTime(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<DateTime>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(new DateTime(2024, 05, 03, 17, 21, 0, DateTimeKind.Utc)));
+	}
+
+	[Test]
+	public void DataReader_TryGetDecimal_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetDecimal(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<decimal>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetDecimal_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetDecimal(0))
+			.Returns(25.0m);
+
+		// Act
+		var result = fakeDataReader.TryGetDecimal(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<decimal>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25.0m));
+	}
+
+	[Test]
+	public void DataReader_TryGetFloat_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetFloat(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<float>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetFloat_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetFloat(0))
+			.Returns(25.0f);
+
+		// Act
+		var result = fakeDataReader.TryGetFloat(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<float>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25.0f));
+	}
+
+	[Test]
+	public void DataReader_TryGetGuid_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetGuid(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<Guid>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetGuid_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetGuid(0))
+			.Returns(Guid.NewGuid());
+
+		// Act
+		var result = fakeDataReader.TryGetGuid(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<Guid>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.Not.EqualTo(Guid.Empty));
+	}
+
+	[Test]
+	public void DataReader_TryGetInt16_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetInt16(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<short>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetInt16_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetInt16(0))
+			.Returns((short)25);
+
+		// Act
+		var result = fakeDataReader.TryGetInt16(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<short>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo((short)25));
+	}
+
+	[Test]
+	public void DataReader_TryGetInt32_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetInt32(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetInt32_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetInt32(0))
+			.Returns(25);
+
+		// Act
+		var result = fakeDataReader.TryGetInt32(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public void DataReader_TryGetInt64_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetInt64(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetInt64_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetInt64(0))
+			.Returns(25);
+
+		// Act
+		var result = fakeDataReader.TryGetInt64(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public void DataReader_TryGetString_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(true);
+
+		// Act
+		var result = fakeDataReader.TryGetString(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<string>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public void DataReader_TryGetString_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = A.Fake<IDataReader>();
+		A.CallTo(() => fakeDataReader.IsDBNull(0))
+			.Returns(false);
+		A.CallTo(() => fakeDataReader.GetString(0))
+			.Returns("banana");
+
+		// Act
+		var result = fakeDataReader.TryGetString(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<string>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo("banana"));
+	}
+}

Base.Tests/Structures/DbDataReaderAsyncMaybeExtensionTests.cs

@@ -0,0 +1,555 @@
+using System;
+using System.Collections;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+using FruityFoundation.Base.Structures;
+using NUnit.Framework;
+
+namespace Base.Tests.Structures;
+
+public class DbDataReaderAsyncMaybeExtensionTests
+{
+	[Test]
+	public async Task DbDataReader_TryGetBooleanAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetBooleanAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<bool>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetBooleanAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithBoolean(true);
+
+		// Act
+		var result = await fakeDataReader.TryGetBooleanAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<bool>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(true));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetByteAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetByteAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<byte>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetByteAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithByte(25);
+
+		// Act
+		var result = await fakeDataReader.TryGetByteAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<byte>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo((byte)25));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetBytesAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetBytesAsync(0, 0, null, 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetBytesAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithBytes(25);
+
+		// Act
+		var result = await fakeDataReader.TryGetBytesAsync(0, 0, [], 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetCharAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetCharAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<char>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetCharAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithChar('b');
+
+		// Act
+		var result = await fakeDataReader.TryGetCharAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<char>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo('b'));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetCharsAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetCharsAsync(0, 0, null, 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetCharsAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithChars(25);
+
+		// Act
+		var result = await fakeDataReader.TryGetCharsAsync(0, 0, [], 0, 0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetDateTimeAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetDateTimeAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<DateTime>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetDateTimeAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithDateTime(new DateTime(2024, 05, 03, 17, 21, 0, DateTimeKind.Utc));
+
+		// Act
+		var result = await fakeDataReader.TryGetDateTimeAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<DateTime>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(new DateTime(2024, 05, 03, 17, 21, 0, DateTimeKind.Utc)));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetDecimalAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetDecimalAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<decimal>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetDecimalAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithDecimal(25.0m);
+
+		// Act
+		var result = await fakeDataReader.TryGetDecimalAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<decimal>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25.0m));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetFloatAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetFloatAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<float>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetFloatAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithFloat(25.0f);
+
+		// Act
+		var result = await fakeDataReader.TryGetFloatAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<float>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25.0f));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetGuidAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetGuidAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<Guid>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetGuidAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithGuid(new Guid("b3e7f4d3-3b7b-4b1b-8e0e-3b1b7b4b3e7f"));
+
+		// Act
+		var result = await fakeDataReader.TryGetGuidAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<Guid>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(new Guid("b3e7f4d3-3b7b-4b1b-8e0e-3b1b7b4b3e7f")));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetInt16Async_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetInt16Async(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<short>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetInt16Async_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithInt16(25);
+
+		// Act
+		var result = await fakeDataReader.TryGetInt16Async(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<short>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo((short)25));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetInt32Async_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetInt32Async(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetInt32Async_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithInt32(25);
+
+		// Act
+		var result = await fakeDataReader.TryGetInt32Async(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetInt64Async_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetInt64Async(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetInt64Async_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithInt64(25L);
+
+		// Act
+		var result = await fakeDataReader.TryGetInt64Async(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<long>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(25));
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetStringAsync_WithDbNull_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.Empty;
+
+		// Act
+		var result = await fakeDataReader.TryGetStringAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<string>>());
+		Assert.That(result.HasValue, Is.False);
+	}
+
+	[Test]
+	public async Task DbDataReader_TryGetStringAsync_WithValue_ReturnsMaybeWithValue()
+	{
+		// Arrange
+		var fakeDataReader = MockDbDataReader.WithString("banana");
+
+		// Act
+		var result = await fakeDataReader.TryGetStringAsync(0);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<string>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo("banana"));
+	}
+
+	private class MockDbDataReader : DbDataReader
+	{
+		private readonly bool _isNull;
+		private readonly Maybe<bool> _boolValue;
+		private readonly Maybe<byte> _byteValue;
+		private readonly Maybe<long> _bytesValue;
+		private readonly Maybe<char> _charValue;
+		private readonly Maybe<long> _charsValue;
+		private readonly Maybe<DateTime> _dateTimeValue;
+		private readonly Maybe<decimal> _decimalValue;
+		private readonly Maybe<float> _floatValue;
+		private readonly Maybe<Guid> _guidValue;
+		private readonly Maybe<short> _int16Value;
+		private readonly Maybe<int> _int32Value;
+		private readonly Maybe<long> _int64Value;
+		private readonly Maybe<string> _stringValue;
+
+		private MockDbDataReader(
+			bool isNull,
+			Maybe<bool> boolValue = default,
+			Maybe<byte> byteValue = default,
+			Maybe<long> bytesValue = default,
+			Maybe<char> charValue = default,
+			Maybe<long> charsValue = default,
+			Maybe<DateTime> dateTimeValue = default,
+			Maybe<decimal> decimalValue = default,
+			Maybe<float> floatValue = default,
+			Maybe<Guid> guidValue = default,
+			Maybe<short> int16Value = default,
+			Maybe<int> int32Value = default,
+			Maybe<long> int64Value = default,
+			Maybe<string> stringValue = default
+		)
+		{
+			_isNull = isNull;
+			_boolValue = boolValue;
+			_byteValue = byteValue;
+			_bytesValue = bytesValue;
+			_charValue = charValue;
+			_charsValue = charsValue;
+			_dateTimeValue = dateTimeValue;
+			_decimalValue = decimalValue;
+			_floatValue = floatValue;
+			_guidValue = guidValue;
+			_int16Value = int16Value;
+			_int32Value = int32Value;
+			_int64Value = int64Value;
+			_stringValue = stringValue;
+			//
+		}
+
+		public static MockDbDataReader Empty => new(isNull: true);
+		public static MockDbDataReader WithBoolean(bool value) => new(isNull: false, boolValue: Maybe.Create(value));
+		public static MockDbDataReader WithByte(byte value) => new(isNull: false, byteValue: Maybe.Create(value));
+		public static MockDbDataReader WithBytes(long value) => new(isNull: false, bytesValue: Maybe.Create(value));
+		public static MockDbDataReader WithChar(char value) => new(isNull: false, charValue: Maybe.Create(value));
+		public static MockDbDataReader WithChars(long value) => new(isNull: false, charsValue: Maybe.Create(value));
+		public static MockDbDataReader WithDateTime(DateTime value) => new(isNull: false, dateTimeValue: Maybe.Create(value));
+		public static MockDbDataReader WithDecimal(decimal value) => new(isNull: false, decimalValue: Maybe.Create(value));
+		public static MockDbDataReader WithFloat(float value) => new(isNull: false, floatValue: Maybe.Create(value));
+		public static MockDbDataReader WithGuid(Guid value) => new(isNull: false, guidValue: Maybe.Create(value));
+		public static MockDbDataReader WithInt16(short value) => new(isNull: false, int16Value: Maybe.Create(value));
+		public static MockDbDataReader WithInt32(int value) => new(isNull: false, int32Value: Maybe.Create(value));
+		public static MockDbDataReader WithInt64(long value) => new(isNull: false, int64Value: Maybe.Create(value));
+		public static MockDbDataReader WithString(string value) => new(isNull: false, stringValue: Maybe.Create(value));
+
+		/// <inheritdoc />
+		public override bool GetBoolean(int ordinal) => _boolValue.Value;
+
+		/// <inheritdoc />
+		public override byte GetByte(int ordinal) => _byteValue.Value;
+
+		/// <inheritdoc />
+		public override long GetBytes(int ordinal, long dataOffset, byte[]? buffer, int bufferOffset, int length) =>
+			_bytesValue.Value;
+
+		/// <inheritdoc />
+		public override char GetChar(int ordinal) => _charValue.Value;
+
+		/// <inheritdoc />
+		public override long GetChars(int ordinal, long dataOffset, char[]? buffer, int bufferOffset, int length) =>
+			_charsValue.Value;
+
+		/// <inheritdoc />
+		public override string GetDataTypeName(int ordinal) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override DateTime GetDateTime(int ordinal) => _dateTimeValue.Value;
+
+		/// <inheritdoc />
+		public override decimal GetDecimal(int ordinal) => _decimalValue.Value;
+
+		/// <inheritdoc />
+		public override double GetDouble(int ordinal) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override Type GetFieldType(int ordinal) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override float GetFloat(int ordinal) => _floatValue.Value;
+
+		/// <inheritdoc />
+		public override Guid GetGuid(int ordinal) => _guidValue.Value;
+
+		/// <inheritdoc />
+		public override short GetInt16(int ordinal) => _int16Value.Value;
+
+		/// <inheritdoc />
+		public override int GetInt32(int ordinal) => _int32Value.Value;
+
+		/// <inheritdoc />
+		public override long GetInt64(int ordinal) => _int64Value.Value;
+
+		/// <inheritdoc />
+		public override string GetName(int ordinal) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override int GetOrdinal(string name) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override string GetString(int ordinal) => _stringValue.Value;
+
+		/// <inheritdoc />
+		public override object GetValue(int ordinal) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override int GetValues(object[] values) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override bool IsDBNull(int ordinal) => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override Task<bool> IsDBNullAsync(int ordinal, CancellationToken cancellationToken) =>
+			Task.FromResult(_isNull);
+
+		/// <inheritdoc />
+		public override int FieldCount => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override object this[int ordinal] => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override object this[string name] => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override int RecordsAffected => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override bool HasRows => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override bool IsClosed => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override bool NextResult() => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override bool Read() => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override int Depth => throw new NotImplementedException();
+
+		/// <inheritdoc />
+		public override IEnumerator GetEnumerator() => throw new NotImplementedException();
+	}
+}

Base.Tests/Structures/MaybeExtensionTests.cs

@@ -9,17 +9,46 @@ namespace Base.Tests.Structures;
 public class MaybeExtensionTests
 {
 	[Test]
-	public void EnumerableFirstOrEmptyTests()
+	public void Enumerable_FirstOrEmpty_WithEmptyEnumerable_ReturnsEmptyMaybe()
 	{
-		Assert.That(Array.Empty<string>().FirstOrEmpty(), Is.EqualTo(Maybe.Empty<string>()));
-		Assert.That(new[] { "banana" }.FirstOrEmpty(), Is.EqualTo(Maybe.Create<string>("banana")));
+		// Arrange
+		var data = Array.Empty<int>();
+
+		// Act
+		var result = data.FirstOrEmpty();
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.False);
 	}
 
 	[Test]
-	public void TestToMaybe()
+	public void Enumerable_FirstOrEmpty_WithMatchingPredicate_ReturnsMaybeWithValue()
 	{
-		Assert.That(Maybe.Empty<int>(), Is.EqualTo(Maybe.Empty<int>()));
-		Assert.That(Maybe.Create(2), Is.Not.EqualTo(Maybe.Create(293921)));
+		// Arrange
+		var data = new[] { 1, 2, 3, 4 };
+
+		// Act
+		var result = data.FirstOrEmpty(x => x > 1);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.True);
+		Assert.That(result.Value, Is.EqualTo(2));
+	}
+
+	[Test]
+	public void Enumerable_FirstOrEmpty_WithNonMatchingPredicate_ReturnsEmptyMaybe()
+	{
+		// Arrange
+		var data = new[] { 1, 2, 3, 4 };
+
+		// Act
+		var result = data.FirstOrEmpty(x => x > 100);
+
+		// Assert
+		Assert.That(result, Is.InstanceOf<Maybe<int>>());
+		Assert.That(result.HasValue, Is.False);
 	}
 
 	[Test]

Base/Base.csproj

@@ -12,7 +12,7 @@
       <Company />
       <Product>FruityFoundation.Base</Product>
       <RepositoryUrl>https://github.com/kyleratti/FruityFoundation</RepositoryUrl>
-      <Version>1.8.1</Version>
+      <Version>1.9.0</Version>
       <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
       <PackageLicenseFile>LICENSE</PackageLicenseFile>
       <AssemblyName>FruityFoundation.Base</AssemblyName>

Base/Base.csproj.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/Daemon/ConfigureAwaitAnalysisMode/@EntryValue">Library</s:String></wpf:ResourceDictionary>

Base/ByteHelper.cs

@@ -1,13 +0,0 @@
-namespace FruityFoundation.Base;
-
-public static class ByteHelper
-{
-	public static long FromKilobytes(long kilobytes) =>
-		kilobytes * 1024;
-
-	public static long FromMegabytes(long megabytes) =>
-		megabytes * 1024 * 1024;
-
-	public static long FromGigabytes(long gigabytes) =>
-		gigabytes * 1024 * 1024 * 1024;
-}

Base/Structures/DataReaderMaybeExtensions.cs

@@ -14,6 +14,9 @@ public static class DataReaderExtensions
 	public static Maybe<long> TryGetBytes(this IDataReader reader, int ord, long fieldOffset, byte[]? buffer, int bufferOffset, int length) =>
 		TryGet(reader, ord, _ => reader.GetBytes(ord, fieldOffset, buffer, bufferOffset, length));
 
+	public static Maybe<char> TryGetChar(this IDataReader reader, int ord) =>
+		TryGet(reader, ord, reader.GetChar);
+
 	public static Maybe<long> TryGetChars(this IDataReader reader, int ord, long fieldOffset, char[]? buffer, int bufferOffset, int length) =>
 		TryGet(reader, ord, _ => reader.GetChars(ord, fieldOffset, buffer, bufferOffset, length));
 

Base/Structures/DbDataReaderMaybeExtensions.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Data.Common;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace FruityFoundation.Base.Structures;
+
+public static class DbDataReaderMaybeExtensions
+{
+	public static async Task<Maybe<bool>> TryGetBooleanAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetBoolean, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<byte>> TryGetByteAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetByte, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<long>> TryGetBytesAsync(this DbDataReader reader, int ord, long fieldOffset,
+		byte[]? buffer, int bufferOffset, int length, CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, _ => reader.GetBytes(ord, fieldOffset, buffer, bufferOffset, length),
+			cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<char>> TryGetCharAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetChar, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<long>> TryGetCharsAsync(this DbDataReader reader, int ord, long fieldOffset,
+		char[]? buffer, int bufferOffset, int length, CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, _ => reader.GetChars(ord, fieldOffset, buffer, bufferOffset, length),
+			cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<DateTime>> TryGetDateTimeAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetDateTime, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<decimal>> TryGetDecimalAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetDecimal, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<float>> TryGetFloatAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetFloat, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<Guid>> TryGetGuidAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetGuid, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<short>> TryGetInt16Async(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetInt16, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<int>> TryGetInt32Async(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetInt32, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<long>> TryGetInt64Async(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetInt64, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	public static async Task<Maybe<string>> TryGetStringAsync(this DbDataReader reader, int ord,
+		CancellationToken cancellationToken = default) =>
+		await TryGetAsync(reader, ord, reader.GetString, cancellationToken)
+			.ConfigureAwait(continueOnCapturedContext: false);
+
+	private static async Task<Maybe<T>> TryGetAsync<T>(DbDataReader reader, int ord, Func<int, T> valueGetter,
+		CancellationToken cancellationToken)
+	{
+		if (await reader.IsDBNullAsync(ord, cancellationToken).ConfigureAwait(continueOnCapturedContext: false))
+			return Maybe.Empty<T>();
+
+		var value = valueGetter(ord);
+
+		return Maybe.Create(value);
+	}
+}

CHANGELOG.md

@@ -1,4 +1,14 @@
 Changelog
+<a name="1.9.0"></a>
+## [1.9.0](https://www.github.com/kyleratti/FruityFoundation/releases/tag/v1.9.0) (2024-05-03)
+
+### Features
+
+* add async extensions support for DbDataReader ([35d1742](https://www.github.com/kyleratti/FruityFoundation/commit/35d1742f00a35712c2be38f0151db343cf1405d3))
+* add cancellation token support to DbDataReaderExtensions ([04f94c2](https://www.github.com/kyleratti/FruityFoundation/commit/04f94c2441fc5f589c8a7ec7f4565f144e2d2d73))
+* add Maybe.TryParse ([b6f2ef3](https://www.github.com/kyleratti/FruityFoundation/commit/b6f2ef3aa6318a25fe771ae8aa7c15eb476d6b07))
+* specify ConfigureAwait(false) on async calls ([190db94](https://www.github.com/kyleratti/FruityFoundation/commit/190db946029f02035fbb7e345bb1210476c39441))
+
 <a name="1.8.1"></a>
 ## [1.8.1](https://www.github.com/kyleratti/FruityFoundation/releases/tag/v1.8.1) (2024-2-8)
 

Db/Db.fsproj

@@ -10,7 +10,7 @@
       <Company />
       <Product>FruityFoudnation.Db</Product>
       <RepositoryUrl>https://github.com/kyleratti/FruityFoundation</RepositoryUrl>
-      <Version>1.8.1</Version>
+      <Version>1.9.0</Version>
       <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
       <PackageLicenseFile>LICENSE</PackageLicenseFile>
       <TargetFrameworks>net6.0;net8.0</TargetFrameworks>

FsBase/FsBase.fsproj

@@ -7,7 +7,7 @@
         <PackageId>FruityFoundation.FsBase</PackageId>
         <Authors>Kyle Ratti</Authors>
         <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
-        <Version>1.8.1</Version>
+        <Version>1.9.0</Version>
         <PackageLicenseFile>LICENSE</PackageLicenseFile>
         <TargetFrameworks>net6.0;net8.0</TargetFrameworks>
         <LangVersion>8.0</LangVersion>