Fix New() support for Type + Fix GroupJoin() not working when using Linq-To-Entities

src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs

@@ -697,7 +697,7 @@ public static IQueryable GroupJoin([NotNull] this IQueryable outer, [CanBeNull]
                 typeof(Queryable), nameof(Queryable.GroupJoin),
                 new[] { outer.ElementType, innerType, outerSelectorLambda.Body.Type, resultSelectorLambda.Body.Type },
                 outer.Expression,
-                Expression.Constant(inner),
+                inner.AsQueryable().Expression,
                 Expression.Quote(outerSelectorLambda),
                 Expression.Quote(innerSelectorLambda),
                 Expression.Quote(resultSelectorLambda)));

src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs

@@ -1549,6 +1549,10 @@ Type FindType(string name)
             {
                 return _root.Type;
             }
+            if (this._parsingConfig.AllowNewToEvaluateAnyType && Type.GetType(name) != null)
+            {
+                return Type.GetType(name);
+            }
 
             return null;
         }

src/System.Linq.Dynamic.Core/ParsingConfig.cs

@@ -1,4 +1,5 @@
 using System.Linq.Dynamic.Core.CustomTypeProviders;
+using System.Reflection;
 
 namespace System.Linq.Dynamic.Core
 {
@@ -7,6 +8,26 @@ namespace System.Linq.Dynamic.Core
     /// </summary>
     public class ParsingConfig
     {
+        /// <summary>
+        /// Get an instance of ParsingConfig
+        /// </summary>
+        public ParsingConfig()
+        {
+#if !(DOTNET5_1 || WINDOWS_APP || UAP10_0 || NETSTANDARD)
+            AppDomain.CurrentDomain.TypeResolve += this.CurrentDomain_TypeResolve;
+#endif
+        }
+
+        /// <summary>
+        /// Cleanup
+        /// </summary>
+        ~ParsingConfig()
+        {
+#if !(DOTNET5_1 || WINDOWS_APP || UAP10_0 || NETSTANDARD)
+            AppDomain.CurrentDomain.TypeResolve -= this.CurrentDomain_TypeResolve;
+#endif
+        }
+
         /// <summary>
         /// Default ParsingConfig
         /// </summary>
@@ -62,5 +83,35 @@ public IDynamicLinkCustomTypeProvider CustomTypeProvider
         /// See https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-2.1#linq-groupby-translation
         /// </summary>
         public bool EvaluateGroupByAtDatabase { get; set; }
+
+        /// <summary>
+        /// Allows the New() keyword to evaluate any available Type
+        /// </summary>
+        public bool AllowNewToEvaluateAnyType { get; set; } = false;
+
+#if !(DOTNET5_1 || WINDOWS_APP || UAP10_0 || NETSTANDARD)
+        /// <summary>
+        /// Custom type resolver to allow ExpressionParser to find any type
+        /// registered in the current application domain. You can add additional
+        /// type resolvers in your application.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        protected Assembly CurrentDomain_TypeResolve(object sender, ResolveEventArgs args)
+        {
+            foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                Type t = assembly.GetType(args.Name, false, true);
+
+                if (t != null)
+                {
+                    return assembly;
+                }
+            }
+
+            return null;
+        }
+#endif
     }
 }

test/System.Linq.Dynamic.Core.Tests/QueryableTests.Select.cs

@@ -169,6 +169,16 @@ public class Example
             public DayOfWeek DOW { get; set; }
             public int Sec { get; set; }
             public int? SecNull { get; set; }
+
+            public class NestedDto
+            {
+                public string Name { get; set; }
+
+                public class NestedDto2
+                {
+                    public string Name2 { get; set; }
+                }
+            }
         }
 
         public class ExampleWithConstructor
@@ -227,6 +237,47 @@ public void Select_Dynamic_IntoTypeWithNullableProperties2()
             Check.That(resultDynamic.Last()).Equals(result.Last());
         }
 
+        [Fact]
+        public void Select_Dynamic_IntoKnownNestedType()
+        {
+
+#if (DOTNET5_1 || WINDOWS_APP || UAP10_0 || NETSTANDARD)
+            return;
+#endif
+            var config = new ParsingConfig();
+            config.AllowNewToEvaluateAnyType = true;
+
+            // Act
+            IQueryable<string> data = new List<string>() { "name1", "name2" }.AsQueryable();
+            IQueryable<Example.NestedDto> projectedData = 
+                (IQueryable<Example.NestedDto>) data.Select(config, $"new {typeof(Example.NestedDto).FullName}(~ as Name)");
+
+            // Assert
+            Check.That(projectedData.First().Name).Equals("name1");
+            Check.That(projectedData.Last().Name).Equals("name2");
+        }
+
+        [Fact]
+        public void Select_Dynamic_IntoKnownNestedTypeSecondLevel()
+        {
+
+#if (DOTNET5_1 || WINDOWS_APP || UAP10_0 || NETSTANDARD)
+            return;
+#endif
+
+            var config = new ParsingConfig();
+            config.AllowNewToEvaluateAnyType = true;
+
+            // Act
+            IQueryable<string> data = new List<string>() { "name1", "name2" }.AsQueryable();
+            IQueryable<Example.NestedDto.NestedDto2> projectedData =
+                (IQueryable<Example.NestedDto.NestedDto2>)data.Select(config, $"new {typeof(Example.NestedDto.NestedDto2).FullName}(~ as Name2)");
+
+            // Assert
+            Check.That(projectedData.First().Name2).Equals("name1");
+            Check.That(projectedData.Last().Name2).Equals("name2");
+        }
+
         [Fact]
         public void Select_Dynamic_Exceptions()
         {