Fixed Compile Issues

Author: michaelstaib

src/GreenDonut/src/Core/CreateDataLoaderBranch.cs

@@ -1,4 +1,3 @@
-#if NET6_0_OR_GREATER
 namespace GreenDonut;
 
 /// <summary>
@@ -18,4 +17,3 @@ public delegate IDataLoader CreateDataLoaderBranch<out TKey, TValue, in TState>(
     IDataLoader<TKey, TValue> dataLoader,
     TState state)
     where TKey : notnull;
-#endif

src/GreenDonut/src/Core/Data/ExpressionHasher.cs

@@ -72,8 +72,14 @@ public ExpressionHasher Add(ReadOnlySpan<char> span)
 
     public string Compute()
     {
+#if NET8_0_OR_GREATER
         var hashBytes = MD5.HashData(_buffer.AsSpan().Slice(0, _start));
         var hashString = Convert.ToHexString(hashBytes).ToLowerInvariant();
+#else
+        var md5 = MD5.Create();
+        var hashBytes = md5.ComputeHash(_buffer, 0, _start);
+        var hashString = BitConverter.ToString(hashBytes).Replace("-", "").ToLowerInvariant();
+#endif
 
         _buffer.AsSpan().Slice(0, _start).Clear();
 
@@ -281,6 +287,7 @@ private void Append(char a, char b)
         _buffer[_start++] = (byte)b;
     }
 
+#if NET8_0_OR_GREATER
     private void Append(string s)
     {
         var span = _buffer.AsSpan().Slice(_start);
@@ -316,6 +323,47 @@ private void Append(ReadOnlySpan<char> s)
         _start += written;
     }
 
+#else
+    private void Append(string s)
+    {
+        byte[]? utf8Bytes = null;
+
+        try
+        {
+            utf8Bytes = Encoding.UTF8.GetBytes(s);
+            EnsureBufferCapacity(utf8Bytes.Length);
+
+            Buffer.BlockCopy(utf8Bytes, 0, _buffer, _start, utf8Bytes.Length);
+            _start += utf8Bytes.Length;
+        }
+        finally
+        {
+            if (utf8Bytes != null)
+            {
+                ArrayPool<byte>.Shared.Return(utf8Bytes);
+            }
+        }
+    }
+
+    private void Append(ReadOnlySpan<char> s)
+    {
+        // Converting ReadOnlySpan<char> to string for .NET Standard 2.0 compatibility
+        var str = new string(s.ToArray());
+        Append(str);
+    }
+
+    private void EnsureBufferCapacity(int requiredCapacity)
+    {
+        while (_buffer.Length - _start < requiredCapacity)
+        {
+            var newBuffer = ArrayPool<byte>.Shared.Rent(_buffer.Length * 2);
+            Buffer.BlockCopy(_buffer, 0, newBuffer, 0, _start);
+            ArrayPool<byte>.Shared.Return(_buffer);
+            _buffer = newBuffer;
+        }
+    }
+#endif
+
     private void Append(byte b)
     {
         if (_start == _buffer.Length)

src/GreenDonut/src/Core/Data/QueryState.cs

@@ -1,3 +1,14 @@
 namespace GreenDonut.Data;
 
-internal readonly record struct QueryState(string Key, object Value);
+internal readonly struct QueryState
+{
+    public QueryState(string key, object value)
+    {
+        Key = key;
+        Value = value;
+    }
+
+    public string Key { get; }
+
+    public object Value { get; }
+}

src/GreenDonut/src/Core/DataLoaderBase.cs

@@ -29,10 +29,8 @@ public abstract partial class DataLoaderBase<TKey, TValue>
     private readonly IBatchScheduler _batchScheduler;
     private readonly int _maxBatchSize;
     private readonly IDataLoaderDiagnosticEvents _diagnosticEvents;
-#if NET6_0_OR_GREATER
     private ImmutableDictionary<string, IDataLoader> _branches =
         ImmutableDictionary<string, IDataLoader>.Empty;
-#endif
     private Batch<TKey>? _currentBatch;
 
     /// <summary>
@@ -228,7 +226,7 @@ void Initialize()
                 ct);
         }
     }
-    
+
     /// <inheritdoc />
     public void Remove(TKey key)
     {
@@ -263,7 +261,6 @@ public void Set(TKey key, Task<TValue?> value)
             Cache.TryAdd(cacheKey, new Promise<TValue?>(value));
         }
     }
-#if NET6_0_OR_GREATER
 
     /// <inheritdoc />
     public IDataLoader Branch<TState>(
@@ -302,7 +299,6 @@ public IDataLoader Branch<TState>(
 
         return branch;
     }
-#endif
 
     private void BatchOperationFailed(
         Batch<TKey> batch,

src/GreenDonut/src/Core/ExpressionHelpers.cs

@@ -1,4 +1,3 @@
-#if NET6_0_OR_GREATER
 using System.Linq.Expressions;
 using System.Reflection;
 
@@ -240,4 +239,3 @@ protected override Expression VisitParameter(ParameterExpression node)
             => node == toReplace ? replacement : base.VisitParameter(node);
     }
 }
-#endif

src/GreenDonut/src/Core/IDataLoader.cs

