more tests

comparison with other libraries
fixed multiple copying of objects
fixed safe deep cloning of readonly fields (through some hacks)

Author: force-net

DeepCloner.Tests/ArraysSpec.cs

@@ -243,5 +243,31 @@ public void NonZero_Based_MultiDim_Array_Should_Be_Cloned()
 			Assert.That(clone.GetValue(1, 1), Is.EqualTo(1));
 			Assert.That(clone.GetValue(2, 2), Is.EqualTo(2));
 		}
+
+		[Test]
+		public void Array_As_Generic_Array_Should_Be_Cloned()
+		{
+			var arr = new[] { 1, 2, 3 };
+			var genArr = (Array)arr;
+			var clone = (int[])genArr.DeepClone();
+			Assert.That(clone.Length, Is.EqualTo(3));
+			Assert.That(clone[0], Is.EqualTo(1));
+			Assert.That(clone[1], Is.EqualTo(2));
+			Assert.That(clone[2], Is.EqualTo(3));
+		}
+
+		[Test]
+		public void Array_As_IEnumerable_Should_Be_Cloned()
+		{
+			var arr = new[] { 1, 2, 3 };
+			var genArr = (IEnumerable<int>)arr;
+			var clone = (int[])genArr.DeepClone();
+// ReSharper disable PossibleMultipleEnumeration
+			Assert.That(clone.Length, Is.EqualTo(3));
+			Assert.That(clone[0], Is.EqualTo(1));
+			Assert.That(clone[1], Is.EqualTo(2));
+			Assert.That(clone[2], Is.EqualTo(3));
+			// ReSharper restore PossibleMultipleEnumeration
+		}
 	}
 }

DeepCloner.Tests/DeepCloner.Tests.csproj

@@ -33,9 +33,24 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="CloneBehave">
+      <HintPath>..\packages\Clone.Behave.1.0.1\lib\CloneBehave.dll</HintPath>
+    </Reference>
     <Reference Include="CloneExtensions">
       <HintPath>..\packages\CloneExtensions.1.2\lib\portable-net40+sl50+win+wp80\CloneExtensions.dll</HintPath>
     </Reference>
+    <Reference Include="Fasterflect">
+      <HintPath>..\packages\fasterflect.2.1.3\lib\net40\Fasterflect.dll</HintPath>
+    </Reference>
+    <Reference Include="GeorgeCloney">
+      <HintPath>..\packages\GeorgeCloney.1.1.1.17\lib\net40\GeorgeCloney.dll</HintPath>
+    </Reference>
+    <Reference Include="NClone">
+      <HintPath>..\packages\NClone.1.1.1\lib\net40\NClone.dll</HintPath>
+    </Reference>
+    <Reference Include="Nuclex.Cloning">
+      <HintPath>..\packages\Nuclex.Cloning.1.0.0.0\lib\net40\Nuclex.Cloning.dll</HintPath>
+    </Reference>
     <Reference Include="nunit.framework">
       <HintPath>..\packages\NUnit.3.0.1\lib\net40\nunit.framework.dll</HintPath>
     </Reference>

DeepCloner.Tests/InheritanceSpec.cs

@@ -22,6 +22,9 @@ public class C1 : IDisposable
 			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
 			public int Y;
 
+			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
+			public object O; // make it not safe
+
 			public void Dispose()
 			{
 			}
@@ -43,6 +46,9 @@ public class C1P : IDisposable
 			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
 			public int Y { get; set; }
 
