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

StefH · web-flow · commit b85093e4afb4 · 2018-10-19T18:06:42.000+02:00
* Fix Parsing Config not passed down to expression parser in JOIN

* Use IDynamicLinkCustomTypeProvider to Resolve a Type

* Small update on tests
diff --git a/src-console/ConsoleAppEF2.0.2_InMemory/Program.cs b/src-console/ConsoleAppEF2.0.2_InMemory/Program.cs
@@ -1,6 +1,5 @@
 ﻿using System;
 using System.Collections.Generic;
-using System.Dynamic;
 using System.Linq;
 using System.Linq.Dynamic.Core;
 using System.Linq.Dynamic.Core.CustomTypeProviders;
@@ -25,6 +24,13 @@ public HashSet<Type> GetCustomTypes()
 
                 return set;
             }
+
+            public Type ResolveType(string typeName)
+            {
+                var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+                return ResolveType(assemblies, typeName);
+            }
         }
 
         private static IQueryable GetQueryable()
diff --git a/src-console/ConsoleAppEF2.0/Program.cs b/src-console/ConsoleAppEF2.0/Program.cs
@@ -4,6 +4,7 @@
 using System.Linq.Dynamic.Core;
 using System.Linq.Dynamic.Core.CustomTypeProviders;
 using ConsoleAppEF2.Database;
+using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 using Newtonsoft.Json;
 
@@ -23,6 +24,12 @@ public HashSet<Type> GetCustomTypes()
 
                 return set;
             }
+
+            public Type ResolveType(string typeName)
+            {
+                var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+                return ResolveType(assemblies, typeName);
+            }
         }
 
         private static IQueryable GetQueryable()
diff --git a/src-console/ConsoleAppEF2.1.1/Program.cs b/src-console/ConsoleAppEF2.1.1/Program.cs
@@ -4,6 +4,7 @@
 using System.Linq.Dynamic.Core;
 using System.Linq.Dynamic.Core.CustomTypeProviders;
 using ConsoleAppEF2.Database;
+using JetBrains.Annotations;
 using Microsoft.EntityFrameworkCore;
 using Newtonsoft.Json;
 
@@ -23,6 +24,13 @@ public HashSet<Type> GetCustomTypes()
 
                 return set;
             }
+
+            public Type ResolveType(string typeName)
+            {
+                var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+                return ResolveType(assemblies, typeName);
+            }
         }
 
         private static IQueryable GetQueryable()
