Remove option for 'UseDynamicObjectClassForAnonymousTypes' (#353)

* fix

* remove config setting

Author: StefH

src/System.Linq.Dynamic.Core/DynamicClass.net35.cs

@@ -1,4 +1,6 @@
 #if NET35
+using System.Collections.Generic;
+
 namespace System.Linq.Dynamic.Core
 {
     /// <summary>

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

@@ -1400,40 +1400,30 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
 
             if (type == null)
             {
-#if !UAP10_0
-                if (_parsingConfig != null && _parsingConfig.UseDynamicObjectClassForAnonymousTypes)
-                {
-#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++)
-                    {
-                        // Just convert the expression always to an object expression.
-                        UnaryExpression boxingExpression = Expression.Convert(expressions[i], typeof(object));
-                        NewExpression parameter = Expression.New(constructorForKeyValuePair, (Expression)Expression.Constant(properties[i].Name), boxingExpression);
+#if UAP10_0
+                type = typeof(DynamicClass);
+                Type typeForKeyValuePair = typeof(KeyValuePair<string, object>);
 
-                        arrayIndexParams.Add(parameter);
-                    }
+                ConstructorInfo constructorForKeyValuePair = typeForKeyValuePair.GetTypeInfo().DeclaredConstructors.First();
 
-                    // Create an expression tree that represents creating and initializing a one-dimensional array of type KeyValuePair<string, object>.
-                    NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(KeyValuePair<string, object>), arrayIndexParams);
+                var arrayIndexParams = new List<Expression>();
+                for (int i = 0; i < expressions.Count; i++)
+                {
+                    // Just convert the expression always to an object expression.
+                    UnaryExpression boxingExpression = Expression.Convert(expressions[i], typeof(object));
+                    NewExpression parameter = Expression.New(constructorForKeyValuePair, (Expression)Expression.Constant(properties[i].Name), boxingExpression);
 
-                    // 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
+                    arrayIndexParams.Add(parameter);
                 }
 
+                // Create an expression tree that represents creating and initializing a one-dimensional array of type KeyValuePair<string, object>.
+                NewArrayExpression newArrayExpression = Expression.NewArrayInit(typeof(KeyValuePair<string, object>), arrayIndexParams);
+
+                // Get the "public DynamicClass(KeyValuePair<string, object>[] propertylist)" constructor
+                ConstructorInfo constructor = type.GetTypeInfo().DeclaredConstructors.First();
+
+                return Expression.New(constructor, newArrayExpression);
+#else
                 type = DynamicClassFactory.CreateType(properties, _createParameterCtor);
 #endif
             }
@@ -1454,7 +1444,6 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
                 for (int i = 0; i < propertyTypes.Length; i++)
                 {
                     Type propertyType = propertyTypes[i];
-                    // Type expressionType = expressions[i].Type;
 
                     // Promote from Type to Nullable Type if needed
                     expressionsPromoted.Add(_parsingConfig.ExpressionPromoter.Promote(expressions[i], propertyType, true, true));
@@ -1468,7 +1457,6 @@ private Expression CreateNewExpression(List<DynamicProperty> properties, List<Ex
             {
                 PropertyInfo property = type.GetProperty(properties[i].Name);
                 Type propertyType = property.PropertyType;
-                // Type expressionType = expressions[i].Type;
 
                 // Promote from Type to Nullable Type if needed
                 bindings[i] = Expression.Bind(property, _parsingConfig.ExpressionPromoter.Promote(expressions[i], propertyType, true, true));

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

@@ -95,13 +95,6 @@ public IQueryableAnalyzer QueryableAnalyzer
         /// </summary>
         public bool AreContextKeywordsEnabled { get; set; } = true;
 
-        /// <summary>
-        /// Gets or sets a value indicating whether to use dynamic object class for anonymous types.
-        ///
-        /// Default value is false.
-        /// </summary>
-        public bool UseDynamicObjectClassForAnonymousTypes { get; set; } = false;
-
         /// <summary>
         /// Gets or sets a value indicating whether the EntityFramework version supports evaluating GroupBy at database level.
         /// See https://docs.microsoft.com/en-us/ef/core/what-is-new/ef-core-2.1#linq-groupby-translation

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

@@ -5,6 +5,7 @@
 using System.Linq.Dynamic.Core.Tests.Helpers.Models;
 using System.Linq.Expressions;
 using System.Reflection;
+using FluentAssertions;
 using Xunit;
 using User = System.Linq.Dynamic.Core.Tests.Helpers.Models.User;