added system.reflection namespace to ignore, some refactoring

Author: force-net

DeepCloner.Tests/ClrExceptionSpec.cs

@@ -1,9 +1,6 @@
 #if !NETCORE
 using System;
 using System.Collections.Generic;
-using System.Reflection;
-
-using Force.DeepCloner.Helpers;
 
 using NUnit.Framework;
 

DeepCloner.Tests/InheritanceSpec.cs

@@ -237,5 +237,74 @@ public void Array_Of_Struct_Casted_To_Interface_Should_Be_Cloned()
 			var clonedArr = arr.DeepClone();
 			Assert.That(clonedArr[0], Is.EqualTo(clonedArr[1]));
 		}
+
+		public class Safe1
+		{
+		}
+
+		public class Safe2
+		{
+		}
+
+		public class Unsafe1 : Safe1
+		{
+			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
+			public object X;
+		}
+
+		public class V1
+		{
+			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
+			public Safe1 Safe;
+		}
+
+		public class V2
+		{
+			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
+			public Safe1 Safe;
+
+ 			public V2(string x)
+			{
+			}
+		}
+
+		// these tests are overlapped by others, but for future can be helpful
+		[Test]
+		public void Class_With_Safe_Class_Should_Be_Cloned()
+		{
+			var v = new V1();
+			v.Safe = new Safe1();
+			var v2 = v.DeepClone();
+			Assert.That(v.Safe == v2.Safe, Is.False);
+		}
+
+		[Test]
+		public void Class_With_Safe_Class_Should_Be_Cloned_No_Default_Constructor()
+		{
+			var v = new V2("X");
+			v.Safe = new Safe1();
+			var v2 = v.DeepClone();
+			Assert.That(v.Safe == v2.Safe, Is.False);
+		}
+
+		[Test]
+		public void Class_With_UnSafe_Class_Should_Be_Cloned()
+		{
+			var v = new V1();
+			v.Safe = new Unsafe1();
+			var v2 = v.DeepClone();
+			Assert.That(v.Safe == v2.Safe, Is.False);
+			Assert.That(v2.Safe.GetType(), Is.EqualTo(typeof(Unsafe1)));
+		}
+
+		[Test]
+		public void Class_With_UnSafe_Class_Should_Be_Cloned_No_Default_Constructor()
+		{
+			var v = new V2("X");
+			v.Safe = new Unsafe1();
+			var v2 = v.DeepClone();
+			Assert.That(v.Safe == v2.Safe, Is.False);
+			Assert.That(v2.Safe.GetType(), Is.EqualTo(typeof(Unsafe1)));
+		}
 	}
 }

DeepCloner.nuspec

@@ -3,7 +3,7 @@
   <metadata>
     <id>DeepCloner</id>
     <title>DeepCloner</title>
-    <version>0.10.1</version>
+    <version>0.10.2</version>
     <authors>force</authors>
     <owners>force</owners>
     <licenseUrl>https://github.com/force-net/DeepCloner/blob/develop/LICENSE</licenseUrl>
@@ -12,8 +12,8 @@
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>Small Library for fast deep or shallow cloning .NET objects. It allows to copy everything and has a lot of performance tricks for fast copying.</description>
     <releaseNotes>
-Fixed cloning of COM objects, some internal structures (RuntimeType, Remoting). Trying to improve cloning for dotnet core, excluded some internal classes.
-As result, some EF queries can be deep cloned without errors. 
+Removed System.Reflection namespace (especially System.Reflection.Emit) from cloning.
+More accurate checking for empty constructors. 
     </releaseNotes>
     <copyright>Copyright by Force 2016-2017</copyright>
     <tags>.NET shallow deep clone DeepClone fast</tags>

DeepCloner/Helpers/ClonerToExprGenerator.cs

