Restore UseType() and merge DynamicProxy with Pcl.Dynamic

Author: mythz

src/ServiceStack.Text/DynamicProxy.cs

@@ -12,6 +12,11 @@
 using System.Linq;
 using System.Text;
 
+#if !(SL5 ||  __IOS__ || NETFX_CORE)
+using System.Reflection;
+using System.Reflection.Emit;
+#endif
+
 namespace ServiceStack
 {
     public static class DeserializeDynamic<TSerializer>
@@ -183,6 +188,163 @@ internal static string Underscored(IEnumerable<char> pascalCase)
         }
     }
 #endif
-}
 
+#if !(SL5 ||  __IOS__ || NETFX_CORE)
+    public static class DynamicProxy
+    {
+        public static T GetInstanceFor<T>()
+        {
+            return (T)GetInstanceFor(typeof(T));
+        }
+
+        static readonly ModuleBuilder ModuleBuilder;
+        static readonly AssemblyBuilder DynamicAssembly;
+        static readonly Type[] EmptyTypes = new Type[0];
+
+        public static object GetInstanceFor(Type targetType)
+        {
+            lock (DynamicAssembly)
+            {
+                var constructedType = DynamicAssembly.GetType(ProxyName(targetType)) ?? GetConstructedType(targetType);
+                var instance = Activator.CreateInstance(constructedType);
+                return instance;
+            }
+        }
+
+        static string ProxyName(Type targetType)
+        {
+            return targetType.Name + "Proxy";
+        }
+
+        static DynamicProxy()
+        {
+            var assemblyName = new AssemblyName("DynImpl");
+#if NETSTANDARD1_1
+            DynamicAssembly = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
+#else
+            DynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
+#endif
+            ModuleBuilder = DynamicAssembly.DefineDynamicModule("DynImplModule");
+        }
+
+        static Type GetConstructedType(Type targetType)
+        {
+            var typeBuilder = ModuleBuilder.DefineType(targetType.Name + "Proxy", TypeAttributes.Public);
+
+            var ctorBuilder = typeBuilder.DefineConstructor(
+                MethodAttributes.Public,
+                CallingConventions.Standard,
+                new Type[] { });
+            var ilGenerator = ctorBuilder.GetILGenerator();
+            ilGenerator.Emit(OpCodes.Ret);
+
+            IncludeType(targetType, typeBuilder);
+
+            foreach (var face in targetType.GetTypeInterfaces())
+                IncludeType(face, typeBuilder);
+
+#if NETSTANDARD1_1
+            return typeBuilder.CreateTypeInfo().AsType();
+#else
+            return typeBuilder.CreateType();
+#endif
+        }
+
+        static void IncludeType(Type typeOfT, TypeBuilder typeBuilder)
+        {
+            var methodInfos = typeOfT.GetMethodInfos();
+            foreach (var methodInfo in methodInfos)
+            {
+                if (methodInfo.Name.StartsWith("set_", StringComparison.Ordinal)) continue; // we always add a set for a get.
+
+                if (methodInfo.Name.StartsWith("get_", StringComparison.Ordinal))
+                {
+                    BindProperty(typeBuilder, methodInfo);
+                }
+                else
+                {
+                    BindMethod(typeBuilder, methodInfo);
+                }
+            }
+
+            typeBuilder.AddInterfaceImplementation(typeOfT);
+        }
+
+        static void BindMethod(TypeBuilder typeBuilder, MethodInfo methodInfo)
+        {
+            var methodBuilder = typeBuilder.DefineMethod(
+                methodInfo.Name,
+                MethodAttributes.Public | MethodAttributes.Virtual,
+                methodInfo.ReturnType,
+                methodInfo.GetParameters().Select(p => p.GetType()).ToArray()
+                );
+            var methodILGen = methodBuilder.GetILGenerator();
+            if (methodInfo.ReturnType == typeof(void))
+            {
+                methodILGen.Emit(OpCodes.Ret);
+            }
+            else
+            {
+                if (methodInfo.ReturnType.IsValueType() || methodInfo.ReturnType.IsEnum())
+                {
+#if NETSTANDARD1_1
+                    MethodInfo getMethod = typeof(Activator).GetMethod("CreateInstance");
+#else
+                    MethodInfo getMethod = typeof(Activator).GetMethod("CreateInstance",
+                                                                       new[] { typeof(Type) });
+#endif
+                    LocalBuilder lb = methodILGen.DeclareLocal(methodInfo.ReturnType);
+                    methodILGen.Emit(OpCodes.Ldtoken, lb.LocalType);
+                    methodILGen.Emit(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"));
+                    methodILGen.Emit(OpCodes.Callvirt, getMethod);
+                    methodILGen.Emit(OpCodes.Unbox_Any, lb.LocalType);
+                }
+                else
+                {
+                    methodILGen.Emit(OpCodes.Ldnull);
+                }
+                methodILGen.Emit(OpCodes.Ret);
+            }
+            typeBuilder.DefineMethodOverride(methodBuilder, methodInfo);
+        }
+
+        public static void BindProperty(TypeBuilder typeBuilder, MethodInfo methodInfo)
+        {
+            // Backing Field
+            string propertyName = methodInfo.Name.Replace("get_", "");
+            Type propertyType = methodInfo.ReturnType;
+            FieldBuilder backingField = typeBuilder.DefineField("_" + propertyName, propertyType, FieldAttributes.Private);
+
+            //Getter
+            MethodBuilder backingGet = typeBuilder.DefineMethod("get_" + propertyName, MethodAttributes.Public |
+                MethodAttributes.SpecialName | MethodAttributes.Virtual |
+                MethodAttributes.HideBySig, propertyType, EmptyTypes);
+            ILGenerator getIl = backingGet.GetILGenerator();
+
+            getIl.Emit(OpCodes.Ldarg_0);
+            getIl.Emit(OpCodes.Ldfld, backingField);
+            getIl.Emit(OpCodes.Ret);
+
+
+            //Setter
+            MethodBuilder backingSet = typeBuilder.DefineMethod("set_" + propertyName, MethodAttributes.Public |
+                MethodAttributes.SpecialName | MethodAttributes.Virtual |
+                MethodAttributes.HideBySig, null, new[] { propertyType });
+
+            ILGenerator setIl = backingSet.GetILGenerator();
+
+            setIl.Emit(OpCodes.Ldarg_0);
+            setIl.Emit(OpCodes.Ldarg_1);
+            setIl.Emit(OpCodes.Stfld, backingField);
+            setIl.Emit(OpCodes.Ret);
+
+            // Property
+            PropertyBuilder propertyBuilder = typeBuilder.DefineProperty(propertyName, PropertyAttributes.None, propertyType, null);
+            propertyBuilder.SetGetMethod(backingGet);
+            propertyBuilder.SetSetMethod(backingSet);
+        }
+    }
+#endif
+
+}
 #endif

