Add more OrderBy unittests (#584)

StefH · web-flow · commit a7158a80cae0 · 2022-06-07T19:04:10.000+02:00
* Add more unittests for OrderBy with IComparer

* .

* wip

* ok

* .
diff --git a/System.Linq.Dynamic.Core.sln b/System.Linq.Dynamic.Core.sln
@@ -108,7 +108,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "BlazorWASMExample", "src-bl
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.EntityFrameworkCore.DynamicLinq.EFCore6", "src\Microsoft.EntityFrameworkCore.DynamicLinq.EFCore6\Microsoft.EntityFrameworkCore.DynamicLinq.EFCore6.csproj", "{D28F6393-B56B-40A2-AF67-E8D669F42546}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleApp_net5.0_EF6_InMemory", "src-console\ConsoleAppEF6_InMemory\ConsoleApp_net5.0_EF6_InMemory.csproj", "{4CC563F6-5352-4A77-A8C0-DC0D77A71DBB}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleApp_net6.0_EF6_InMemory", "src-console\ConsoleAppEF6_InMemory\ConsoleApp_net6.0_EF6_InMemory.csproj", "{4CC563F6-5352-4A77-A8C0-DC0D77A71DBB}"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleApp_net6.0", "src-console\ConsoleApp_net6.0\ConsoleApp_net6.0.csproj", "{C206917D-6E90-4A31-8533-AF2DD68FF738}"
 EndProject
diff --git a/src-console/ConsoleAppEF6_InMemory/ConsoleApp_net6.0_EF6_InMemory.csproj b/src-console/ConsoleAppEF6_InMemory/ConsoleApp_net6.0_EF6_InMemory.csproj
@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net5.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
     </PropertyGroup>
 
     <ItemGroup>
diff --git a/src/System.Linq.Dynamic.Core/DynamicClassFactory.cs b/src/System.Linq.Dynamic.Core/DynamicClassFactory.cs
@@ -1,4 +1,5 @@
 ﻿#if !(UAP10_0)
+using System.Collections;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -21,26 +22,23 @@ namespace System.Linq.Dynamic.Core
     /// </summary>
     public static class DynamicClassFactory
     {
-        // EmptyTypes is used to indicate that we are looking for someting without any parameters. 
-        private static readonly Type[] EmptyTypes = new Type[0];
-
         private static readonly ConcurrentDictionary<string, Type> GeneratedTypes = new ConcurrentDictionary<string, Type>();
 
         private static readonly ModuleBuilder ModuleBuilder;
 
         // Some objects we cache
-        private static readonly CustomAttributeBuilder CompilerGeneratedAttributeBuilder = new CustomAttributeBuilder(typeof(CompilerGeneratedAttribute).GetConstructor(EmptyTypes), new object[0]);
+        private static readonly CustomAttributeBuilder CompilerGeneratedAttributeBuilder = new CustomAttributeBuilder(typeof(CompilerGeneratedAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
         private static readonly CustomAttributeBuilder DebuggerBrowsableAttributeBuilder = new CustomAttributeBuilder(typeof(DebuggerBrowsableAttribute).GetConstructor(new[] { typeof(DebuggerBrowsableState) }), new object[] { DebuggerBrowsableState.Never });
-        private static readonly CustomAttributeBuilder DebuggerHiddenAttributeBuilder = new CustomAttributeBuilder(typeof(DebuggerHiddenAttribute).GetConstructor(EmptyTypes), new object[0]);
+        private static readonly CustomAttributeBuilder DebuggerHiddenAttributeBuilder = new CustomAttributeBuilder(typeof(DebuggerHiddenAttribute).GetConstructor(Type.EmptyTypes), new object[0]);
 
-        private static readonly ConstructorInfo ObjectCtor = typeof(object).GetConstructor(EmptyTypes);
+        private static readonly ConstructorInfo ObjectCtor = typeof(object).GetConstructor(Type.EmptyTypes);
 #if WINDOWS_APP ||  UAP10_0 || NETSTANDARD
         private static readonly MethodInfo ObjectToString = typeof(object).GetMethod("ToString", BindingFlags.Instance | BindingFlags.Public);
 #else
-        private static readonly MethodInfo ObjectToString = typeof(object).GetMethod("ToString", BindingFlags.Instance | BindingFlags.Public, null, EmptyTypes, null);
+        private static readonly MethodInfo ObjectToString = typeof(object).GetMethod("ToString", BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
 #endif
 
-        private static readonly ConstructorInfo StringBuilderCtor = typeof(StringBuilder).GetConstructor(EmptyTypes);
+        private static readonly ConstructorInfo StringBuilderCtor = typeof(StringBuilder).GetConstructor(Type.EmptyTypes);
 #if WINDOWS_APP ||  UAP10_0 || NETSTANDARD
         private static readonly MethodInfo StringBuilderAppendString = typeof(StringBuilder).GetMethod("Append", new[] { typeof(string) });
         private static readonly MethodInfo StringBuilderAppendObject = typeof(StringBuilder).GetMethod("Append", new[] { typeof(object) });
@@ -56,7 +54,7 @@ public static class DynamicClassFactory
         private static readonly MethodInfo EqualityComparerEquals = EqualityComparer.GetMethod("Equals", new[] { EqualityComparerGenericArgument, EqualityComparerGenericArgument });
         private static readonly MethodInfo EqualityComparerGetHashCode = EqualityComparer.GetMethod("GetHashCode", new[] { EqualityComparerGenericArgument });
 #else
-        private static readonly MethodInfo EqualityComparerDefault = EqualityComparer.GetMethod("get_Default", BindingFlags.Static | BindingFlags.Public, null, EmptyTypes, null);
+        private static readonly MethodInfo EqualityComparerDefault = EqualityComparer.GetMethod("get_Default", BindingFlags.Static | BindingFlags.Public, null, Type.EmptyTypes, null);
         private static readonly MethodInfo EqualityComparerEquals = EqualityComparer.GetMethod("Equals", BindingFlags.Instance | BindingFlags.Public, null, new[] { EqualityComparerGenericArgument, EqualityComparerGenericArgument }, null);
         private static readonly MethodInfo EqualityComparerGetHashCode = EqualityComparer.GetMethod("GetHashCode", BindingFlags.Instance | BindingFlags.Public, null, new[] { EqualityComparerGenericArgument }, null);
 #endif
@@ -85,6 +83,71 @@ static DynamicClassFactory()
             ModuleBuilder = assemblyBuilder.DefineDynamicModule(DynamicModuleName);
         }
 
+        /// <summary>
+        /// Create a GenericComparerType based on the GenericType and an instance of a <see cref="IComparer"/>.
+        /// </summary>
+        /// <param name="comparerGenericType">The GenericType</param>
+        /// <param name="comparerType">The <see cref="IComparer"/> instance</param>
+        /// <returns>Type</returns>
+        public static Type CreateGenericComparerType(Type comparerGenericType, Type comparerType)
+        {
+            Check.NotNull(comparerGenericType, nameof(comparerGenericType));
+            Check.NotNull(comparerType, nameof(comparerType));
+
+            var key = $"{comparerGenericType.FullName}_{comparerType.FullName}";
+
+            if (!GeneratedTypes.TryGetValue(key, out var type))
+            {
+                // We create only a single class at a time, through this lock
+                // Note that this is a variant of the double-checked locking.
+                // It is safe because we are using a thread safe class.
+                lock (GeneratedTypes)
+                {
+                    if (!GeneratedTypes.TryGetValue(key, out type))
+                    {
+                        var compareMethodGeneric = comparerGenericType.GetMethod("Compare");
+                        var compareMethod = typeof(IComparer).GetMethod("Compare");
+                        var compareCtor = comparerType.GetConstructor(Type.EmptyTypes);
+
+                        var typeBuilder = ModuleBuilder.DefineType(key, TypeAttributes.AnsiClass | TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.AutoLayout, typeof(object));
+                        typeBuilder.AddInterfaceImplementation(comparerGenericType);
+
+                        var fieldBuilder = typeBuilder.DefineField("_c", typeof(IComparer), FieldAttributes.Private | FieldAttributes.InitOnly);
+
+                        var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig, CallingConventions.HasThis, Type.EmptyTypes);
+                        var constructorIL = constructorBuilder.GetILGenerator();
+                        constructorIL.Emit(OpCodes.Ldarg_0);
+                        constructorIL.Emit(OpCodes.Call, ObjectCtor);
+                        constructorIL.Emit(OpCodes.Ldarg_0);
+                        constructorIL.Emit(OpCodes.Newobj, compareCtor);
+                        constructorIL.Emit(OpCodes.Stfld, fieldBuilder);
+                        constructorIL.Emit(OpCodes.Ret);
+
+                        var methodBuilder = typeBuilder.DefineMethod(
+                            compareMethodGeneric.Name,
+                            compareMethodGeneric.Attributes & ~MethodAttributes.Abstract,
+                            compareMethodGeneric.CallingConvention,
+                            compareMethodGeneric.ReturnType,
+                            compareMethodGeneric.GetParameters().Select(p => p.ParameterType).ToArray()
+                        );
+                        var methodBuilderIL = methodBuilder.GetILGenerator();
+                        methodBuilderIL.Emit(OpCodes.Ldarg_0);
+                        methodBuilderIL.Emit(OpCodes.Ldfld, fieldBuilder);
+                        methodBuilderIL.Emit(OpCodes.Ldarg_1);
+                        methodBuilderIL.Emit(OpCodes.Box, typeof(int));
+                        methodBuilderIL.Emit(OpCodes.Ldarg_2);
+                        methodBuilderIL.Emit(OpCodes.Box, typeof(int));
+                        methodBuilderIL.Emit(OpCodes.Callvirt, compareMethod);
+                        methodBuilderIL.Emit(OpCodes.Ret);
+
+                        return GeneratedTypes.GetOrAdd(key, typeBuilder.CreateType());
+                    }
+                }
+            }
+
+            return type;
+        }
+
         /// <summary>
         /// The CreateType method creates a new data class with a given set of public properties and returns the System.Type object for the newly created class. If a data class with an identical sequence of properties has already been created, the System.Type object for this class is returned.        
         /// Data classes implement private instance variables and read/write property accessors for the specified properties.Data classes also override the Equals and GetHashCode members to implement by-value equality.
@@ -157,7 +220,7 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
                             fields[i] = tb.DefineField($"<{names[i]}>i__Field", generics[i].AsType(), FieldAttributes.Private | FieldAttributes.InitOnly);
                             fields[i].SetCustomAttribute(DebuggerBrowsableAttributeBuilder);
 
-                            PropertyBuilder property = tb.DefineProperty(names[i], PropertyAttributes.None, CallingConventions.HasThis, generics[i].AsType(), EmptyTypes);
+                            PropertyBuilder property = tb.DefineProperty(names[i], PropertyAttributes.None, CallingConventions.HasThis, generics[i].AsType(), Type.EmptyTypes);
 
                             // getter
                             MethodBuilder getter = tb.DefineMethod($"get_{names[i]}", MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.SpecialName, CallingConventions.HasThis, generics[i].AsType(), null);
@@ -184,7 +247,7 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
                         }
 
                         // ToString()
-                        MethodBuilder toString = tb.DefineMethod("ToString", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig, CallingConventions.HasThis, typeof(string), EmptyTypes);
+                        MethodBuilder toString = tb.DefineMethod("ToString", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig, CallingConventions.HasThis, typeof(string), Type.EmptyTypes);
                         toString.SetCustomAttribute(DebuggerHiddenAttributeBuilder);
                         ILGenerator ilgeneratorToString = toString.GetILGenerator();
                         ilgeneratorToString.DeclareLocal(typeof(StringBuilder));
@@ -206,7 +269,7 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
                         Label equalsLabel = ilgeneratorEquals.DefineLabel();
 
                         // GetHashCode()
-                        MethodBuilder getHashCode = tb.DefineMethod("GetHashCode", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig, CallingConventions.HasThis, typeof(int), EmptyTypes);
+                        MethodBuilder getHashCode = tb.DefineMethod("GetHashCode", MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig, CallingConventions.HasThis, typeof(int), Type.EmptyTypes);
                         getHashCode.SetCustomAttribute(DebuggerHiddenAttributeBuilder);
                         ILGenerator ilgeneratorGetHashCode = getHashCode.GetILGenerator();
                         ilgeneratorGetHashCode.DeclareLocal(typeof(int));
@@ -283,7 +346,7 @@ public static Type CreateType([NotNull] IList<DynamicProperty> properties, bool
                         if (createParameterCtor && names.Any())
                         {
                             // .ctor default
-                            ConstructorBuilder constructorDef = tb.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig, CallingConventions.HasThis, EmptyTypes);
+                            ConstructorBuilder constructorDef = tb.DefineConstructor(MethodAttributes.Public | MethodAttributes.HideBySig, CallingConventions.HasThis, Type.EmptyTypes);
                             constructorDef.SetCustomAttribute(DebuggerHiddenAttributeBuilder);
 
                             ILGenerator ilgeneratorConstructorDef = constructorDef.GetILGenerator();
diff --git a/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs b/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs
@@ -1564,6 +1564,11 @@ public static IOrderedQueryable<TSource> OrderBy<TSource>([NotNull] this IQuerya
         /// </example>
         public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [NotNull] ParsingConfig config, [NotNull] string ordering, params object[] args)
         {
+            if (args.Length > 0 && args[0] != null && args[0].GetType().GetInterfaces().Any(i => i.Name.Contains("IComparer`1")))
+            {
+                return InternalOrderBy(source, ParsingConfig.Default, ordering, args[0], args);
+            }
+
             return InternalOrderBy(source, config, ordering, null, args);
         }
 
@@ -1581,7 +1586,7 @@ public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [NotNu
             return InternalOrderBy(source, config, ordering, comparer, args);
         }
 
-        internal static IOrderedQueryable InternalOrderBy([NotNull] IQueryable source, [NotNull] ParsingConfig config, [NotNull] string ordering, IComparer comparer, params object[] args)
+        internal static IOrderedQueryable InternalOrderBy([NotNull] IQueryable source, [NotNull] ParsingConfig config, [NotNull] string ordering, object comparer, params object[] args)
         {
             Check.NotNull(source, nameof(source));
             Check.NotNull(config, nameof(config));
@@ -1605,11 +1610,27 @@ internal static IOrderedQueryable InternalOrderBy([NotNull] IQueryable source, [
                 else
                 {
                     var comparerGenericType = typeof(IComparer<>).MakeGenericType(dynamicOrdering.Selector.Type);
+
+                    ConstantExpression constant;
+                    if (comparerGenericType.IsInstanceOfType(comparer))
+                    {
+                        constant = Expression.Constant(comparer, comparerGenericType);
+                    }
+                    else
+                    {
+#if !UAP10_0
+                        var newType = DynamicClassFactory.CreateGenericComparerType(comparerGenericType, comparer.GetType());
+                        constant = Expression.Constant(Activator.CreateInstance(newType), comparerGenericType);
+#else
+                        constant = Expression.Constant(comparer, comparerGenericType);
+#endif
+                    }
+
                     queryExpr = Expression.Call(
                         typeof(Queryable), dynamicOrdering.MethodName,
                         new[] { source.ElementType, dynamicOrdering.Selector.Type },
                         queryExpr, Expression.Quote(Expression.Lambda(dynamicOrdering.Selector, parameters)),
-                        Expression.Constant(comparer, comparerGenericType));
+                        constant);
                 }
             }
 
diff --git a/test/System.Linq.Dynamic.Core.Tests/DynamicClassFactoryTests.cs b/test/System.Linq.Dynamic.Core.Tests/DynamicClassFactoryTests.cs
@@ -0,0 +1,40 @@
+﻿using System.Collections;
+using System.Collections.Generic;
+using FluentAssertions;
+using Xunit;
+
+namespace System.Linq.Dynamic.Core.Tests
+{
+    public class DynamicClassFactoryTests
+    {
+        [Fact]
+        public void CreateGenericComparerType()
+        {
+            // Assign
+            var comparer = new IntComparer();
+            var comparerGenericType = typeof(IComparer<>).MakeGenericType(typeof(int));
+
+            // Act
+            var type = DynamicClassFactory.CreateGenericComparerType(comparerGenericType, comparer.GetType());
+
+            // Assert
+            var instance = (IComparer<int>)Activator.CreateInstance(type);
+            int greaterThan = instance.Compare(1, 2);
+            greaterThan.Should().Be(1);
+
+            int equal = instance.Compare(1, 1);
+            equal.Should().Be(0);
+
+            int lessThan = instance.Compare(2, 1);
+            lessThan.Should().Be(-1);
+        }
+    }
+
+    public class IntComparer : IComparer
+    {
+        public int Compare(object x, object y)
+        {
+            return new CaseInsensitiveComparer().Compare(y, x);
+        }
+    }
+}
diff --git a/test/System.Linq.Dynamic.Core.Tests/QueryableTests.OrderBy.cs b/test/System.Linq.Dynamic.Core.Tests/QueryableTests.OrderBy.cs
