Support of Initializing Named Types with new

Author: jogibear9988

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

@@ -1314,10 +1314,22 @@ Expression ParseNew()
             if (_textParser.CurrentToken.Id == TokenId.Identifier)
             {
                 var newTypeName = _textParser.CurrentToken.Text;
+                _textParser.NextToken();
+
+                while (_textParser.CurrentToken.Id == TokenId.Dot || _textParser.CurrentToken.Id == TokenId.Plus)
+                {
+                    var sep = _textParser.CurrentToken.Text;
+                    _textParser.NextToken();
+                    if (_textParser.CurrentToken.Id != TokenId.Identifier)
+                        throw ParseError(Res.IdentifierExpected);
+                    newTypeName += sep + _textParser.CurrentToken.Text;
+                    _textParser.NextToken();
+                }
+
                 newType = FindType(newTypeName);
                 if (newType == null)
                     throw ParseError(_textParser.CurrentToken.Pos, Res.TypeNotFound, newTypeName);
-                _textParser.NextToken();
+               
                 if (_textParser.CurrentToken.Id != TokenId.OpenParen &&
                     _textParser.CurrentToken.Id != TokenId.OpenBracket &&
                     _textParser.CurrentToken.Id != TokenId.OpenCurlyParen)
@@ -1414,9 +1426,13 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
 #endif
                     type = typeof(DynamicClass);
                     Type typeForKeyValuePair = typeof(KeyValuePair<string, object>);
+#if NET35 || NET40
+                    ConstructorInfo constructorForKeyValuePair =
+                        typeForKeyValuePair.GetConstructors().First();
+#else
                     ConstructorInfo constructorForKeyValuePair =
                         typeForKeyValuePair.GetTypeInfo().DeclaredConstructors.First();
-
+#endif
                     var arrayIndexParams = new List<Expression>();
                     for (int i = 0; i < expressions.Count; i++)
                     {
@@ -1433,7 +1449,11 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
                         Expression.NewArrayInit(typeof(KeyValuePair<string, object>), arrayIndexParams);
 
                     // Get the "public DynamicClass(KeyValuePair<string, object>[] propertylist)" constructor
+#if NET35 || NET40
+                    ConstructorInfo constructor = type.GetConstructors().First();
+#else
                     ConstructorInfo constructor = type.GetTypeInfo().DeclaredConstructors.First();
+#endif
                     return Expression.New(constructor, newArrayExpression);
 #if !UAP10_0
                 }
@@ -1446,7 +1466,7 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
 
             Type[] propertyTypes = type.GetProperties().Select(p => p.PropertyType).ToArray();
             ConstructorInfo ctor = type.GetConstructor(propertyTypes);
-            if (ctor != null)
+            if (ctor != null && ctor.GetParameters().Length == expressions.Count)
                 return Expression.New(ctor, expressions);
 
             MemberBinding[] bindings = new MemberBinding[properties.Count];

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

@@ -1,7 +1,9 @@
 using NFluent;
 using System.Collections.Generic;
+using System.Linq.Dynamic.Core.CustomTypeProviders;
 using System.Linq.Dynamic.Core.Exceptions;
 using System.Linq.Expressions;
+using System.Reflection;
 using Xunit;
 using User = System.Linq.Dynamic.Core.Tests.Helpers.Models.User;
 
@@ -23,6 +25,29 @@ private class ComplexParseLambda1Result
             public int TotalIncome;
         }
 
+        [DynamicLinqType]
+        public class ComplexParseLambda3Result
+        {
+            public int? Age { get; set; }
+            public int TotalIncome { get; set; }
+        }
+
+        private class TestCustomTypeProvider : AbstractDynamicLinqCustomTypeProvider, IDynamicLinkCustomTypeProvider
+        {
+            private HashSet<Type> _customTypes;
+
+            public virtual HashSet<Type> GetCustomTypes()
+            {
+                if (_customTypes != null)
+                    return _customTypes;
+
+                _customTypes =
+                    new HashSet<Type>(
+                        FindTypesMarkedWithDynamicLinqTypeAttribute(new[] {this.GetType().GetTypeInfo().Assembly}));
+                return _customTypes;
+            }
+        }
+
         [Fact]
         public void ParseLambda_ToList()
         {
@@ -70,7 +95,6 @@ public void ParseLambda_Complex_1()
             Check.That(result.ToArray()[0]).Equals(expected[0]);
         }
 
-
         [Fact]
         public void ParseLambda_Complex_2()
         {
@@ -92,6 +116,36 @@ public void ParseLambda_Complex_2()
             Check.That(result.ToArray()[0]).Equals(expected[0]);
         }
 
+        [Fact]
+        public void ParseLambda_Complex_3()
+        {
+            GlobalConfig.CustomTypeProvider = new TestCustomTypeProvider();
+
+            // Arrange
+            var testList = User.GenerateSampleModels(51);
+            var qry = testList.AsQueryable();
+
+            var externals = new Dictionary<string, object>
+            {
+                { "Users", qry }
+            };
+
+            // Act
+            string query = "Users.GroupBy(x => new { x.Profile.Age }).OrderBy(gg => gg.Key.Age).Select(j => new System.Linq.Dynamic.Core.Tests.DynamicExpressionParserTests+ComplexParseLambda3Result{j.Key.Age, j.Sum(k => k.Income) As TotalIncome})";
+            LambdaExpression expression = DynamicExpressionParser.ParseLambda(null, query, externals);
+            Delegate del = expression.Compile();
+            IEnumerable<dynamic> result = del.DynamicInvoke() as IEnumerable<dynamic>;
+
+            var expected = qry.GroupBy(x => new { x.Profile.Age }).OrderBy(gg => gg.Key.Age).Select(j => new ComplexParseLambda3Result { Age = j.Key.Age, TotalIncome = j.Sum(k => k.Income) }).Cast<dynamic>().ToArray();
+
+            // Assert
+            Check.That(result).IsNotNull();
+            Check.That(result).HasSize(expected.Length);
+            Check.That(result.ToArray()[0]).Equals(expected[0]);
+
+            GlobalConfig.CustomTypeProvider = null;
+        }
+
         [Fact]
         public void ParseLambda_Select_1()
         {