Adds net9 and net10 TFMs, fixes related errors, some of the warnings

arpadbarta · arpadbarta · commit 9721aee6349c · 2025-11-25T20:39:07.000+02:00
diff --git a/PlainBytes.LiteDB.Tests/Database/Contains_Tests.cs b/PlainBytes.LiteDB.Tests/Database/Contains_Tests.cs
@@ -20,10 +20,10 @@ public void ArrayContains_ShouldHaveCount1()
                 var collection = database.GetCollection<ItemWithEnumerable>();
                 collection.Insert(new ItemWithEnumerable
                 {
-                    Array = new int[] { randomValue }
+                    Array = [randomValue]
                 });
 
-                var result = collection.Find(i => i.Array.Contains(randomValue)).ToList();
+                var result = collection.Find(i => i.Array.AsEnumerable().Contains(randomValue)).ToList();
                 result.Should().HaveCount(1);
             }
         }
diff --git a/PlainBytes.LiteDB.Tests/Issues/Issue2471_Test.cs b/PlainBytes.LiteDB.Tests/Issues/Issue2471_Test.cs
@@ -82,7 +82,7 @@ public void Ensure_Query_GetPlan_Releases_Lock()
 
         // doing Phone query
         var queryPhone = col.Query()
-            .Where(x => x.Phones.Contains(3));
+            .Where(x => x.Phones.AsEnumerable().Contains(3));
 
         var planPhone = queryPhone.GetPlan();
 
diff --git a/PlainBytes.LiteDB.Tests/Mapper/LinqBsonExpression_Tests.cs b/PlainBytes.LiteDB.Tests/Mapper/LinqBsonExpression_Tests.cs
@@ -214,12 +214,12 @@ public void Linq_Enumerables()
             TestExpr<User>(x => x.Phones.Last(), "$.Phones[-1]");
 
             // contains
-            TestExpr<User>(x => x.PhoneNumbers.Contains(1234), "PhoneNumbers ANY = @p0", 1234);
-            TestExpr<User>(x => x.Phones2.Contains(new Phone { Number = 1 }), "Phones2 ANY = { Number: @p0 }", 1);
+            TestExpr<User>(x => x.PhoneNumbers.AsEnumerable().Contains(1234), "PhoneNumbers ANY = @p0", 1234);
+            TestExpr<User>(x => x.Phones2.AsEnumerable().Contains(new Phone { Number = 1 }), "Phones2 ANY = { Number: @p0 }", 1);
 
             // negated contains
-            TestExpr<User>(x => !x.PhoneNumbers.Contains(1234), "(PhoneNumbers ANY = @p0) = false", 1234);
-            TestExpr<User>(x => !x.Phones2.Contains(new Phone { Number = 1 }), "(Phones2 ANY = { Number: @p0 }) = false", 1);
+            TestExpr<User>(x => !x.PhoneNumbers.AsEnumerable().Contains(1234), "(PhoneNumbers ANY = @p0) = false", 1234);
+            TestExpr<User>(x => !x.Phones2.AsEnumerable().Contains(new Phone { Number = 1 }), "(Phones2 ANY = { Number: @p0 }) = false", 1);
 
             // fixed position with filter expression
             TestExpr<User>(x => x.Phones.First(p => p.Number == 1), "FIRST(FILTER($.Phones=>(@.Number=@p0)))", 1);
@@ -265,7 +265,7 @@ public void Linq_Predicate()
             var numbersArrayList = new ArrayList() { 1, 2, 3 };
             var numbersBson = new BsonArray(numbersArray.Select(x => new BsonValue(x)));
 
-            TestExpr<User>(x => numbersArray.Contains(x.Id), "@p0 ANY = _id", numbersBson);
+            TestExpr<User>(x => Enumerable.Contains(numbersArray, x.Id), "@p0 ANY = _id", numbersBson);
             TestExpr<User>(x => numbersList.Contains(x.Id), "@p0 ANY = _id", numbersBson);
             TestExpr<User>(x => numbersSet.Contains(x.Id), "@p0 ANY = _id", numbersBson);
             TestExpr<User>(x => numbersArrayList.Contains(x.Id), "@p0 ANY = _id", numbersBson);