@@ -67,7 +67,7 @@ private static object GenerateProcessMethod(Type type, bool isDeepClone)
 
 			foreach (var fieldInfo in fi)
 			{
-				if (isDeepClone && !DeepClonerSafeTypes.IsTypeSafe(fieldInfo.FieldType, null))
+				if (isDeepClone && !DeepClonerSafeTypes.CanNotCopyType(fieldInfo.FieldType, null))
 				{
 					var methodInfo = fieldInfo.FieldType.IsValueType()
 						? typeof(DeepClonerGenerator).GetPrivateStaticMethod("CloneStructInternal")
@@ -136,7 +136,7 @@ private static object GenerateProcessArrayMethod(Type type, bool isDeep)
 				else
 				{
 					var methodName = "Clone1DimArrayClassInternal";
-					if (DeepClonerSafeTypes.IsTypeSafe(elementType, null)) methodName = "Clone1DimArraySafeInternal";
+					if (DeepClonerSafeTypes.CanNotCopyType(elementType, null)) methodName = "Clone1DimArraySafeInternal";
 					else if (elementType.IsValueType()) methodName = "Clone1DimArrayStructInternal";
 					var methodInfo = typeof(ClonerToExprGenerator).GetPrivateStaticMethod(methodName).MakeGenericMethod(elementType);
 					var callS = Expression.Call(methodInfo, Expression.Convert(from, type), Expression.Convert(to, type), state);
@@ -204,7 +204,7 @@ internal static T[] Clone1DimArrayClassInternal<T>(T[] objFrom, T[] objTo, DeepC
 			var l1 = Math.Min(objFrom.GetLength(0), objTo.GetLength(0));
 			var l2 = Math.Min(objFrom.GetLength(1), objTo.GetLength(1));
 			state.AddKnownRef(objFrom, objTo);
-			if ((!isDeep || DeepClonerSafeTypes.IsTypeSafe(typeof(T), null))
+			if ((!isDeep || DeepClonerSafeTypes.CanNotCopyType(typeof(T), null))
 			    && objFrom.GetLength(0) == objTo.GetLength(0)
 			    && objFrom.GetLength(1) == objTo.GetLength(1))
 			{

DeepCloner/Helpers/DeepClonerExprGenerator.cs

@@ -9,7 +9,7 @@ internal static class DeepClonerExprGenerator
 	{
 		internal static object GenerateClonerInternal(Type realType, bool asObject)
 		{
-			if (DeepClonerSafeTypes.IsTypeSafe(realType, null)) return null;
+			if (DeepClonerSafeTypes.CanNotCopyType(realType, null)) return null;
 
 			return GenerateProcessMethod(realType, asObject && realType.IsValueType());
 		}
@@ -100,7 +100,7 @@ private static object GenerateProcessMethod(Type type, bool unboxStruct)
 
 			foreach (var fieldInfo in fi)
 			{
-				if (!DeepClonerSafeTypes.IsTypeSafe(fieldInfo.FieldType, null))
+				if (!DeepClonerSafeTypes.CanNotCopyType(fieldInfo.FieldType, null))
 				{
 					var methodInfo = fieldInfo.FieldType.IsValueType()
 										? typeof(DeepClonerGenerator).GetPrivateStaticMethod("CloneStructInternal")
@@ -164,7 +164,7 @@ private static object GenerateProcessArrayMethod(Type type)
 			else
 			{
 				var methodName = "Clone1DimArrayClassInternal";
-				if (DeepClonerSafeTypes.IsTypeSafe(elementType, null)) methodName = "Clone1DimArraySafeInternal";
+				if (DeepClonerSafeTypes.CanNotCopyType(elementType, null)) methodName = "Clone1DimArraySafeInternal";
 				else if (elementType.IsValueType()) methodName = "Clone1DimArrayStructInternal";
 				methodInfo = typeof(DeepClonerGenerator).GetPrivateStaticMethod(methodName).MakeGenericMethod(elementType);
 			}

DeepCloner/Helpers/DeepClonerGenerator.cs

@@ -20,7 +20,7 @@ private static object CloneClassRoot(object obj)
 			// we can receive an poco objects which is faster to copy in shallow way if possible
 			var type = obj.GetType();
 			// 200ms
-			if (DeepClonerSafeTypes.IsClassSafe(type)) 
+			if (DeepClonerSafeTypes.CanNotDeepCopyClass(type)) 
 				return ShallowObjectCloner.CloneObject(obj);
 			// 350ms
 			var cloner = (Func<object, DeepCloneState, object>)DeepClonerCache.GetOrAddClass(type, t => GenerateCloner(t, true));
@@ -109,7 +109,7 @@ internal static T[] Clone1DimArrayClassInternal<T>(T[] obj, DeepCloneState state
 			var l2 = obj.GetLength(1);
 			var outArray = new T[l1, l2];
 			state.AddKnownRef(obj, outArray);
-			if (DeepClonerSafeTypes.IsTypeSafe(typeof(T), null))
+			if (DeepClonerSafeTypes.CanNotCopyType(typeof(T), null))
 			{
 				Array.Copy(obj, outArray, obj.Length);
 				return outArray;

DeepCloner/Helpers/DeepClonerMsilGenerator.cs

@@ -17,7 +17,7 @@ internal static object GenerateClonerInternal(Type realType, bool asObject)
 			// there is no performance penalties to cast objects to concrete type, but we can win in removing other conversions
 			var methodType = asObject ? typeof(object) : realType;
 
-			if (DeepClonerSafeTypes.IsTypeSafe(realType, null)) return null;
+			if (DeepClonerSafeTypes.CanNotCopyType(realType, null)) return null;
 
 			var mb = TypeCreationHelper.GetModuleBuilder();
 			var dt = new DynamicMethod(
@@ -122,7 +122,18 @@ private static void GenerateProcessMethod(ILGenerator il, Type type, bool unboxS
 
 			foreach (var fieldInfo in fi)
 			{
-				if (!DeepClonerSafeTypes.IsTypeSafe(fieldInfo.FieldType, null))
+				if (DeepClonerSafeTypes.CanNotCopyType(fieldInfo.FieldType, null))
+				{
+					// for good consturctor we use direct field copy anyway
+					if (isGoodConstructor)
+					{
+						il.Emit(type.IsClass ? OpCodes.Ldloc : OpCodes.Ldloca_S, typeLocal);
+						il.Emit(OpCodes.Ldarg_0);
+						il.Emit(OpCodes.Ldfld, fieldInfo);
+						il.Emit(OpCodes.Stfld, fieldInfo);
+					}
+				}
+				else
 				{
 					il.Emit(type.IsClass ? OpCodes.Ldloc : OpCodes.Ldloca_S, typeLocal);
 					if (structLoc == null) il.Emit(OpCodes.Ldarg_0);
@@ -137,17 +148,6 @@ private static void GenerateProcessMethod(ILGenerator il, Type type, bool unboxS
 					il.Emit(OpCodes.Call, methodInfo);
 					il.Emit(OpCodes.Stfld, fieldInfo);
 				}
-				else
-				{
-					// for good consturctor we use direct field copy
-					if (isGoodConstructor)
-					{
-						il.Emit(type.IsClass ? OpCodes.Ldloc : OpCodes.Ldloca_S, typeLocal);
-						il.Emit(OpCodes.Ldarg_0);
-						il.Emit(OpCodes.Ldfld, fieldInfo);
-						il.Emit(OpCodes.Stfld, fieldInfo);
-					}
-				}
 			}
 
 			il.Emit(OpCodes.Ldloc, typeLocal);
@@ -200,7 +200,7 @@ private static void GenerateProcessArrayMethod(ILGenerator il, Type type)
 			il.Emit(OpCodes.Ldloc, typeLocal);
 			il.Emit(OpCodes.Call, typeof(DeepCloneState).GetMethod("AddKnownRef"));
 
-			if (DeepClonerSafeTypes.IsTypeSafe(elementType, null))
+			if (DeepClonerSafeTypes.CanNotCopyType(elementType, null))
 			{
 				// Array.Copy(from, to, from.Length);
 				il.Emit(OpCodes.Ldarg_0);

DeepCloner/Helpers/DeepClonerSafeTypes.cs

@@ -30,7 +30,7 @@ var x in
 						}) KnownTypes.TryAdd(x, true);
 		}
 
-		internal static bool IsTypeSafe(Type type, HashSet<Type> processingTypes)
+		internal static bool CanNotCopyType(Type type, HashSet<Type> processingTypes)
 		{
 			bool isSafe;
 			if (KnownTypes.TryGetValue(type, out isSafe)) return isSafe;
@@ -52,11 +52,18 @@ internal static bool IsTypeSafe(Type type, HashSet<Type> processingTypes)
 				return true;
 			}
 
-			if (type.FullName.StartsWith("System.Reflection.Emit") && type.Assembly == typeof(System.Reflection.Emit.OpCode).Assembly)
+			if (type.FullName.StartsWith("System.Reflection.") && type.Assembly == typeof(PropertyInfo).Assembly)
 			{
 				KnownTypes.TryAdd(type, true);
 				return true;
 			}
+
+			// catched by previous condition
+			/*if (type.FullName.StartsWith("System.Reflection.Emit") && type.Assembly == typeof(System.Reflection.Emit.OpCode).Assembly)
+			{
+				KnownTypes.TryAdd(type, true);
+				return true;
+			}*/
 
 			// this types are serious native resources, it is better not to clone it
 			if (type.IsSubclassOf(typeof(System.Runtime.ConstrainedExecution.CriticalFinalizerObject)))
@@ -122,7 +129,7 @@ internal static bool IsTypeSafe(Type type, HashSet<Type> processingTypes)
 					continue;
 
 				// not safe and not not safe. we need to go deeper
-				if (!IsTypeSafe(fieldType, processingTypes))
+				if (!CanNotCopyType(fieldType, processingTypes))
 				{
 					KnownTypes.TryAdd(type, false);
 					return false;
@@ -136,7 +143,7 @@ internal static bool IsTypeSafe(Type type, HashSet<Type> processingTypes)
 		/// <summary>
 		/// Classes with only safe fields are safe for ShallowClone (if they root objects for copying)
 		/// </summary>
-		internal static bool IsClassSafe(Type type)
+		internal static bool CanNotDeepCopyClass(Type type)
 		{
 			bool isSafe;
 			if (KnownClasses.TryGetValue(type, out isSafe)) return isSafe;
@@ -158,7 +165,7 @@ internal static bool IsClassSafe(Type type)
 			}
 			while (tp != null);
 
-			if (fi.Any(fieldInfo => !IsTypeSafe(fieldInfo.FieldType, null)))
+			if (fi.Any(fieldInfo => !CanNotCopyType(fieldInfo.FieldType, null)))
 			{
 				KnownClasses.TryAdd(type, false);
 				return false;

DeepCloner/project.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.1-*",
+  "version": "0.10.2-*",
   "buildOptions": {
     "debugType": "portable",
 	"optimize": true,