+			[SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1401:FieldsMustBePrivate", Justification = "Reviewed. Suppression is OK here.")]
+			public object O; // make it not safe
+
 			public void Dispose()
 			{
 			}

DeepCloner.Tests/PerformanceSpec.cs

@@ -4,10 +4,16 @@
 using System.Runtime.InteropServices;
 using System.Runtime.Serialization.Formatters.Binary;
 
+using CloneBehave;
+
 using CloneExtensions;
 
+using NClone;
+
 using NUnit.Framework;
 
+using Nuclex.Cloning;
+
 namespace Force.DeepCloner.Tests
 {
 	[TestFixture]
@@ -80,6 +86,11 @@ public void Test_Construct_Variants(bool isSafe)
 			for (var i = 0; i < 1000; i++) c1.GetClone();
 			for (var i = 0; i < 1000; i++) c1.DeepClone();
 			for (var i = 0; i < 1000; i++) CloneViaFormatter(c1);
+			for (var i = 0; i < 1000; i++) Clone.ObjectGraph(c1);
+			for (var i = 0; i < 1000; i++) new CloneEngine().Clone(c1);
+			// null reference
+			// for (var i = 0; i < 1000; i++) ReflectionCloner.DeepFieldClone(c1);
+			for (var i = 0; i < 1000; i++) GeorgeCloney.CloneExtension.DeepCloneWithoutSerialization(c1);
 
 			// test
 			var sw = new Stopwatch();
@@ -94,7 +105,24 @@ public void Test_Construct_Variants(bool isSafe)
 			sw.Restart();
 
 			for (var i = 0; i < 1000000; i++) c1.GetClone();
-			Console.WriteLine("Clone Extensions: " + sw.ElapsedMilliseconds);
+			Console.WriteLine("CloneExtensions: " + sw.ElapsedMilliseconds);
+			sw.Restart();
+
+			for (var i = 0; i < 1000000; i++) Clone.ObjectGraph(c1);
+			Console.WriteLine("NClone: " + sw.ElapsedMilliseconds);
+			sw.Restart();
+
+			for (var i = 0; i < 1000000; i++) new CloneEngine().Clone(c1);
+			Console.WriteLine("Clone.Behave: " + sw.ElapsedMilliseconds);
+			sw.Restart();
+
+			// null reference
+			/*for (var i = 0; i < 1000000; i++) ReflectionCloner.DeepFieldClone(c1);
+			Console.WriteLine("Nuclex.Cloning: " + sw.ElapsedMilliseconds);
+			sw.Restart();*/
+
+			for (var i = 0; i < 1000000; i++) GeorgeCloney.CloneExtension.DeepCloneWithoutSerialization(c1);
+			Console.WriteLine("GeorgeCloney: " + sw.ElapsedMilliseconds);
 			sw.Restart();
 
 			// inaccurate variant, but test should complete in reasonable time
@@ -179,6 +207,7 @@ public void Test_Shallow_Variants()
 			BaseTest.SwitchTo(true);
 			for (var i = 0; i < 1000; i++) c1.ShallowClone();
 			for (var i = 0; i < 1000; i++) c1.GetClone();
+			for (var i = 0; i < 1000; i++) ReflectionCloner.ShallowFieldClone(c1);
 
 			// test
 			var sw = new Stopwatch();
@@ -203,6 +232,10 @@ public void Test_Shallow_Variants()
 			Console.WriteLine("Shallow Safe: " + sw.ElapsedMilliseconds);
 			sw.Restart();
 
+			for (var i = 0; i < 1000000; i++) ReflectionCloner.ShallowFieldClone(c1);
+			Console.WriteLine("Nuclex.Cloning: " + sw.ElapsedMilliseconds);
+			sw.Restart();
+
 			for (var i = 0; i < 1000000; i++) c1.GetClone(CloningFlags.Shallow);
 			Console.WriteLine("Clone Extensions: " + sw.ElapsedMilliseconds);
 			sw.Restart();

DeepCloner.Tests/PermissionSpec.cs

@@ -1,8 +1,9 @@
 using System;
-using System.Collections.Generic;
 using System.Security;
 using System.Security.Permissions;
 
+using CloneExtensions;
+
 using NUnit.Framework;
 
 namespace Force.DeepCloner.Tests
@@ -25,32 +26,55 @@ public void EnsurePermission()
 			// assembly execute
 			permissions.AddPermission(new SecurityPermission(SecurityPermissionFlag.Execution));
 
-			permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.MemberAccess));
-			// permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess));
+			// permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.RestrictedMemberAccess | ReflectionPermissionFlag.MemberAccess));
+			permissions.AddPermission(new ReflectionPermission(ReflectionPermissionFlag.MemberAccess));
 
 			var test = AppDomain.CreateDomain("sandbox", null, setup, permissions);
 
 			var instance = (Executor)test.CreateInstanceFromAndUnwrap(this.GetType().Assembly.Location, typeof(Executor).FullName);
