Support nullable notation "xxx?" in As expression

src-console/ConsoleApp_net6.0/ConsoleApp_net6.0.csproj

@@ -1,13 +1,14 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net6.0</TargetFramework>
-    <RootNamespace>ConsoleApp_net6._0</RootNamespace>
-  </PropertyGroup>
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net6.0</TargetFramework>
+        <RootNamespace>ConsoleApp_net6._0</RootNamespace>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
 
-  <ItemGroup>
-    <ProjectReference Include="..\..\src\System.Linq.Dynamic.Core\System.Linq.Dynamic.Core.csproj" />
-  </ItemGroup>
+    <ItemGroup>
+        <ProjectReference Include="..\..\src\System.Linq.Dynamic.Core\System.Linq.Dynamic.Core.csproj" />
+    </ItemGroup>
 
 </Project>

src-console/ConsoleApp_net6.0/Program.cs

@@ -1,17 +1,35 @@
-using System;
+using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Dynamic.Core;
 
 namespace ConsoleApp_net6._0
 {
+    public class X
+    {
+        public string Key { get; set; } = null!;
+
+        public List<Y>? Contestants { get; set; }
+    }
+
+    public class Y
+    {
+    }
+
     class Program
     {
         static void Main(string[] args)
         {
+            var q = new[]
+            {
+                new X { Key = "x" },
+                new X { Key = "a" },
+                new X { Key = "a", Contestants = new List<Y> { new Y() } }
+            }.AsQueryable();
+            var groupByKey = q.GroupBy("Key");
+            var selectQry = groupByKey.Select("new (Key, Sum(np(Contestants.Count, 0)) As TotalCount)").ToDynamicList();
+
             Normal();
             Dynamic();
-
-            int y = 0;
         }
 
         private static void Normal()
@@ -40,4 +58,4 @@ private static void Dynamic()
             //var d = q.FirstOrDefault(i => i == 0, 42);
         }
     }
-}
+}

src/System.Linq.Dynamic.Core/CustomTypeProviders/DefaultDynamicLinqCustomTypeProvider.cs