@@ -495,8 +495,8 @@ public void Linq_Array_Contains()
             var ids = new int[] { 1, 2, 3 };
             //var ids = new List<int> { 1, 2, 3 }; // works too
 
-            // the result are correct, but can be optimize (in QueryOptimzier) to `$._id IN @p0` (index will be used)
-            TestExpr<User>(x => ids.Contains(x.Id), "@p0 ANY = $._id", new BsonArray { 1, 2, 3 });
+            // the result are correct, but can be optimized (in QueryOptimizer) to `$._id IN @p0` (index will be used)
+            TestExpr<User>(x => Enumerable.Contains(ids, x.Id), "@p0 ANY = $._id", new BsonArray { 1, 2, 3 });
 
             TestExpr<User>(x => ids.Where(q => q == x.Id).Count() > 0, "(COUNT(FILTER(@p0 => (@=$._id))) > @p1)", new BsonArray { 1, 2, 3 }, 0);
         }
diff --git a/PlainBytes.LiteDB.Tests/PlainBytes.LiteDB.Tests.csproj b/PlainBytes.LiteDB.Tests/PlainBytes.LiteDB.Tests.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
+        <TargetFrameworks>net8.0;net9.0;net10.0;</TargetFrameworks>
         <RootNamespace>LiteDB.Tests</RootNamespace>
         <Authors>Maurício David</Authors>
         <Copyright>MIT</Copyright>