src/ServiceStack.Text/Pcl.Dynamic.cs

@@ -568,6 +568,15 @@ public override SetPropertyDelegate GetSetMethod(PropertyInfo propertyInfo, Fiel
                 : CreateIlFieldSetter(fieldInfo);
         }
 
+        public override Type UseType(Type type)
+        {
+            if (type.IsInterface || type.IsAbstract)
+            {
+                return DynamicProxy.GetInstanceFor(type).GetType();
+            }
+            return type;
+        }
+
         public override DataContractAttribute GetWeakDataContract(Type type)
         {
             return type.GetWeakDataContract();

src/ServiceStack.Text/PclExport.Net40.cs

@@ -269,7 +269,6 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ParseAsType.cs" />
-    <Compile Include="DynamicProxy.cs" />
     <Compile Include="PclExport.NetStandard.cs" />
   </ItemGroup>
   <!--ItemGroup,Content-->

src/ServiceStack.Text/ServiceStack.Text.PCL.csproj

@@ -292,7 +292,6 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ParseAsType.cs" />
-    <Compile Include="DynamicProxy.cs" />
     <Compile Include="PclExport.NetStandard.cs" />
   </ItemGroup>
   <!--ItemGroup,Content-->

src/ServiceStack.Text/ServiceStack.Text.SL5.csproj

@@ -328,7 +328,6 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ParseAsType.cs" />
-    <Compile Include="DynamicProxy.cs" />
     <Compile Include="PclExport.NetStandard.cs" />
   </ItemGroup>
   <ItemGroup>

src/ServiceStack.Text/ServiceStack.Text.Signed.csproj

@@ -322,7 +322,6 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="ParseAsType.cs" />
-    <Compile Include="DynamicProxy.cs" />
     <Compile Include="PclExport.NetStandard.cs" />
   </ItemGroup>
   <ItemGroup>