diff --git a/src-console/ConsoleAppEF2.1.1_InMemory/Program.cs b/src-console/ConsoleAppEF2.1.1_InMemory/Program.cs
@@ -13,7 +13,17 @@ namespace ConsoleAppEF2
 {
     static class Program
     {
-        class C : AbstractDynamicLinqCustomTypeProvider, IDynamicLinkCustomTypeProvider
+        public class NestedDto
+        {
+            public string Name { get; set; }
+
+            public class NestedDto2
+            {
+                public string Name2 { get; set; }
+            }
+        }
+
+        class NetCore21CustomTypeProvider : AbstractDynamicLinqCustomTypeProvider, IDynamicLinkCustomTypeProvider
         {
             public HashSet<Type> GetCustomTypes()
             {
@@ -26,6 +36,12 @@ public HashSet<Type> GetCustomTypes()
 
                 return set;
             }
+
+            public Type ResolveType(string typeName)
+            {
+                var assemblies = AppDomain.CurrentDomain.GetAssemblies();
+                return ResolveType(assemblies, typeName);
+            }
         }
 
         private static object GetObj()
@@ -150,6 +166,18 @@ private static TResult Execute<TResult>(MethodInfo operatorMethodInfo, IQueryabl
 
         static void Main(string[] args)
         {
+            var config = new ParsingConfig
+            {
+                AllowNewToEvaluateAnyType = true,
+                CustomTypeProvider = new NetCore21CustomTypeProvider()
+            };
+
+            // Act
+            var testDataAsQueryable = new List<string>() { "name1", "name2" }.AsQueryable();
+            var projectedData = (IQueryable<NestedDto>)testDataAsQueryable.Select(config, $"new {typeof(NestedDto).FullName}(~ as Name)");
+            Console.WriteLine(projectedData.First().Name);
+            Console.WriteLine(projectedData.Last().Name);
+
             IQueryable qry = GetQueryable();
 
             var result = qry.Select("it").OrderBy("Value");
@@ -183,10 +211,7 @@ static void Main(string[] args)
             var any2 = anyTest.Where("values.Contains(1)");
             Console.WriteLine("any2 {0}", JsonConvert.SerializeObject(any2, Formatting.Indented));
 
-            var config = new ParsingConfig
-            {
-                CustomTypeProvider = new C()
-            };
+            
 
             var dateLastModified = new DateTime(2018, 1, 15);
 
diff --git a/src/EntityFramework.DynamicLinq/EntityFramework.DynamicLinq.csproj b/src/EntityFramework.DynamicLinq/EntityFramework.DynamicLinq.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>Dynamic Linq extensions for EntityFramework which adds Async support</Description>
     <AssemblyTitle>EntityFramework.DynamicLinq</AssemblyTitle>
-    <VersionPrefix>1.0.8.18</VersionPrefix>
+    <VersionPrefix>1.0.9.1</VersionPrefix>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net45;net46</TargetFrameworks>
     <DefineConstants>EF</DefineConstants>
diff --git a/src/Microsoft.EntityFrameworkCore.DynamicLinq/Microsoft.EntityFrameworkCore.DynamicLinq.csproj b/src/Microsoft.EntityFrameworkCore.DynamicLinq/Microsoft.EntityFrameworkCore.DynamicLinq.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>Dynamic Linq extensions for Microsoft.EntityFrameworkCore which adds Async support</Description>
     <AssemblyTitle>Microsoft.EntityFrameworkCore.DynamicLinq</AssemblyTitle>
-    <VersionPrefix>1.0.8.18</VersionPrefix>
+    <VersionPrefix>1.0.9.1</VersionPrefix>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net451;net46;netstandard1.3;netstandard2.0;uap10.0</TargetFrameworks>
     <DefineConstants>$(DefineConstants);EFCORE</DefineConstants>
diff --git a/src/System.Linq.Dynamic.Core/CustomTypeProviders/AbstractDynamicLinqCustomTypeProvider.cs b/src/System.Linq.Dynamic.Core/CustomTypeProviders/AbstractDynamicLinqCustomTypeProvider.cs
@@ -6,7 +6,7 @@
 namespace System.Linq.Dynamic.Core.CustomTypeProviders
 {
     /// <summary>
-    /// The abstract <see cref="AbstractDynamicLinqCustomTypeProvider"/>. Find all types marked with <see cref="DynamicLinqTypeAttribute"/>.
+    /// The abstract DynamicLinqCustomTypeProvider which is used by the <see cref="IDynamicLinkCustomTypeProvider"/> and can be used by a custom TypeProvider like in .NET Core.
     /// </summary>
     public abstract class AbstractDynamicLinqCustomTypeProvider
     {
@@ -30,6 +30,29 @@ protected IEnumerable<Type> FindTypesMarkedWithDynamicLinqTypeAttribute([NotNull
 #endif
         }
 
+        /// <summary>
+        /// Resolve any type which is registered in the current application domain.
+        /// </summary>
+        /// <param name="assemblies">The assemblies to inspect.</param>
+        /// <param name="typeName">The typename to resolve.</param>
+        /// <returns>A resolved <see cref="Type"/> or null when not found.</returns>
+        protected Type ResolveType([NotNull] IEnumerable<Assembly> assemblies, [NotNull] string typeName)
+        {
+            Check.NotNull(assemblies, nameof(assemblies));
+            Check.NotEmpty(typeName, nameof(typeName));
+
+            foreach (Assembly assembly in assemblies)
+            {
+                Type resolvedType = assembly.GetType(typeName, false, true);
+                if (resolvedType != null)
+                {
+                    return resolvedType;
+                }
+            }
+
+            return null;
+        }
+
 #if (WINDOWS_APP || DOTNET5_1 || UAP10_0 || NETSTANDARD)
         /// <summary>
         /// Gets the assembly types in an Exception friendly way.
@@ -48,8 +71,10 @@ protected IEnumerable<TypeInfo> GetAssemblyTypes([NotNull] IEnumerable<Assembly>
                 {
                     definedTypes = assembly.DefinedTypes;
                 }
-                catch (Exception)
-                { }
+                catch
+                {
+                    // Ignore error
+                }
 
                 if (definedTypes != null)
                 {
@@ -78,8 +103,10 @@ protected IEnumerable<Type> GetAssemblyTypes([NotNull] IEnumerable<Assembly> ass
                 {
                     definedTypes = assembly.GetTypes();
                 }
-                catch (Exception)
-                { }
+                catch
+                {
+                    // Ignore error
+                }
 
                 if (definedTypes != null)
                 {
@@ -92,4 +119,4 @@ protected IEnumerable<Type> GetAssemblyTypes([NotNull] IEnumerable<Assembly> ass
         }
 #endif
     }
-}
+}
diff --git a/src/System.Linq.Dynamic.Core/CustomTypeProviders/DefaultDynamicLinqCustomTypeProvider.cs b/src/System.Linq.Dynamic.Core/CustomTypeProviders/DefaultDynamicLinqCustomTypeProvider.cs
@@ -1,33 +1,36 @@
 ﻿#if !(WINDOWS_APP || UAP10_0)
 using System.Collections.Generic;
+using System.Linq.Dynamic.Core.Validation;
 using System.Reflection;
 
 namespace System.Linq.Dynamic.Core.CustomTypeProviders
 {
     /// <summary>
-    /// The default <see cref="IDynamicLinkCustomTypeProvider"/>. Scans the current AppDomain for all types marked with <see cref="DynamicLinqTypeAttribute"/>, and adds them as custom Dynamic Link types.
+    /// The default <see cref="IDynamicLinkCustomTypeProvider"/>.
+    /// Scans the current AppDomain for all types marked with <see cref="DynamicLinqTypeAttribute"/>, and adds them as custom Dynamic Link types.
+    ///
+    /// Also provides functionality to resolve a Type in the current Application Domain.
+    ///
+    /// This class is used as default for full .NET Framework, so not for .NET Core
     /// </summary>
     public class DefaultDynamicLinqCustomTypeProvider : AbstractDynamicLinqCustomTypeProvider, IDynamicLinkCustomTypeProvider
     {
         private readonly IAssemblyHelper _assemblyHelper = new DefaultAssemblyHelper();
-        private HashSet<Type> _customTypes;
 
-        /// <summary>
-        /// Returns a list of custom types that System.Linq.Dynamic.Core will understand.
-        /// </summary>
-        /// <returns>
-        /// A <see cref="System.Collections.Generic.HashSet&lt;Type&gt;" /> list of custom types.
-        /// </returns>
+        /// <inheritdoc cref="IDynamicLinkCustomTypeProvider.GetCustomTypes"/>
         public virtual HashSet<Type> GetCustomTypes()
         {
-            if (_customTypes != null)
-            {
-                return _customTypes;
-            }
+            IEnumerable<Assembly> assemblies = _assemblyHelper.GetAssemblies();
+            return new HashSet<Type>(FindTypesMarkedWithDynamicLinqTypeAttribute(assemblies));
+        }
+
+        /// <inheritdoc cref="IDynamicLinkCustomTypeProvider.ResolveType"/>
+        public Type ResolveType(string typeName)
+        {
+            Check.NotEmpty(typeName, nameof(typeName));
 
             IEnumerable<Assembly> assemblies = _assemblyHelper.GetAssemblies();
-            _customTypes = new HashSet<Type>(FindTypesMarkedWithDynamicLinqTypeAttribute(assemblies));
-            return _customTypes;
+            return ResolveType(assemblies, typeName);
         }
     }
 }
diff --git a/src/System.Linq.Dynamic.Core/CustomTypeProviders/IDynamicLinkCustomTypeProvider.cs b/src/System.Linq.Dynamic.Core/CustomTypeProviders/IDynamicLinkCustomTypeProvider.cs
@@ -0,0 +1,24 @@
+﻿using System.Collections.Generic;
+using JetBrains.Annotations;
+
+namespace System.Linq.Dynamic.Core.CustomTypeProviders
+{
+    /// <summary>
+    /// Interface for providing functionality to find custom types for or resolve any type.
+    /// </summary>
+    public interface IDynamicLinkCustomTypeProvider
+    {
+        /// <summary>
+        /// Returns a list of custom types that System.Linq.Dynamic.Core will understand.
+        /// </summary>
+        /// <returns>A <see cref="HashSet&lt;Type&gt;" /> list of custom types.</returns>
+        HashSet<Type> GetCustomTypes();
+
+        /// <summary>
+        /// Resolve any type which is registered in the current application domain.
+        /// </summary>
+        /// <param name="typeName">The typename to resolve.</param>
+        /// <returns>A resolved <see cref="Type"/> or null when not found.</returns>
+        Type ResolveType([NotNull] string typeName);
+    }
+}
diff --git a/src/System.Linq.Dynamic.Core/CustomTypeProviders/IDynamicLinkTypeProvider.cs b/src/System.Linq.Dynamic.Core/CustomTypeProviders/IDynamicLinkTypeProvider.cs
diff --git a/src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs b/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)));
diff --git a/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs b/src/System.Linq.Dynamic.Core/Parser/ExpressionParser.cs
@@ -1525,14 +1525,17 @@ Type FindType(string name)
             {
                 return result;
             }
+
             if (_it != null && _it.Type.Name == name)
             {
                 return _it.Type;
             }
+
             if (_parent != null && _parent.Type.Name == name)
             {
                 return _parent.Type;
             }
+
             if (_root != null && _root.Type.Name == name)
             {
                 return _root.Type;
@@ -1541,15 +1544,22 @@ Type FindType(string name)
             {
                 return _it.Type;
             }
+
             if (_parent != null && _parent.Type.Namespace + "." + _parent.Type.Name == name)
             {
                 return _parent.Type;
             }
+
             if (_root != null && _root.Type.Namespace + "." + _root.Type.Name == name)
             {
                 return _root.Type;
             }
 
+            if (_parsingConfig.AllowNewToEvaluateAnyType && _parsingConfig.CustomTypeProvider != null)
+            {
+                return _parsingConfig.CustomTypeProvider.ResolveType(name);
+            }
+
             return null;
         }
 
diff --git a/src/System.Linq.Dynamic.Core/ParsingConfig.cs b/src/System.Linq.Dynamic.Core/ParsingConfig.cs
@@ -62,5 +62,10 @@ 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;
     }
 }
diff --git a/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj b/src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>This is a .NETStandard/ .NET Core port of the the Microsoft assembly for the .Net 4.0 Dynamic language functionality.</Description>
     <AssemblyTitle>System.Linq.Dynamic.Core</AssemblyTitle>
-    <VersionPrefix>1.0.8.18</VersionPrefix>
+    <VersionPrefix>1.0.9.1</VersionPrefix>
     <Authors>Microsoft;Scott Guthrie;King Wilder;Nathan Arnott;Stef Heyenrath</Authors>
     <TargetFrameworks>net35;net40;net45;net46;netstandard1.3;netstandard2.0;uap10.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
diff --git a/test-uap/WindowsUniversalTestApp14393/WindowsAppCustomTypeProvider.cs b/test-uap/WindowsUniversalTestApp14393/WindowsAppCustomTypeProvider.cs
@@ -17,6 +17,12 @@ public HashSet<Type> GetCustomTypes()
             return new HashSet<Type>(FindTypesMarkedWithDynamicLinqTypeAttribute(assemblies));
         }
 
+        public Type ResolveType(string typeName)
+        {
+            var assemblies = GetAssemblyListAsync().Result;
+            return ResolveType(assemblies, typeName);
+        }
+
         private static async Task<List<Assembly>> GetAssemblyListAsync()
         {
             List<Assembly> assemblies = new List<Assembly>();
diff --git a/test/EntityFramework.DynamicLinq.Tests.net452/EntityFramework.DynamicLinq.Tests.net452.csproj b/test/EntityFramework.DynamicLinq.Tests.net452/EntityFramework.DynamicLinq.Tests.net452.csproj
diff --git a/test/EntityFramework.DynamicLinq.Tests/EntityFramework.DynamicLinq.Tests.csproj b/test/EntityFramework.DynamicLinq.Tests/EntityFramework.DynamicLinq.Tests.csproj
diff --git a/test/System.Linq.Dynamic.Core.Tests/DefaultDynamicLinqCustomTypeProviderTests.cs b/test/System.Linq.Dynamic.Core.Tests/DefaultDynamicLinqCustomTypeProviderTests.cs
diff --git a/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs b/test/System.Linq.Dynamic.Core.Tests/DynamicExpressionParserTests.cs
diff --git a/test/System.Linq.Dynamic.Core.Tests/NetStandardCustomTypeProvider.cs b/test/System.Linq.Dynamic.Core.Tests/NetStandardCustomTypeProvider.cs
diff --git a/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Select.cs b/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Select.cs

Original file line number	Diff line number	Diff line change
`@@ -1525,14 +1525,17 @@ Type FindType(string name)`
`1525`	`1525`	`{`
`1526`	`1526`	`return result;`
`1527`	`1527`	`}`
	`1528`	`+`
`1528`	`1529`	`if (_it != null && _it.Type.Name == name)`
`1529`	`1530`	`{`
`1530`	`1531`	`return _it.Type;`
`1531`	`1532`	`}`
	`1533`	`+`
`1532`	`1534`	`if (_parent != null && _parent.Type.Name == name)`
`1533`	`1535`	`{`
`1534`	`1536`	`return _parent.Type;`
`1535`	`1537`	`}`
	`1538`	`+`
`1536`	`1539`	`if (_root != null && _root.Type.Name == name)`
`1537`	`1540`	`{`
`1538`	`1541`	`return _root.Type;`
`@@ -1541,15 +1544,22 @@ Type FindType(string name)`
`1541`	`1544`	`{`
`1542`	`1545`	`return _it.Type;`
`1543`	`1546`	`}`
	`1547`	`+`
`1544`	`1548`	`if (_parent != null && _parent.Type.Namespace + "." + _parent.Type.Name == name)`
`1545`	`1549`	`{`
`1546`	`1550`	`return _parent.Type;`
`1547`	`1551`	`}`
	`1552`	`+`
`1548`	`1553`	`if (_root != null && _root.Type.Namespace + "." + _root.Type.Name == name)`
`1549`	`1554`	`{`
`1550`	`1555`	`return _root.Type;`
`1551`	`1556`	`}`
`1552`	`1557`
	`1558`	`+ if (_parsingConfig.AllowNewToEvaluateAnyType && _parsingConfig.CustomTypeProvider != null)`
	`1559`	`+ {`
	`1560`	`+ return _parsingConfig.CustomTypeProvider.ResolveType(name);`
	`1561`	`+ }`
	`1562`	`+`
`1553`	`1563`	`return null;`
`1554`	`1564`	`}`
`1555`	`1565`
Original file line number	Diff line number	Diff line change
`@@ -62,5 +62,10 @@ public IDynamicLinkCustomTypeProvider CustomTypeProvider`
`62`	`62`	`/// See https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-2.1#linq-groupby-translation`
`63`	`63`	`/// </summary>`
`64`	`64`	`public bool EvaluateGroupByAtDatabase { get; set; }`
	`65`	`+`
	`66`	`+ /// <summary>`
	`67`	`+ /// Allows the New() keyword to evaluate any available Type.`
	`68`	`+ /// </summary>`
	`69`	`+ public bool AllowNewToEvaluateAnyType { get; set; } = false;`
`65`	`70`	`}`
`66`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,12 @@ public HashSet<Type> GetCustomTypes()`
`17`	`17`	`return new HashSet<Type>(FindTypesMarkedWithDynamicLinqTypeAttribute(assemblies));`
`18`	`18`	`}`
`19`	`19`
	`20`	`+ public Type ResolveType(string typeName)`
	`21`	`+ {`
	`22`	`+ var assemblies = GetAssemblyListAsync().Result;`
	`23`	`+ return ResolveType(assemblies, typeName);`
	`24`	`+ }`
	`25`	`+`
`20`	`26`	`private static async Task<List<Assembly>> GetAssemblyListAsync()`
`21`	`27`	`{`
`22`	`28`	`List<Assembly> assemblies = new List<Assembly>();`