Fix ParseNew to be compatible with NHibernate.Linq... (#18)

* ClassFactory and ParseNew uses a constructor
(This is consistent with .NET compiler-generated code for anonymous types; and is required for compatibility with NHibernate.Linq)

* DefaultDynamicLinqCustomTypeProvider skips assemblies which throw ReflectionTypeLoadException

* Slightly optimized "GenerateConstructor" method. Replaced Type[0] with Type.Empty types, Type.GetType("System.Object") with typeof(object). Updated code formatting to accomodate project styles.

* Replaced two LINQ selects with single for loop (optimized pass time & memory usage). Replaced "var" with "explicit types" to accomodate project style.

* Improved comments. Added a way to check if assemlby is dynamic for .NET Framework 3.5. Replaced new Type[0] with Type.EmptyTypes.

Author: jehhynes

Src/System.Linq.Dynamic/ClassFactory.cs

@@ -93,6 +93,28 @@ private ClassFactory()
 #endif
         }
 
+        private static void GenerateConstructor(TypeBuilder tb, FieldInfo[] fields)
+        {
+            ConstructorInfo objCtor = typeof(object).GetConstructor(Type.EmptyTypes);
+            ConstructorBuilder cb = tb.DefineConstructor(
+                MethodAttributes.Public, 
+                CallingConventions.Standard,
+                fields.Select(x => x.FieldType).ToArray());
+
+            ILGenerator gen = cb.GetILGenerator();
+            gen.Emit(OpCodes.Ldarg_0);
+            gen.Emit(OpCodes.Call, objCtor);
+            for (int i = 0; i < fields.Length; i++)
+            {
+                var f = fields[i];
+
+                gen.Emit(OpCodes.Ldarg_0);
+                gen.Emit(OpCodes.Ldarg, i + 1);
+                gen.Emit(OpCodes.Stfld, f);
+            }
+            gen.Emit(OpCodes.Ret);
+        }
+
         private static FieldInfo[] GenerateProperties(TypeBuilder tb, DynamicProperty[] properties)
         {
             FieldInfo[] fields = new FieldBuilder[properties.Length];
@@ -208,6 +230,7 @@ private Type CreateDynamicClass(Signature signature)
                         TypeAttributes.Class | TypeAttributes.Public, 
                         typeof(DynamicClass));
                     FieldInfo[] fields = GenerateProperties(tb, signature.properties);
+                    GenerateConstructor(tb, fields);
                     GenerateEquals(tb, fields);
                     GenerateGetHashCode(tb, fields);
 

Src/System.Linq.Dynamic/DynamicLinqTypeProvider.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Reflection;
+using System.Reflection.Emit;
 
 namespace System.Linq.Dynamic
 {
@@ -10,7 +12,7 @@ namespace System.Linq.Dynamic
     public sealed class DynamicLinqTypeAttribute : Attribute { }
 
     /// <summary>
-    /// The default <see cref="IDynamicLinkCustomTypeProvider"/>. Scans the current <see cref="AppDomain"/> for all types marked with 
+    /// The default <see cref="IDynamicLinkCustomTypeProvider"/>. Scans the current <see cref="AppDomain"/> for all exported types marked with 
     /// <see cref="DynamicLinqTypeAttribute"/>, and adds them as custom Dynamic Link types.
     /// </summary>
     public class DefaultDynamicLinqCustomTypeProvider : IDynamicLinkCustomTypeProvider
@@ -22,8 +24,24 @@ private static IEnumerable<Type> FindTypesMarkedWithAttribute()
             return AppDomain.CurrentDomain.GetAssemblies()
 #if !NET35
                 .Where(x => !x.IsDynamic)
+#else
+                // Prior to .NET Framework 4.0 there were no "IsDynamic" property.
+                // Thanks to reflection we know that for dynamic assemblies generated via reflection emit
+                // "ManifestModule.ScopeName" is set to "RefEmit_InMemoryManifestModule"
+                .Where(x => x.ManifestModule.ScopeName != "RefEmit_InMemoryManifestModule")
 #endif
-                .SelectMany(x => x.GetTypes())
+                .SelectMany(x =>
+                {
+                    try
+                    {
+                        return x.GetTypes();
+                    }
+                    catch (ReflectionTypeLoadException)
+                    {
+                        // Some referenced assemblies may throw a ReflectionTypeLoadException. In this case, just eat the exception.
+                        return Type.EmptyTypes;
+                    }
+                })
                 .Where(x => x.GetCustomAttributes(typeof(DynamicLinqTypeAttribute), false).Any());
         }
 

Src/System.Linq.Dynamic/ExpressionParser.cs

@@ -1040,10 +1040,16 @@ Expression ParseNew()
             ValidateToken(TokenId.CloseParen, Res.CloseParenOrCommaExpected);
             NextToken();
             Type type = ClassFactory.Instance.GetDynamicClass(properties);
-            MemberBinding[] bindings = new MemberBinding[properties.Count];
-            for (int i = 0; i < bindings.Length; i++)
-                bindings[i] = Expression.Bind(type.GetProperty(properties[i].Name), expressions[i]);
-            return Expression.MemberInit(Expression.New(type), bindings);
+            PropertyInfo[] members = new PropertyInfo[properties.Count];
+            Type[] ctorArgTypes = new Type[properties.Count];
+            for (int i = 0; i < properties.Count; ++i)
+            {
+                DynamicProperty dp = properties[i];
+
+                members[i] = type.GetProperty(dp.Name);
+                ctorArgTypes[i] = dp.Type;
+            }
+            return Expression.New(type.GetConstructor(ctorArgTypes), expressions, members);
         }
 
         Expression ParseLambdaInvocation(LambdaExpression lambda)