bind expressions to correct constructor parameter

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

@@ -1466,20 +1466,25 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
 
             Type[] propertyTypes = propertyInfos.Select(p => p.PropertyType).ToArray();
             ConstructorInfo ctor = type.GetConstructor(propertyTypes);
-            if (ctor != null && ctor.GetParameters().Length == expressions.Count)
+            if (ctor != null)
             {
-                var expressionsPromoted = new List<Expression>();
-
-                // Loop all expressions and promote if needed
-                for (int i = 0; i < propertyTypes.Length; i++)
+                var ctorParameters = ctor.GetParameters();
+                if (ctorParameters.Length == expressions.Count)
                 {
-                    Type propertyType = propertyTypes[i];
+                    var expressionsPromoted = new List<Expression>();
+                    // Loop all expressions and promote if needed
+                    for (int i = 0; i < ctorParameters.Length; i++)
+                    {
+                        Type propertyType = ctorParameters[i].ParameterType;
+                        string cParameterName = ctorParameters[i].Name;
+                        var propertyAndIndex = properties.Select((p, index) => new { p, index })
+                            .First(p => p.p.Name == cParameterName && p.p.Type == propertyType);
+                        // Promote from Type to Nullable Type if needed
+                        expressionsPromoted.Add(_parsingConfig.ExpressionPromoter.Promote(expressions[propertyAndIndex.index], propertyType, true, true));
+                    }
 
-                    // Promote from Type to Nullable Type if needed
-                    expressionsPromoted.Add(_parsingConfig.ExpressionPromoter.Promote(expressions[i], propertyType, true, true));
+                    return Expression.New(ctor, expressionsPromoted, (IEnumerable<MemberInfo>)propertyInfos);
                 }
-
-                return Expression.New(ctor, expressionsPromoted, (IEnumerable<MemberInfo>)propertyInfos);
             }
 
             MemberBinding[] bindings = new MemberBinding[properties.Count];

test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.TypeAccess.cs

@@ -1,4 +1,5 @@
-using System.Linq.Dynamic.Core.Parser;
+using System.Collections.Generic;
+using System.Linq.Dynamic.Core.Parser;
 using System.Linq.Expressions;
 using FluentAssertions;
 using Xunit;
@@ -97,5 +98,28 @@ public void ParseTypeAccess_Via_Constructor_String_And_UriKind_To_Uri()
             // Assert
             expression.ToString().Should().Be("new Uri(\"https://www.example.com/\", Absolute)");
         }
+
+        [Theory]
+        [InlineData("new(2 as b, 1 as a)", "new(1 as a, 2 as b)")]
+        public void ParseTypeAccess_Via_Constructor_DynamicType_To_String(string newExpression, string newExpression2)
+        {
+            // Arrange
+            var parameter = Expression.Parameter(typeof(int));
+            var parameter2 = Expression.Parameter(typeof(int));
+            var returnType = DynamicClassFactory.CreateType(new List<DynamicProperty> {
+                new DynamicProperty("a", typeof(int)),
+                new DynamicProperty("b", typeof(int))
+            });
+
+            // Act
+            var parser = new ExpressionParser(new[] { parameter, parameter2 }, newExpression, new object[] { }, ParsingConfig.Default);
+            var parser2 = new ExpressionParser(new[] { parameter, parameter2 }, newExpression2, new object[] { }, ParsingConfig.Default);
+
+            var expression = parser.Parse(returnType);
+            var expression2 = parser2.Parse(returnType);
+            // Assert
+            expression.ToString().Should().Be("new "+ returnType.Name + "(a = 1, b = 2)");
+            expression2.ToString().Should().Be("new "+ returnType.Name + "(a = 1, b = 2)");
+        }
     }
 }