diff --git a/PlainBytes.LiteDB/Client/Mapper/Linq/LinqExpressionVisitor.cs b/PlainBytes.LiteDB/Client/Mapper/Linq/LinqExpressionVisitor.cs
@@ -46,6 +46,8 @@ internal class LinqExpressionVisitor : ExpressionVisitor
 
         public LinqExpressionVisitor(BsonMapper mapper, Expression expr)
         {
+            ArgumentNullException.ThrowIfNull(expr);
+            
             _mapper = mapper;
             _expr = expr;
 
@@ -69,17 +71,17 @@ public BsonExpression Resolve(bool predicate)
 
             try
             {
-                var e = BsonExpression.Create(expression, _parameters);
+                var bsonExpression = BsonExpression.Create(expression, _parameters);
 
                 // if expression must return an predicate but expression result is Path/Parameter/Call add `= true`
-                if (predicate && (e.Type == BsonExpressionType.Path || e.Type == BsonExpressionType.Call || e.Type == BsonExpressionType.Parameter))
+                if (predicate && (bsonExpression.Type == BsonExpressionType.Path || bsonExpression.Type == BsonExpressionType.Call || bsonExpression.Type == BsonExpressionType.Parameter))
                 {
                     expression = "(" + expression + " = true)";
 
-                    e = BsonExpression.Create(expression, _parameters);
+                    bsonExpression = BsonExpression.Create(expression, _parameters);
                 }
 
-                return e;
+                return bsonExpression;
             }
             catch (Exception ex)
             {
diff --git a/PlainBytes.LiteDB/Client/Mapper/Linq/ParameterExpressionVisitor.cs b/PlainBytes.LiteDB/Client/Mapper/Linq/ParameterExpressionVisitor.cs
@@ -7,11 +7,11 @@ namespace PlainBytes.LiteDB
     /// </summary>
     internal class ParameterExpressionVisitor : ExpressionVisitor
     {
-        public bool IsParameter { get; private set; } = false;
+        private bool IsParameter { get; set; }
 
         protected override Expression VisitParameter(ParameterExpression node)
         {
-            this.IsParameter = true;
+            IsParameter = true;
 
             return base.VisitParameter(node);
         }
diff --git a/PlainBytes.LiteDB/Engine/Disk/DiskReader.cs b/PlainBytes.LiteDB/Engine/Disk/DiskReader.cs
@@ -59,7 +59,7 @@ private void ReadStream(Stream stream, long position, BufferSlice buffer)
 
             stream.Position = position;
 
-            stream.Read(buffer.Array, buffer.Offset, buffer.Count);
+            stream.ReadExactly(buffer.Array, buffer.Offset, buffer.Count);
 
             DEBUG(buffer.All(0) == false, "check if are not reading out of file length");
         }
diff --git a/PlainBytes.LiteDB/Engine/Disk/DiskService.cs b/PlainBytes.LiteDB/Engine/Disk/DiskService.cs
@@ -241,7 +241,7 @@ internal void MarkAsInvalidState()
                 using (var stream = _dataFactory.GetStream(true, true))
                 {
                     var buffer = _bufferPool.Rent(PAGE_SIZE);
-                    stream.Read(buffer, 0, PAGE_SIZE);
+                    stream.ReadExactly(buffer, 0, PAGE_SIZE);
                     buffer[HeaderPage.P_INVALID_DATAFILE_STATE] = 1;
                     stream.Position = 0;
                     stream.Write(buffer, 0, PAGE_SIZE);
diff --git a/PlainBytes.LiteDB/Engine/Disk/Streams/AesStream.cs b/PlainBytes.LiteDB/Engine/Disk/Streams/AesStream.cs
@@ -23,8 +23,6 @@ public class AesStream : Stream
 
         private readonly byte[] _decryptedZeroes = new byte[16];
 
-        private static readonly byte[] _emptyContent = new byte[PAGE_SIZE - 1 - 16]; // 1 for aes indicator + 16 for salt
-
         private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;
 
         public byte[] Salt { get; }
@@ -83,15 +81,17 @@ public AesStream(string password, Stream stream)
                         throw LiteException.FileNotEncrypted();
                     }
 
-                    _stream.Read(this.Salt, 0, ENCRYPTION_SALT_SIZE);
+                    _stream.ReadExactly(this.Salt, 0, ENCRYPTION_SALT_SIZE);
                 }
 
                 _aes = Aes.Create();
                 _aes.Padding = PaddingMode.None;
                 _aes.Mode = CipherMode.ECB;
 
 #pragma warning disable SYSLIB0041
+#pragma warning disable SYSLIB0060
                 var pdb = new Rfc2898DeriveBytes(password, this.Salt);
+#pragma warning restore SYSLIB0060
 #pragma warning restore SYSLIB0041
 
                 using (pdb as IDisposable)
@@ -114,11 +114,10 @@ public AesStream(string password, Stream stream)
                 // set stream to password checking
                 _stream.Position = 32;
 
-
                 if (!isNew)
                 {
                     // check whether bytes 32 to 64 is empty. This indicates PlainBytes.LiteDB was unable to write encrypted 1s during last attempt.
-                    _stream.Read(checkBuffer, 0, checkBufferSize);
+                    _stream.ReadExactly(checkBuffer, 0, checkBufferSize);
                     isNew = checkBuffer.All(x => x == 0);
 
                     // reset checkBuffer and stream position
@@ -139,7 +138,7 @@ public AesStream(string password, Stream stream)
                 }
                 else
                 {
-                    _reader.Read(checkBuffer, 0, checkBufferSize);
+                    _reader.ReadExactly(checkBuffer, 0, checkBufferSize);
 
                     if (!checkBuffer.All(x => x == 1))
                     {
@@ -152,7 +151,7 @@ public AesStream(string password, Stream stream)
                 using (var ms = new MemoryStream(msBuffer))
                 using (var tempStream = new CryptoStream(ms, _decryptor, CryptoStreamMode.Read))
                 {
-                    tempStream.Read(_decryptedZeroes, 0, _decryptedZeroes.Length);
+                    tempStream.ReadExactly(_decryptedZeroes, 0, _decryptedZeroes.Length);
                 }
             }
             catch
diff --git a/PlainBytes.LiteDB/Engine/Engine/Upgrade.cs b/PlainBytes.LiteDB/Engine/Engine/Upgrade.cs
@@ -31,7 +31,7 @@ private void TryUpgrade()
 
 
                 stream.Position = 0;
-                stream.Read(buffer, 0, bufferSize);
+                stream.ReadExactly(buffer, 0, bufferSize);
 
                 if (FileReaderV7.IsVersion(buffer) == false) return;
             }
diff --git a/PlainBytes.LiteDB/Engine/FileReader/FileReaderV7.cs b/PlainBytes.LiteDB/Engine/FileReader/FileReaderV7.cs
@@ -188,7 +188,7 @@ private BsonDocument ReadPage(uint pageID)
 
             _stream.Position = pageID * V7_PAGE_SIZE; // v7 uses 4k page size
 
-            _stream.Read(_buffer, 0, V7_PAGE_SIZE);
+            _stream.ReadExactly(_buffer, 0, V7_PAGE_SIZE);
 
             // decrypt encrypted page (except header page - header are plain data)
             if (_aes != null && pageID > 0)
diff --git a/PlainBytes.LiteDB/Engine/FileReader/Legacy/AesEncryption.cs b/PlainBytes.LiteDB/Engine/FileReader/Legacy/AesEncryption.cs
@@ -18,7 +18,9 @@ public AesEncryption(string password, byte[] salt)
             _aes.Padding = PaddingMode.Zeros;
 
 #pragma warning disable SYSLIB0041
+#pragma warning disable SYSLIB0060
             var pdb = new Rfc2898DeriveBytes(password, salt);
+#pragma warning restore SYSLIB0060
 #pragma warning restore SYSLIB0041
 
             using (pdb as IDisposable)
@@ -41,7 +43,7 @@ public byte[] Encrypt(byte[] bytes)
                 crypto.FlushFinalBlock();
                 stream.Position = 0;
                 var encrypted = new byte[stream.Length];
-                stream.Read(encrypted, 0, encrypted.Length);
+                stream.ReadExactly(encrypted, 0, encrypted.Length);
 
                 return encrypted;
             }