+			instance.CloneExtensionsClone();
 			instance.DoShallowClone();
 			instance.DoDeepClone();
 		}
 
 		public class Test
 		{
 			public int X { get; set; }
+
+			private readonly object y = new object();
+
+			private readonly UnsafeStructTest z;
+
+			public object GetY()
+			{
+				return y;
+			}
+		}
+
+		public struct UnsafeStructTest
+		{
+			public object Y { get; set; }
 		}
 
 		public class Executor : MarshalByRefObject
 		{
 			 public void DoDeepClone()
 			 {
-				 new List<int> { 1, 2, 3 }.DeepClone();
+				 var test = new Test();
+				 var clone = test.DeepClone();
+				 if (clone.GetY() == test.GetY())
+					 throw new Exception("Deep Clone fail");
 			 }
 
-			 public void DoShallowClone()
+			public void DoShallowClone()
 			 {
-				new List<int> { 1, 2, 3 }.ShallowClone();
+				 new Test().ShallowClone();
 			 }
+
+			public void CloneExtensionsClone()
+			{
+				new Test().GetClone();
+			}
 		}
 	}
 }

DeepCloner.Tests/SimpleObjectSpec.cs

@@ -186,5 +186,65 @@ public void String_In_Class_Should_Not_Be_Cloned()
 			Assert.That(cloned.X, Is.EqualTo(c.X));
 			Assert.True(ReferenceEquals(cloned.X, c.X));
 		}
+
+		public sealed class C6
+		{
+			public readonly int X = 1;
+
+			private readonly object y = new object();
+
+			private readonly StructWithObject z;
+
+			public object GetY()
+			{
+				return y;
+			}
+		}
+
+		public struct StructWithObject
+		{
+			public readonly object Z;
+		}
+
+		[Test]
+		public void Object_With_Readonly_Fields_Should_Be_Cloned()
+		{
+			var c = new C6();
+			var clone = c.DeepClone();
+			Assert.That(clone, Is.Not.EqualTo(c));
+			Assert.That(clone.X, Is.EqualTo(1));
+			Assert.That(clone.GetY(), Is.Not.Null);
+			Assert.That(clone.GetY(), Is.Not.EqualTo(c.GetY()));
+		}
+
+		public class VirtualClass1
+		{
+			public virtual int A { get; set; }
+
+			public virtual int B { get; set; }
+
+			// not safe
+			public object X { get; set; }
+		}
+
+		public class VirtualClass2 : VirtualClass1
+		{
+			public override int B { get; set; }
+		}
+
+		[Test(Description = "Nothings special, just for checking")]
+		public void Class_With_Virtual_Methods_Should_Be_Cloned()
+		{
+			var v2 = new VirtualClass2();
+			v2.A = 1;
+			v2.B = 2;
+			var v1 = v2 as VirtualClass1;
+			v1.A = 3;
+			var clone = v1.DeepClone() as VirtualClass2;
+			v2.B = 0;
+			v2.A = 0;
+			Assert.That(clone.B, Is.EqualTo(2));
+			Assert.That(clone.A, Is.EqualTo(3));
+		}
 	}
 }

DeepCloner.Tests/packages.config

@@ -1,5 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="Clone.Behave" version="1.0.1" targetFramework="net40" />
   <package id="CloneExtensions" version="1.2" targetFramework="net40" />
+  <package id="fasterflect" version="2.1.3" targetFramework="net40" />
+  <package id="GeorgeCloney" version="1.1.1.17" targetFramework="net40" />
+  <package id="NClone" version="1.1.1" targetFramework="net40" />
+  <package id="Nuclex.Cloning" version="1.0.0.0" targetFramework="net40" />
   <package id="NUnit" version="3.0.1" targetFramework="net40" />
 </packages>