@@ -66,7 +66,7 @@ public Dictionary<Type, List<MethodInfo>> GetExtensionMethods()
         /// <inheritdoc cref="IDynamicLinqCustomTypeProvider.ResolveType"/>
         public Type? ResolveType(string typeName)
         {
-            Check.NotEmpty(typeName, nameof(typeName));
+            Check.NotEmpty(typeName);
 
             IEnumerable<Assembly> assemblies = _assemblyHelper.GetAssemblies();
             return ResolveType(assemblies, typeName);
@@ -75,7 +75,7 @@ public Dictionary<Type, List<MethodInfo>> GetExtensionMethods()
         /// <inheritdoc cref="IDynamicLinqCustomTypeProvider.ResolveTypeBySimpleName"/>
         public Type? ResolveTypeBySimpleName(string simpleTypeName)
         {
-            Check.NotEmpty(simpleTypeName, nameof(simpleTypeName));
+            Check.NotEmpty(simpleTypeName);
 
             IEnumerable<Assembly> assemblies = _assemblyHelper.GetAssemblies();
             return ResolveTypeBySimpleName(assemblies, simpleTypeName);

src/System.Linq.Dynamic.Core/Extensions/LinqExtensions.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace System.Linq.Dynamic.Core.Extensions
+{
+    internal static class LinqExtensions
+    {
+        // Ex: collection.TakeLast(5);
+        public static IEnumerable<T> TakeLast<T>(this IList<T> source, int n)
+        {
+            return source.Skip(Math.Max(0, source.Count() - n));
+        }
+    }
+}

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

@@ -1907,13 +1907,20 @@ private Type ResolveTypeFromArgumentExpression(string functionName, Expression a
 
         private Type ResolveTypeStringFromArgument(string typeName)
         {
+            bool typeIsNullable = false;
+            if (typeName.EndsWith("?"))
+            {
+                typeName = typeName.TrimEnd('?');
+                typeIsNullable = true;
+            }
+
             var resultType = _typeFinder.FindTypeByName(typeName, new[] { _it, _parent, _root }, true);
             if (resultType == null)
             {
                 throw ParseError(_textParser.CurrentToken.Pos, Res.TypeNotFound, typeName);
             }
 
-            return resultType;
+            return typeIsNullable ? TypeHelper.ToNullableType(resultType) : resultType;
         }
 
         private Expression[] ParseArgumentList()

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

@@ -311,16 +311,29 @@ public static bool IsNullableType(Type type)
 
         public static bool TypeCanBeNull(Type type)
         {
-            Check.NotNull(type, nameof(type));
+            Check.NotNull(type);
 
             return !type.GetTypeInfo().IsValueType || IsNullableType(type);
         }
 
         public static Type ToNullableType(Type type)
         {
-            Check.NotNull(type, nameof(type));
+            Check.NotNull(type);
+
+            if (IsNullableType(type))
+            {
+                // Already nullable, just return the type.
+                return type;
+            }
+
+            if (!type.GetTypeInfo().IsValueType)
+            {
+                // Type is a not a value type, just return the type.
+                return type;
+            }
 
-            return IsNullableType(type) ? type : typeof(Nullable<>).MakeGenericType(type);
+            // Convert type to a nullable type
+            return typeof(Nullable<>).MakeGenericType(type);
         }
 
         public static bool IsSignedIntegralType(Type type)

test/System.Linq.Dynamic.Core.Tests.Net7/System.Linq.Dynamic.Core.Tests.Net7.csproj

@@ -7,7 +7,7 @@
         <SignAssembly>True</SignAssembly>
         <AssemblyOriginatorKeyFile>../../src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.snk</AssemblyOriginatorKeyFile>
         <IsPackable>false</IsPackable>
-
+        <Nullable>enable</Nullable>
         <DefineConstants>$(DefineConstants);NETCOREAPP;EFCORE;EFCORE_3X;NETCOREAPP3_1</DefineConstants>
     </PropertyGroup>
 

test/System.Linq.Dynamic.Core.Tests/Entities/Department.cs

@@ -3,5 +3,7 @@
     public class Department
     {
         public BaseEmployee Employee { get; set; }
+
+        public BaseEmployee? NullableEmployee { get; set; }
     }
 }

test/System.Linq.Dynamic.Core.Tests/ExpressionTests.cs

@@ -1,10 +1,12 @@
 using System.Collections.Generic;
 using System.Dynamic;
 using System.Globalization;
+using System.Linq.Dynamic.Core.CustomTypeProviders;
 using System.Linq.Dynamic.Core.Exceptions;
 using System.Linq.Dynamic.Core.Tests.Helpers;
 using System.Linq.Dynamic.Core.Tests.Helpers.Models;
 using FluentAssertions;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
 using Xunit;
@@ -251,7 +253,7 @@ public void ExpressionTests_BinaryOrNumericConvert()
         }
 
         [Fact]
-        public void ExpressionTests_Cast_To_nullableint()
+        public void ExpressionTests_Cast_To_NullableInt()
         {
             // Arrange
             var list = new List<SimpleValuesModel>
@@ -268,7 +270,94 @@ public void ExpressionTests_Cast_To_nullableint()
         }
 
         [Fact]
-        public void ExpressionTests_Cast_Automatic_To_nullablelong()
+        public void ExpressionTests_Cast_To_Enum_Using_DynamicLinqType()
+        {
+            // Arrange
+            var list = new List<SimpleValuesModel>
+            {
+                new SimpleValuesModel { EnumValueDynamicLinqType = SimpleValuesModelEnumAsDynamicLinqType.A }
+            };
+
+            // Act
+            var expectedResult = list.Select(x => x.EnumValueDynamicLinqType);
+            var result = list.AsQueryable().Select("SimpleValuesModelEnumAsDynamicLinqType(EnumValueDynamicLinqType)");
+
+            // Assert
+            Assert.Equal(expectedResult.ToArray(), result.ToDynamicArray<SimpleValuesModelEnumAsDynamicLinqType>());
+        }
+
+        [Fact]
+        public void ExpressionTests_Cast_To_Enum_Using_CustomTypeProvider()
+        {
+            // Arrange
+            var dynamicLinqCustomTypeProviderMock = new Mock<IDynamicLinkCustomTypeProvider>();
+            dynamicLinqCustomTypeProviderMock.Setup(d => d.GetCustomTypes()).Returns(new HashSet<Type> { typeof(SimpleValuesModelEnum) });
+            var config = new ParsingConfig
+            {
+                CustomTypeProvider = dynamicLinqCustomTypeProviderMock.Object
+            };
+
+            var list = new List<SimpleValuesModel>
+            {
+                new SimpleValuesModel { EnumValue = SimpleValuesModelEnum.A }
+            };
+
+            // Act
+            var expectedResult = list.Select(x => x.EnumValue);
+            var result = list.AsQueryable().Select(config, "SimpleValuesModelEnum(EnumValue)");
+
+            // Assert
+            Assert.Equal(expectedResult.ToArray(), result.ToDynamicArray<SimpleValuesModelEnum>());
+        }
+
+        [Fact]
+        public void ExpressionTests_Cast_To_NullableEnum_Using_DynamicLinqType()
+        {
+            // Arrange
+            var list = new List<SimpleValuesModel>
+            {
+                new SimpleValuesModel { EnumValueDynamicLinqType = SimpleValuesModelEnumAsDynamicLinqType.A }
+            };
+
+            // Act
+            var expectedResult = list.Select(x => (SimpleValuesModelEnumAsDynamicLinqType?)x.EnumValueDynamicLinqType);
+            var result = list.AsQueryable().Select("SimpleValuesModelEnumAsDynamicLinqType?(EnumValueDynamicLinqType)");
+
+            // Assert
+            Assert.Equal(expectedResult.ToArray(), result.ToDynamicArray<SimpleValuesModelEnumAsDynamicLinqType?>());
+        }
+
+        [Fact]
+        public void ExpressionTests_Cast_To_NullableEnum_Using_CustomTypeProvider()
+        {
+            // Arrange
+            var dynamicLinqCustomTypeProviderMock = new Mock<IDynamicLinkCustomTypeProvider>();
+            dynamicLinqCustomTypeProviderMock.Setup(d => d.GetCustomTypes()).Returns(new HashSet<Type>
+            {
+                typeof(SimpleValuesModelEnum),
+                typeof(SimpleValuesModelEnum?)
+            });
+
+            var config = new ParsingConfig
+            {
+                CustomTypeProvider = dynamicLinqCustomTypeProviderMock.Object
+            };
+
+            var list = new List<SimpleValuesModel>
+            {
+                new SimpleValuesModel { EnumValue = SimpleValuesModelEnum.A }
+            };
+
+            // Act
+            var expectedResult = list.Select(x => (SimpleValuesModelEnum?)x.EnumValue);
+            var result = list.AsQueryable().Select(config, $"SimpleValuesModelEnum?(EnumValue)");
+
+            // Assert
+            Assert.Equal(expectedResult.ToArray(), result.ToDynamicArray<SimpleValuesModelEnum?>());
+        }
+
+        [Fact]
+        public void ExpressionTests_Cast_Automatic_To_NullableLong()
         {
             // Arrange
             var q = new[] { null, new UserProfile(), new UserProfile { UserProfileDetails = new UserProfileDetails { Id = 42 } } }.AsQueryable();
@@ -282,7 +371,7 @@ public void ExpressionTests_Cast_Automatic_To_nullablelong()
         }
 
         [Fact]
-        public void ExpressionTests_Cast_To_newnullableint()
+        public void ExpressionTests_Cast_To_NewNullableInt()
         {
             // Arrange
             var list = new List<SimpleValuesModel>

test/System.Linq.Dynamic.Core.Tests/Helpers/Models/SimpleValuesModel.cs

@@ -1,6 +1,20 @@
-
+using System.Linq.Dynamic.Core.CustomTypeProviders;
+
 namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
 {
+    public enum SimpleValuesModelEnum
+    {
+        A,
+        B
+    }
+
+    [DynamicLinqType]
+    public enum SimpleValuesModelEnumAsDynamicLinqType
+    {
+        A,
+        B
+    }
+
     public class SimpleValuesModel
     {
         public int IntValue { get; set; }
@@ -14,5 +28,9 @@ public class SimpleValuesModel
         public int? NullableIntValue { get; set; }
 
         public double? NullableDoubleValue { get; set; }
+
+        public SimpleValuesModelEnum EnumValue { get; set; }
+
+        public SimpleValuesModelEnumAsDynamicLinqType EnumValueDynamicLinqType { get; set; }
     }
-}
+}