@@ -1,7 +1,4 @@
 using System.Collections.Immutable;
-#if NET8_0_OR_GREATER
-using GreenDonut.Selectors;
-#endif
 
 namespace GreenDonut;
 
@@ -165,7 +162,6 @@ public interface IDataLoader<in TKey, TValue>
     /// </exception>
     void Set(TKey key, Task<TValue?> value);
 
-#if NET6_0_OR_GREATER
     /// <summary>
     /// Branches the current <c>DataLoader</c>.
     /// </summary>
@@ -185,5 +181,4 @@ IDataLoader Branch<TState>(
         string key,
         CreateDataLoaderBranch<TKey, TValue, TState> createBranch,
         TState state);
-#endif
 }

src/GreenDonut/src/Data.Primitives/GreenDonut.Data.Primitives.csproj

@@ -7,4 +7,8 @@
     <Description>This package contains the basic building blocks of the DataLoader linq query integration.</Description>
   </PropertyGroup>
 
+  <ItemGroup Condition="'$(TargetFramework)' == 'NETSTANDARD2.0'">
+    <PackageReference Include="System.Collections.Immutable" />
+  </ItemGroup>
+
 </Project>

src/GreenDonut/src/Data.Primitives/QueryContext.cs

@@ -2,6 +2,7 @@
 
 namespace GreenDonut.Data;
 
+#if NET6_0_OR_GREATER
 /// <summary>
 /// Represents the context for constructing queries against a data source for <typeparamref name="TEntity"/>.
 /// This record contains the projection (selector), filtering (predicate), and sorting instructions
@@ -29,3 +30,35 @@ public record QueryContext<TEntity>(
     /// </summary>
     public static QueryContext<TEntity> Empty { get; } = new();
 }
+#else
+/// <summary>
+/// Represents the context for constructing queries against a data source for <typeparamref name="TEntity"/>.
+/// This record contains the projection (selector), filtering (predicate), and sorting instructions
+/// (<see cref="SortDefinition{TEntity}"/>) for building a query.
+/// </summary>
+public class QueryContext<TEntity>(
+    Expression<Func<TEntity, TEntity>>? selector = null,
+    Expression<Func<TEntity, bool>>? predicate = null,
+    SortDefinition<TEntity>? sorting = null)
+{
+    /// <summary>
+    /// An expression that defines what data shall be selected from <typeparamref name="TEntity"/>.
+    /// </summary>
+    public Expression<Func<TEntity, TEntity>>? Selector { get; } = selector;
+
+    /// <summary>
+    /// An expression that defines the filtering condition for <typeparamref name="TEntity"/>.
+    /// </summary>
+    public Expression<Func<TEntity, bool>>? Predicate { get; } = predicate;
+
+    /// <summary>
+    /// The sorting instructions (see <see cref="SortDefinition{TEntity}"/>) for <typeparamref name="TEntity"/>.
+    /// </summary>
+    public SortDefinition<TEntity>? Sorting { get; } = sorting;
+
+    /// <summary>
+    /// An empty query context.
+    /// </summary>
+    public static QueryContext<TEntity> Empty { get; } = new();
+}
+#endif

src/GreenDonut/src/Data.Primitives/SortBy.cs

@@ -28,14 +28,14 @@ public SortBy(Expression<Func<TEntity, TValue>> keySelector, bool ascending = tr
     /// <summary>
     /// Gets the field on which the sort operation is applied.
     /// </summary>
-    public Expression<Func<TEntity, TValue>> KeySelector { get; init; }
+    public Expression<Func<TEntity, TValue>> KeySelector { get; }
 
     LambdaExpression ISortBy<TEntity>.KeySelector => KeySelector;
 
     /// <summary>
     /// Gets the sort direction.
     /// </summary>
-    public bool Ascending { get => field; init; }
+    public bool Ascending { get; }
 
     /// <summary>
     /// Applies the sort operation to the queryable.

src/GreenDonut/src/Data.Primitives/SortDefinition.cs

@@ -9,7 +9,7 @@ namespace GreenDonut.Data;
 /// <typeparam name="T">
 /// The entity type on which the sort operations are applied.
 /// </typeparam>
-public sealed record SortDefinition<T>
+public sealed class SortDefinition<T>
 {
     /// <summary>
     /// Initializes a new instance of <see cref="SortDefinition{T}"/>.
@@ -19,7 +19,7 @@ public sealed record SortDefinition<T>
     /// </param>
     public SortDefinition(params ISortBy<T>[] operations)
     {
-        Operations = [..operations];
+        Operations = ImmutableArray.Create(operations);
     }
 
     /// <summary>
@@ -30,13 +30,13 @@ public SortDefinition(params ISortBy<T>[] operations)
     /// </param>
     public SortDefinition(IEnumerable<ISortBy<T>> operations)
     {
-        Operations = [..operations];
+        Operations = ImmutableArray.CreateRange(operations);
     }
 
     /// <summary>
     /// The sort operations.
     /// </summary>
-    public ImmutableArray<ISortBy<T>> Operations { get; init; }
+    public ImmutableArray<ISortBy<T>> Operations { get; }
 
     /// <summary>
     /// Deconstructs the sort operations.