DeepCloner.nuspec

@@ -12,10 +12,9 @@
     <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 an issue with handling references to arrays
-Added support for multidimensional arrays and non-zero-based arrays
-Added fallback for non-fulltrust code through expressions
-Due build issue, release 0.9.0 was invalid, this is fixed variant
+Seriously improved cloning of simple object (constructor analyzing + reference counting)
+Fixed small issue with possible multiple copying of same fields in object
+Safe variant now correctly clones readonly fields
     </releaseNotes>
     <copyright>Copyright by Force 2016</copyright>
     <tags>.NET shallow deep clone DeepClone fast</tags>

DeepCloner/Helpers/DeepClonerExprGenerator.cs

@@ -12,6 +12,25 @@ internal static object GenerateClonerInternal(Type realType, bool asObject)
 			return GenerateProcessMethod(realType, asObject && realType.IsValueType);
 		}
 
+		// slow, but hardcore method to set readonly field
+		internal static void ForceSetField(FieldInfo field, object obj, object value)
+		{
+			var fieldInfo = field.GetType().GetField("m_fieldAttributes", BindingFlags.NonPublic | BindingFlags.Instance);
+
+			// TODO: think about it
+			// nothing to do :( we should a throw an exception, but it is no good for user
+			if (fieldInfo == null)
+				return;
+			var ov = fieldInfo.GetValue(field);
+			if (!(ov is FieldAttributes))
+				return;
+			var v = (FieldAttributes)ov;
+
+			fieldInfo.SetValue(field, v & ~FieldAttributes.InitOnly);
+			field.SetValue(obj, value);
+			fieldInfo.SetValue(field, v);
+		}
+
 		private static object GenerateProcessMethod(Type type, bool unboxStruct)
 		{
 			if (type.IsArray)
@@ -67,7 +86,7 @@ private static object GenerateProcessMethod(Type type, bool unboxStruct)
 			{
 				// don't do anything with this dark magic!
 				if (tp == typeof(ContextBoundObject)) break;
-				fi.AddRange(tp.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
+				fi.AddRange(tp.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly));
 				tp = tp.BaseType;
 			}
 			while (tp != null);
@@ -89,10 +108,13 @@ private static object GenerateProcessMethod(Type type, bool unboxStruct)
 						call = Expression.Convert(call, fieldInfo.FieldType);
 
 					// should handle specially
+					// todo: think about optimization, but it rare case
 					if (fieldInfo.IsInitOnly)
 					{
-						var setMethod = fieldInfo.GetType().GetMethod("SetValue", new[] { typeof(object), typeof(object) });
-						expressionList.Add(Expression.Call(Expression.Constant(fieldInfo), setMethod, toLocal, call));
+						// var setMethod = fieldInfo.GetType().GetMethod("SetValue", new[] { typeof(object), typeof(object) });
+						// expressionList.Add(Expression.Call(Expression.Constant(fieldInfo), setMethod, toLocal, call));
+						var setMethod = typeof(DeepClonerExprGenerator).GetMethod("ForceSetField", BindingFlags.NonPublic | BindingFlags.Static);
+						expressionList.Add(Expression.Call(setMethod, Expression.Constant(fieldInfo), Expression.Convert(toLocal, typeof(object)), Expression.Convert(call, typeof(object))));
 					}
 					else
 					{

DeepCloner/Helpers/DeepClonerMsilGenerator.cs

@@ -102,7 +102,7 @@ private static void GenerateProcessMethod(ILGenerator il, Type type, bool unboxS
 			{
 				// don't do anything with this dark magic!
 				if (tp == typeof(ContextBoundObject)) break;
-				fi.AddRange(tp.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
+				fi.AddRange(tp.GetFields(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.DeclaredOnly));
 				tp = tp.BaseType;
 			}
 			while (tp != null);