@@ -60,7 +62,7 @@ public byte[] Decrypt(byte[] encryptedValue, int offset = 0, int count = -1)
                 crypto.FlushFinalBlock();
                 stream.Position = 0;
                 var decryptedBytes = new byte[stream.Length];
-                stream.Read(decryptedBytes, 0, decryptedBytes.Length);
+                stream.ReadExactly(decryptedBytes, 0, decryptedBytes.Length);
 
                 return decryptedBytes;
             }
diff --git a/PlainBytes.LiteDB/Engine/Services/RebuildService.cs b/PlainBytes.LiteDB/Engine/Services/RebuildService.cs
@@ -115,7 +115,7 @@ private byte[] ReadFirstBytes(bool useAesStream = true)
             using (var stream = factory.GetStream(false, true))
             {
                 stream.Position = 0;
-                stream.Read(buffer, 0, buffer.Length);
+                stream.ReadExactly(buffer, 0, buffer.Length);
             }
 
             return buffer;
diff --git a/PlainBytes.LiteDB/Engine/Sort/SortContainer.cs b/PlainBytes.LiteDB/Engine/Sort/SortContainer.cs
@@ -122,7 +122,7 @@ private IEnumerable<BufferSlice> GetSourceFromStream(Stream stream)
             {
                 stream.Position = this.Position + _readPosition;
 
-                stream.Read(bytes, 0, PAGE_SIZE);
+                stream.ReadExactly(bytes, 0, PAGE_SIZE);
 
                 _readPosition += PAGE_SIZE;
 
diff --git a/PlainBytes.LiteDB/PlainBytes.LiteDB.csproj b/PlainBytes.LiteDB/PlainBytes.LiteDB.csproj
@@ -1,7 +1,7 @@
 ﻿<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net8.0;</TargetFrameworks>
+        <TargetFrameworks>net8.0;net9.0;net10.0</TargetFrameworks>
         
         <Authors>PlainBytes contrubutors and Maurício David original author</Authors>
         <Product>LiteDB</Product>

Original file line number	Diff line number	Diff line change
`@@ -20,10 +20,10 @@ public void ArrayContains_ShouldHaveCount1()`
`20`	`20`	`var collection = database.GetCollection<ItemWithEnumerable>();`
`21`	`21`	`collection.Insert(new ItemWithEnumerable`
`22`	`22`	`{`
`23`		`- Array = new int[] { randomValue }`
	`23`	`+ Array = [randomValue]`
`24`	`24`	`});`
`25`	`25`
`26`		`- var result = collection.Find(i => i.Array.Contains(randomValue)).ToList();`
	`26`	`+ var result = collection.Find(i => i.Array.AsEnumerable().Contains(randomValue)).ToList();`
`27`	`27`	`result.Should().HaveCount(1);`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,8 @@ internal class LinqExpressionVisitor : ExpressionVisitor`
`46`	`46`
`47`	`47`	`public LinqExpressionVisitor(BsonMapper mapper, Expression expr)`
`48`	`48`	`{`
	`49`	`+ ArgumentNullException.ThrowIfNull(expr);`
	`50`	`+`
`49`	`51`	`_mapper = mapper;`
`50`	`52`	`_expr = expr;`
`51`	`53`
`@@ -69,17 +71,17 @@ public BsonExpression Resolve(bool predicate)`
`69`	`71`
`70`	`72`	`try`
`71`	`73`	`{`
`72`		`- var e = BsonExpression.Create(expression, _parameters);`
	`74`	`+ var bsonExpression = BsonExpression.Create(expression, _parameters);`
`73`	`75`
`74`	`76`	// if expression must return an predicate but expression result is Path/Parameter/Call add `= true`
`75`		`- if (predicate && (e.Type == BsonExpressionType.Path \|\| e.Type == BsonExpressionType.Call \|\| e.Type == BsonExpressionType.Parameter))`
	`77`	`+ if (predicate && (bsonExpression.Type == BsonExpressionType.Path \|\| bsonExpression.Type == BsonExpressionType.Call \|\| bsonExpression.Type == BsonExpressionType.Parameter))`
`76`	`78`	`{`
`77`	`79`	`expression = "(" + expression + " = true)";`
`78`	`80`
`79`		`- e = BsonExpression.Create(expression, _parameters);`
	`81`	`+ bsonExpression = BsonExpression.Create(expression, _parameters);`
`80`	`82`	`}`
`81`	`83`
`82`		`- return e;`
	`84`	`+ return bsonExpression;`
`83`	`85`	`}`
`84`	`86`	`catch (Exception ex)`
`85`	`87`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,11 @@ namespace PlainBytes.LiteDB`
`7`	`7`	`/// </summary>`
`8`	`8`	`internal class ParameterExpressionVisitor : ExpressionVisitor`
`9`	`9`	`{`
`10`		`- public bool IsParameter { get; private set; } = false;`
	`10`	`+ private bool IsParameter { get; set; }`
`11`	`11`
`12`	`12`	`protected override Expression VisitParameter(ParameterExpression node)`
`13`	`13`	`{`
`14`		`- this.IsParameter = true;`
	`14`	`+ IsParameter = true;`
`15`	`15`
`16`	`16`	`return base.VisitParameter(node);`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ private void ReadStream(Stream stream, long position, BufferSlice buffer)`
`59`	`59`
`60`	`60`	`stream.Position = position;`
`61`	`61`
`62`		`- stream.Read(buffer.Array, buffer.Offset, buffer.Count);`
	`62`	`+ stream.ReadExactly(buffer.Array, buffer.Offset, buffer.Count);`
`63`	`63`
`64`	`64`	`DEBUG(buffer.All(0) == false, "check if are not reading out of file length");`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -241,7 +241,7 @@ internal void MarkAsInvalidState()`
`241`	`241`	`using (var stream = _dataFactory.GetStream(true, true))`
`242`	`242`	`{`
`243`	`243`	`var buffer = _bufferPool.Rent(PAGE_SIZE);`
`244`		`- stream.Read(buffer, 0, PAGE_SIZE);`
	`244`	`+ stream.ReadExactly(buffer, 0, PAGE_SIZE);`
`245`	`245`	`buffer[HeaderPage.P_INVALID_DATAFILE_STATE] = 1;`
`246`	`246`	`stream.Position = 0;`
`247`	`247`	`stream.Write(buffer, 0, PAGE_SIZE);`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,6 @@ public class AesStream : Stream`
`23`	`23`
`24`	`24`	`private readonly byte[] _decryptedZeroes = new byte[16];`
`25`	`25`
`26`		`- private static readonly byte[] _emptyContent = new byte[PAGE_SIZE - 1 - 16]; // 1 for aes indicator + 16 for salt`
`27`		`-`
`28`	`26`	`private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;`
`29`	`27`
`30`	`28`	`public byte[] Salt { get; }`
`@@ -83,15 +81,17 @@ public AesStream(string password, Stream stream)`
`83`	`81`	`throw LiteException.FileNotEncrypted();`
`84`	`82`	`}`
`85`	`83`
`86`		`- _stream.Read(this.Salt, 0, ENCRYPTION_SALT_SIZE);`
	`84`	`+ _stream.ReadExactly(this.Salt, 0, ENCRYPTION_SALT_SIZE);`
`87`	`85`	`}`
`88`	`86`
`89`	`87`	`_aes = Aes.Create();`
`90`	`88`	`_aes.Padding = PaddingMode.None;`
`91`	`89`	`_aes.Mode = CipherMode.ECB;`
`92`	`90`
`93`	`91`	`#pragma warning disable SYSLIB0041`
	`92`	`+#pragma warning disable SYSLIB0060`
`94`	`93`	`var pdb = new Rfc2898DeriveBytes(password, this.Salt);`
	`94`	`+#pragma warning restore SYSLIB0060`
`95`	`95`	`#pragma warning restore SYSLIB0041`
`96`	`96`
`97`	`97`	`using (pdb as IDisposable)`
`@@ -114,11 +114,10 @@ public AesStream(string password, Stream stream)`
`114`	`114`	`// set stream to password checking`
`115`	`115`	`_stream.Position = 32;`
`116`	`116`
`117`		`-`
`118`	`117`	`if (!isNew)`
`119`	`118`	`{`
`120`	`119`	`// check whether bytes 32 to 64 is empty. This indicates PlainBytes.LiteDB was unable to write encrypted 1s during last attempt.`
`121`		`- _stream.Read(checkBuffer, 0, checkBufferSize);`
	`120`	`+ _stream.ReadExactly(checkBuffer, 0, checkBufferSize);`
`122`	`121`	`isNew = checkBuffer.All(x => x == 0);`
`123`	`122`
`124`	`123`	`// reset checkBuffer and stream position`
`@@ -139,7 +138,7 @@ public AesStream(string password, Stream stream)`
`139`	`138`	`}`
`140`	`139`	`else`
`141`	`140`	`{`
`142`		`- _reader.Read(checkBuffer, 0, checkBufferSize);`
	`141`	`+ _reader.ReadExactly(checkBuffer, 0, checkBufferSize);`
`143`	`142`
`144`	`143`	`if (!checkBuffer.All(x => x == 1))`
`145`	`144`	`{`
`@@ -152,7 +151,7 @@ public AesStream(string password, Stream stream)`
`152`	`151`	`using (var ms = new MemoryStream(msBuffer))`
`153`	`152`	`using (var tempStream = new CryptoStream(ms, _decryptor, CryptoStreamMode.Read))`
`154`	`153`	`{`
`155`		`- tempStream.Read(_decryptedZeroes, 0, _decryptedZeroes.Length);`
	`154`	`+ tempStream.ReadExactly(_decryptedZeroes, 0, _decryptedZeroes.Length);`
`156`	`155`	`}`
`157`	`156`	`}`
`158`	`157`	`catch`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@ private void TryUpgrade()`
`31`	`31`
`32`	`32`
`33`	`33`	`stream.Position = 0;`
`34`		`- stream.Read(buffer, 0, bufferSize);`
	`34`	`+ stream.ReadExactly(buffer, 0, bufferSize);`
`35`	`35`
`36`	`36`	`if (FileReaderV7.IsVersion(buffer) == false) return;`
`37`	`37`	`}`