Expression tree cloner can now also create shallow field based clones

git-svn-id: file:///srv/devel/repo-conversion/nusu@241 d2e56fa2-650e-0410-a79f-9358c0239efd

Nuclex.Support (net-4.0).csproj

@@ -63,6 +63,12 @@
     <Compile Include="Source\Cloning\CloneFactoryTest.cs" />
     <Compile Include="Source\Cloning\CloningParameters.cs" />
     <Compile Include="Source\Cloning\ExpressionTreeCloner.cs" />
+    <Compile Include="Source\Cloning\ExpressionTreeCloner.FieldBased.cs">
+      <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Source\Cloning\ExpressionTreeCloner.PropertyBased.cs">
+      <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
+    </Compile>
     <Compile Include="Source\Cloning\ExpressionTreeCloner.Test.cs">
       <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
     </Compile>

Nuclex.Support (xna-4.0-phone7).csproj

@@ -94,6 +94,12 @@
     <Compile Include="Source\Cloning\CloneFactoryTest.cs" />
     <Compile Include="Source\Cloning\CloningParameters.cs" />
     <Compile Include="Source\Cloning\ExpressionTreeCloner.cs" />
+    <Compile Include="Source\Cloning\ExpressionTreeCloner.FieldBased.cs">
+      <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Source\Cloning\ExpressionTreeCloner.PropertyBased.cs">
+      <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
+    </Compile>
     <Compile Include="Source\Cloning\ExpressionTreeCloner.Test.cs">
       <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
     </Compile>

Nuclex.Support (xna-4.0-xbox360).csproj

@@ -105,6 +105,12 @@
     <Compile Include="Source\Cloning\CloneFactoryTest.cs" />
     <Compile Include="Source\Cloning\CloningParameters.cs" />
     <Compile Include="Source\Cloning\ExpressionTreeCloner.cs" />
+    <Compile Include="Source\Cloning\ExpressionTreeCloner.FieldBased.cs">
+      <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Source\Cloning\ExpressionTreeCloner.PropertyBased.cs">
+      <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
+    </Compile>
     <Compile Include="Source\Cloning\ExpressionTreeCloner.Test.cs">
       <DependentUpon>ExpressionTreeCloner.cs</DependentUpon>
     </Compile>

Source/Cloning/CloneFactoryTest.cs

@@ -123,6 +123,8 @@ namespace Nuclex.Support.Cloning {
       HierarchicalReferenceType original, HierarchicalReferenceType clone,
       bool isDeepClone, bool isPropertyBasedClone
     ) {
+      Assert.AreNotSame(original, clone);
+
       if(isPropertyBasedClone) {
         Assert.AreEqual(0, clone.TestField);
         Assert.AreEqual(0, clone.ValueTypeField.TestField);

Source/Cloning/ExpressionTreeCloner.FieldBased.cs

@@ -0,0 +1,579 @@
+#region CPL License
+/*
+Nuclex Framework
+Copyright (C) 2002-2010 Nuclex Development Labs
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the IBM Common Public License as
+published by the IBM Corporation; either version 1.0 of the
+License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+IBM Common Public License for more details.
+
+You should have received a copy of the IBM Common Public
+License along with this library
+*/
+#endregion
+
+#if !(XBOX360 || WINDOWS_PHONE)
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Nuclex.Support.Cloning {
+
+	partial class ExpressionTreeCloner : ICloneFactory {
+
+		/// <summary>Compiles a method that creates a deep clone of an object</summary>
+		/// <param name="clonedType">Type for which a clone method will be created</param>
+		/// <returns>A method that clones an object of the provided type</returns>
+		/// <remarks>
+		///   <para>
+		///     The 'null' check is supposed to take place before running the cloner. This
+		///     avoids having redundant 'null' checks on nested types - first before calling
+		///     GetType() on the field to be cloned and second when runner the matching
+		///     cloner for the field.
+		///   </para>
+		///   <para>
+		///     This design also enables the cloning of nested value types (which can never
+		///     be null) without any null check whatsoever.
+		///   </para>
+		/// </remarks>
+		private static Func<object, object> createDeepFieldBasedCloner(Type clonedType) {
+			ParameterExpression original = Expression.Parameter(typeof(object), "original");
+
+			var transferExpressions = new List<Expression>();
+			var variables = new List<ParameterExpression>();
+
+			if(clonedType.IsPrimitive || (clonedType == typeof(string))) {
+				// Primitives and strings are copied on direct assignment
+				transferExpressions.Add(original);
+			} else if(clonedType.IsArray) {
+				// Arrays need to be cloned element-by-element
+				Type elementType = clonedType.GetElementType();
+
+				if(elementType.IsPrimitive || (elementType == typeof(string))) {
+					// For primitive arrays, the Array.Clone() method is sufficient
+					transferExpressions.Add(
+						generatePrimitiveArrayTransferExpressions(
+							clonedType, original, variables, transferExpressions
+						)
+					);
+				} else {
+					// To access the fields of the original type, we need it to be of the actual
+					// type instead of an object, so perform a downcast
+					ParameterExpression typedOriginal = Expression.Variable(clonedType);
+					variables.Add(typedOriginal);
+					transferExpressions.Add(
+						Expression.Assign(typedOriginal, Expression.Convert(original, clonedType))
+					);
+
+					// Arrays of complex types require manual cloning
+					transferExpressions.Add(
+						generateComplexArrayTransferExpressions(
+							clonedType, typedOriginal, variables, transferExpressions
+						)
+					);
+				}
+			} else {
+				// We need a variable to hold the clone because due to the assignments it
+				// won't be last in the block when we're finished
+				ParameterExpression clone = Expression.Variable(clonedType);
+				variables.Add(clone);
+
+				// Give it a new instance of the type being cloned
+				transferExpressions.Add(Expression.Assign(clone, Expression.New(clonedType)));
+
+				// To access the fields of the original type, we need it to be of the actual
+				// type instead of an object, so perform a downcast
+				ParameterExpression typedOriginal = Expression.Variable(clonedType);
+				variables.Add(typedOriginal);
+				transferExpressions.Add(
+					Expression.Assign(typedOriginal, Expression.Convert(original, clonedType))
+				);
+
+				// Generate the expressions required to transfer the type field by field
+				generateComplexTypeTransferExpressions(
+					clonedType, typedOriginal, clone, variables, transferExpressions
+				);
+
+				// Make sure the clone is the last thing in the block to set the return value
+				transferExpressions.Add(clone);
+			}
+
+			// Turn all transfer expressions into a single block if necessary
+			Expression resultExpression;
+			if((transferExpressions.Count == 1) && (variables.Count == 0)) {
+				resultExpression = transferExpressions[0];
+			} else {
+				resultExpression = Expression.Block(variables, transferExpressions);
+			}
+
+			// Value types require manual boxing
+			if(clonedType.IsValueType) {
+				resultExpression = Expression.Convert(resultExpression, typeof(object));
+			}
+
+			return Expression.Lambda<Func<object, object>>(resultExpression, original).Compile();
+		}
+
+		/// <summary>Compiles a method that creates a shallow clone of an object</summary>
+		/// <param name="clonedType">Type for which a clone method will be created</param>
+		/// <returns>A method that clones an object of the provided type</returns>
+		private static Func<object, object> createShallowFieldBasedCloner(Type clonedType) {
+			ParameterExpression original = Expression.Parameter(typeof(object), "original");
+
+			var transferExpressions = new List<Expression>();
+			var variables = new List<ParameterExpression>();
+
+			if(clonedType.IsPrimitive || clonedType.IsValueType || (clonedType == typeof(string))) {
+				// Primitives and strings are copied on direct assignment
+				transferExpressions.Add(original);
+			} else if(clonedType.IsArray) {
+				transferExpressions.Add(
+					generatePrimitiveArrayTransferExpressions(
+						clonedType, original, variables, transferExpressions
+					)
+				);
+			} else {
+				// We need a variable to hold the clone because due to the assignments it
+				// won't be last in the block when we're finished
+				ParameterExpression clone = Expression.Variable(clonedType);
+				variables.Add(clone);
+
+				// To access the fields of the original type, we need it to be of the actual
+				// type instead of an object, so perform a downcast
+				ParameterExpression typedOriginal = Expression.Variable(clonedType);
+				variables.Add(typedOriginal);
+				transferExpressions.Add(
+					Expression.Assign(typedOriginal, Expression.Convert(original, clonedType))
+				);
+
+				// Give it a new instance of the type being cloned
+				transferExpressions.Add(Expression.Assign(clone, Expression.New(clonedType)));
+
+				// Enumerate all of the type's fields and generate transfer expressions for each
+				FieldInfo[] fieldInfos = clonedType.GetFields(
+					BindingFlags.Public | BindingFlags.NonPublic |
+					BindingFlags.Instance | BindingFlags.FlattenHierarchy
+				);
+				for(int index = 0; index < fieldInfos.Length; ++index) {
+					FieldInfo fieldInfo = fieldInfos[index];
+
+					transferExpressions.Add(
+						Expression.Assign(
+							Expression.Field(clone, fieldInfo),
+							Expression.Field(typedOriginal, fieldInfo)
+						)
+					);
+				}
+
+				// Make sure the clone is the last thing in the block to set the return value
+				transferExpressions.Add(clone);
+			}
+
+			// Turn all transfer expressions into a single block if necessary
+			Expression resultExpression;
+			if((transferExpressions.Count == 1) && (variables.Count == 0)) {
+				resultExpression = transferExpressions[0];
+			} else {
+				resultExpression = Expression.Block(variables, transferExpressions);
+			}
+
+			// Value types require manual boxing
+			if(clonedType.IsValueType) {
+				resultExpression = Expression.Convert(resultExpression, typeof(object));
+			}
+
+			return Expression.Lambda<Func<object, object>>(resultExpression, original).Compile();
+		}
+
+		/// <summary>
+		///   Generates state transfer expressions to copy an array of primitive types
+		/// </summary>
+		/// <param name="clonedType">Type of array that will be cloned</param>
+		/// <param name="original">Variable expression for the original array</param>
+		/// <param name="variables">Receives variables used by the transfer expressions</param>
+		/// <param name="transferExpressions">Receives the generated transfer expressions</param>
+		/// <returns>The variable holding the cloned array</returns>
+		private static Expression generatePrimitiveArrayTransferExpressions(
+			Type clonedType,
+			Expression original,
+			ICollection<ParameterExpression> variables,
+			ICollection<Expression> transferExpressions
+		) {
+			MethodInfo arrayCloneMethodInfo = typeof(Array).GetMethod("Clone");
+			return Expression.Convert(
+				Expression.Call(
+					Expression.Convert(original, typeof(Array)), arrayCloneMethodInfo
+				),
+				clonedType
+			);
+		}
+
+		/// <summary>
+		///   Generates state transfer expressions to copy an array of complex types
+		/// </summary>
+		/// <param name="clonedType">Type of array that will be cloned</param>
+		/// <param name="original">Variable expression for the original array</param>
+		/// <param name="variables">Receives variables used by the transfer expressions</param>
+		/// <param name="transferExpressions">Receives the generated transfer expressions</param>
+		/// <returns>The variable holding the cloned array</returns>
+		private static ParameterExpression generateComplexArrayTransferExpressions(
+			Type clonedType,
+			Expression original,
+			IList<ParameterExpression> variables,
+			ICollection<Expression> transferExpressions
+		) {
+			// We need a temporary variable in order to transfer the elements of the array
+			ParameterExpression clone = Expression.Variable(clonedType);
+			variables.Add(clone);
+
+			int dimensionCount = clonedType.GetArrayRank();
+			int baseVariableIndex = variables.Count;
+			Type elementType = clonedType.GetElementType();
+
+			var lengths = new List<ParameterExpression>();
+			var indexes = new List<ParameterExpression>();
+			var labels = new List<LabelTarget>();
+
+			// Retrieve the length of each of the array's dimensions
+			MethodInfo arrayGetLengthMethodInfo = typeof(Array).GetMethod("GetLength");
+			for(int index = 0; index < dimensionCount; ++index) {
+
+				// Obtain the length of the array in the current dimension
+				lengths.Add(Expression.Variable(typeof(int)));
+				variables.Add(lengths[index]);
+				transferExpressions.Add(
+					Expression.Assign(
+						lengths[index],
+						Expression.Call(
+							original, arrayGetLengthMethodInfo, Expression.Constant(index)
+						)
+					)
+				);
+
+				// Set up a variable to index the array in this dimension
+				indexes.Add(Expression.Variable(typeof(int)));
+				variables.Add(indexes[index]);
+
+				// Also set up a label than can be used to break out of the dimension's
+				// transfer loop
+				labels.Add(Expression.Label());
+
+			}
+
+			// Create a new (empty) array with the same dimensions and lengths as the original
+			transferExpressions.Add(
+				Expression.Assign(clone, Expression.NewArrayBounds(elementType, lengths))
+			);
+
+			// Initialize the indexer of the outer loop (indexers are initialized one up
+			// in the loops (ie. before the loop using it begins), so we have to set this
+			// one outside of the loop building code.
+			transferExpressions.Add(
+				Expression.Assign(indexes[0], Expression.Constant(0))
+			);
+
+			// We use a temporary variable to store the element
+			ParameterExpression element = Expression.Variable(elementType);
+			variables.Add(element);
+
+			// Build the nested loops (one for each dimension) from the inside out
+			Expression innerLoop = null;
+			for(int index = dimensionCount - 1; index >= 0; --index) {
+				var loopVariables = new List<ParameterExpression>();
+				var loopExpressions = new List<Expression>();
+
+				// If we reached the end of the current array dimension, break the loop
+				loopExpressions.Add(
+					Expression.IfThen(
+						Expression.GreaterThanOrEqual(indexes[index], lengths[index]),
+						Expression.Break(labels[index])
+					)
+				);
+
+				if(innerLoop == null) {
+					// The innermost loop clones an actual array element
+
+					if(elementType.IsPrimitive || (elementType == typeof(string))) {
+						// Primitive array elements can be copied by simple assignment. This case
+						// should not occur since Array.Clone() should be used instead.
+						loopExpressions.Add(
+							Expression.Assign(
+								Expression.ArrayAccess(clone, indexes),
+								Expression.ArrayAccess(original, indexes)
+							)
+						);
+					} else if(elementType.IsValueType) {
+						// Arrays of complex value types can be transferred by assigning all fields
+						// of the source array element to the destination array element (cloning
+						// any nested reference types appropriately)
+						generateComplexTypeTransferExpressions(
+							elementType,
+							Expression.ArrayAccess(original, indexes),
+							Expression.ArrayAccess(clone, indexes),
+							variables,
+							loopExpressions
+						);
+
+					} else {
+						// Arrays of reference types need to be cloned by creating a new instance
+						// of the reference type and then transferring the fields over
+						ParameterExpression originalElement = Expression.Variable(elementType);
+						loopVariables.Add(originalElement);
+
+						loopExpressions.Add(
+							Expression.Assign(originalElement, Expression.ArrayAccess(original, indexes))
+						);
+
+						var nestedVariables = new List<ParameterExpression>();
+						var nestedTransferExpressions = new List<Expression>();
+
+						// A nested array should be cloned by directly creating a new array (not invoking
+						// a cloner) since you cannot derive from an array
+						if(elementType.IsArray) {
+							Expression clonedElement;
+
+							Type nestedElementType = elementType.GetElementType();
+							if(nestedElementType.IsPrimitive || (nestedElementType == typeof(string))) {
+								clonedElement = generatePrimitiveArrayTransferExpressions(
+									elementType, originalElement, nestedVariables, nestedTransferExpressions
+								);
+							} else {
+								clonedElement = generateComplexArrayTransferExpressions(
+									elementType, originalElement, nestedVariables, nestedTransferExpressions
+								);
+							}
+							nestedTransferExpressions.Add(
+								Expression.Assign(Expression.ArrayAccess(clone, indexes), clonedElement)
+							);
+						} else {
+							// Complex types are cloned by checking their actual, concrete type (fields
+							// may be typed to an interface or base class) and requesting a cloner for that
+							// type during runtime
+							MethodInfo getOrCreateClonerMethodInfo = typeof(ExpressionTreeCloner).GetMethod(
+								"getOrCreateDeepFieldBasedCloner",
+								BindingFlags.NonPublic | BindingFlags.Static
+							);
+							MethodInfo getTypeMethodInfo = typeof(object).GetMethod("GetType");
+							MethodInfo invokeMethodInfo = typeof(Func<object, object>).GetMethod("Invoke");
+
+							// Generate expressions to do this:
+							//   clone.SomeField = getOrCreateDeepFieldBasedCloner(
+							//     original.SomeField.GetType()
+							//   ).Invoke(original.SomeField);
+							nestedTransferExpressions.Add(
+								Expression.Assign(
+									Expression.ArrayAccess(clone, indexes),
+									Expression.Convert(
+										Expression.Call(
+											Expression.Call(
+												getOrCreateClonerMethodInfo,
+												Expression.Call(originalElement, getTypeMethodInfo)
+											),
+											invokeMethodInfo,
+											originalElement
+										),
+										elementType
+									)
+								)
+							);
+						}
+
+						// Whether array-in-array of reference-type-in-array, we need a null check before
+						// doing anything to avoid NullReferenceExceptions for unset members
+						loopExpressions.Add(
+							Expression.IfThen(
+								Expression.NotEqual(originalElement, Expression.Constant(null)),
+								Expression.Block(
+									nestedVariables,
+									nestedTransferExpressions
+								)
+							)
+						);
+					}
+
+				} else {
+					// Outer loops of any level just reset the inner loop's indexer and execute
+					// the inner loop
+					loopExpressions.Add(
+						Expression.Assign(indexes[index + 1], Expression.Constant(0))
+					);
+					loopExpressions.Add(innerLoop);
+				}
+
+				// Each time we executed the loop instructions, increment the indexer
+				loopExpressions.Add(Expression.PreIncrementAssign(indexes[index]));
+
+				// Build the loop using the expressions recorded above
+				innerLoop = Expression.Loop(
+					Expression.Block(loopVariables, loopExpressions),
+					labels[index]
+				);
+			}
+
+			// After the loop builder has finished, the innerLoop variable contains
+			// the entire hierarchy of nested loops, so add this to the clone expressions.
+			transferExpressions.Add(innerLoop);
+
+			return clone;
+		}
+
+		/// <summary>Generates state transfer expressions to copy a complex type</summary>
+		/// <param name="clonedType">Complex type that will be cloned</param>
+		/// <param name="original">Variable expression for the original instance</param>
+		/// <param name="clone">Variable expression for the cloned instance</param>
+		/// <param name="variables">Receives variables used by the transfer expressions</param>
+		/// <param name="transferExpressions">Receives the generated transfer expressions</param>
+		private static void generateComplexTypeTransferExpressions(
+			Type clonedType, // Actual, concrete type (not declared type)
+			Expression original, // Expected to be an object
+			Expression clone,	// As actual, concrete type
+			IList<ParameterExpression> variables,
+			ICollection<Expression> transferExpressions
+		) {
+			// Enumerate all of the type's fields and generate transfer expressions for each
+			FieldInfo[] fieldInfos = clonedType.GetFields(
+				BindingFlags.Public | BindingFlags.NonPublic |
+				BindingFlags.Instance | BindingFlags.FlattenHierarchy
+			);
+			for(int index = 0; index < fieldInfos.Length; ++index) {
+				FieldInfo fieldInfo = fieldInfos[index];
+				Type fieldType = fieldInfo.FieldType;
+
+				if(fieldType.IsPrimitive || (fieldType == typeof(string))) {
+					// Primitive types and strings can be transferred by simple assignment
+					transferExpressions.Add(
+						Expression.Assign(
+							Expression.Field(clone, fieldInfo),
+							Expression.Field(original, fieldInfo)
+						)
+					);
+				} else if(fieldType.IsValueType) {
+					// A nested value type is part of the parent and will have its fields directly
+					// assigned without boxing, new instance creation or anything like that.
+					generateComplexTypeTransferExpressions(
+						fieldType,
+						Expression.Field(original, fieldInfo),
+						Expression.Field(clone, fieldInfo),
+						variables,
+						transferExpressions
+					);
+				} else {
+					generateReferenceTypeTransferExpressions(
+						original, clone, transferExpressions, fieldInfo, fieldType
+					);
+				}
+			}
+		}
+
+		/// <summary>
+		///   Generates the expressions to transfer a reference type (array or class)
+		/// </summary>
+		/// <param name="original">Original value that will be cloned</param>
+		/// <param name="clone">Variable that will receive the cloned value</param>
+		/// <param name="transferExpressions">
+		///   Receives the expression generated to transfer the values
+		/// </param>
+		/// <param name="fieldInfo">Reflection informations about the field being cloned</param>
+		/// <param name="fieldType">Type of the field being cloned</param>
+		private static void generateReferenceTypeTransferExpressions(
+			Expression original,
+			Expression clone,
+			ICollection<Expression> transferExpressions,
+			FieldInfo fieldInfo,
+			Type fieldType
+		) {
+			// Reference types and arrays require special care because they can be null,
+			// so gather the transfer expressions in a separate block for the null check
+			var fieldTransferExpressions = new List<Expression>();
+			var fieldVariables = new List<ParameterExpression>();
+
+			if(fieldType.IsArray) {
+				// Arrays need to be cloned element-by-element
+				Expression fieldClone;
+
+				Type elementType = fieldType.GetElementType();
+				if(elementType.IsPrimitive || (elementType == typeof(string))) {
+					// For primitive arrays, the Array.Clone() method is sufficient
+					fieldClone = generatePrimitiveArrayTransferExpressions(
+						fieldType,
+						Expression.Field(original, fieldInfo),
+						fieldVariables,
+						fieldTransferExpressions
+					);
+				} else {
+					// Arrays of complex types require manual cloning
+					fieldClone = generateComplexArrayTransferExpressions(
+						fieldType,
+						Expression.Field(original, fieldInfo),
+						fieldVariables,
+						fieldTransferExpressions
+					);
+				}
+
+				// Add the assignment to the transfer expressions. The array transfer expression
+				// generator will either have set up a temporary variable to hold the array or
+				// returned the conversion expression straight away
+				fieldTransferExpressions.Add(
+					Expression.Assign(Expression.Field(clone, fieldInfo), fieldClone)
+				);
+			} else {
+				// Complex types are cloned by checking their actual, concrete type (fields
+				// may be typed to an interface or base class) and requesting a cloner for that
+				// type during runtime
+				MethodInfo getOrCreateClonerMethodInfo = typeof(ExpressionTreeCloner).GetMethod(
+					"getOrCreateDeepFieldBasedCloner",
+					BindingFlags.NonPublic | BindingFlags.Static
+				);
+				MethodInfo getTypeMethodInfo = typeof(object).GetMethod("GetType");
+				MethodInfo invokeMethodInfo = typeof(Func<object, object>).GetMethod("Invoke");
+
+				// Generate expressions to do this:
+				//   clone.SomeField = getOrCreateDeepFieldBasedCloner(
+				//     original.SomeField.GetType()
+				//   ).Invoke(original.SomeField);
+				fieldTransferExpressions.Add(
+					Expression.Assign(
+						Expression.Field(clone, fieldInfo),
+						Expression.Convert(
+							Expression.Call(
+								Expression.Call(
+									getOrCreateClonerMethodInfo,
+									Expression.Call(
+										Expression.Field(original, fieldInfo), getTypeMethodInfo
+									)
+								),
+								invokeMethodInfo,
+								Expression.Field(original, fieldInfo)
+							),
+							fieldType
+						)
+					)
+				);
+			}
+
+			// Wrap up the generated array or complex reference type transfer expressions
+			// in a null check so the field is skipped if it is not holding an instance.
+			transferExpressions.Add(
+				Expression.IfThen(
+					Expression.NotEqual(
+						Expression.Field(original, fieldInfo), Expression.Constant(null)
+					),
+					Expression.Block(fieldVariables, fieldTransferExpressions)
+				)
+			);
+		}
+
+	}
+
+} // namespace Nuclex.Support.Cloning
+
+#endif // !(XBOX360 || WINDOWS_PHONE)

Source/Cloning/ExpressionTreeCloner.PropertyBased.cs

@@ -0,0 +1,39 @@
+#region CPL License
+/*
+Nuclex Framework
+Copyright (C) 2002-2010 Nuclex Development Labs
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the IBM Common Public License as
+published by the IBM Corporation; either version 1.0 of the
+License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+IBM Common Public License for more details.
+
+You should have received a copy of the IBM Common Public
+License along with this library
+*/
+#endregion
+
+#if !(XBOX360 || WINDOWS_PHONE)
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace Nuclex.Support.Cloning {
+
+  partial class ExpressionTreeCloner : ICloneFactory {
+
+    // Not implement yet...
+
+  }
+
+} // namespace Nuclex.Support.Cloning
+
+#endif // !(XBOX360 || WINDOWS_PHONE)

Source/Cloning/ExpressionTreeCloner.Test.cs

@@ -65,7 +65,6 @@ namespace Nuclex.Support.Cloning {
 			CollectionAssert.AreEqual(original, clone);
 		}
 
-#if false
 		/// <summary>Verifies that shallow clones of arrays can be made</summary>
 		[Test]
 		public void ShallowClonesOfArraysCanBeMade() {
@@ -76,7 +75,6 @@ namespace Nuclex.Support.Cloning {
 
 			Assert.AreSame(original[0], clone[0]);
 		}
-#endif
 
 		/// <summary>Verifies that deep clones of arrays can be made</summary>
 		[Test]
@@ -112,7 +110,6 @@ namespace Nuclex.Support.Cloning {
 			Assert.AreEqual("one", clone[1]);
 		}
 
-#if false
 		/// <summary>
 		///   Verifies that a field-based shallow clone of a value type can be performed
 		/// </summary>
@@ -132,7 +129,7 @@ namespace Nuclex.Support.Cloning {
 			HierarchicalReferenceType clone = this.cloneFactory.ShallowClone(original, false);
 			VerifyClone(original, clone, isDeepClone: false, isPropertyBasedClone: false);
 		}
-#endif
+
 		/// <summary>
 		///   Verifies that a field-based deep clone of a value type can be performed
 		/// </summary>

Source/Cloning/ExpressionTreeCloner.cs

@@ -28,25 +28,16 @@ using System.Reflection;
 
 namespace Nuclex.Support.Cloning {
 
-  /// <summary>An action that takes its arguments as references to a structure</summary>
-  /// <typeparam name="TFirst">Type of the first argument to the method</typeparam>
-  /// <typeparam name="TSecond">Type of the second argument to the method</typeparam>
-  /// <param name="first">First argument to the method</param>
-  /// <param name="second">Second argument to the method</param>
-  public delegate void ReferenceAction<TFirst, TSecond>(ref TFirst first, ref TSecond second)
-    where TFirst : struct
-    where TSecond : struct;
-
   /// <summary>
   ///   Cloning factory which uses expression trees to improve performance when cloning
   ///   is a high-frequency action.
   /// </summary>
-  public class ExpressionTreeCloner : ICloneFactory {
+  public partial class ExpressionTreeCloner : ICloneFactory {
 
     /// <summary>Initializes the static members of the expression tree cloner</summary>
     static ExpressionTreeCloner() {
-      shallowCloners = new ConcurrentDictionary<Type, Func<object, object>>();
+      shallowFieldBasedCloners = new ConcurrentDictionary<Type, Func<object, object>>();
-      deepCloners = new ConcurrentDictionary<Type, Func<object, object>>();
+      deepFieldBasedCloners = new ConcurrentDictionary<Type, Func<object, object>>();
     }
 
     /// <summary>
@@ -87,7 +78,17 @@ namespace Nuclex.Support.Cloning {
     public static TCloned ShallowClone<TCloned>(
       TCloned objectToClone, bool usePropertyBasedClone
     ) {
+      object objectToCloneAsObject = objectToClone;
+      if(objectToCloneAsObject == null) {
+        return default(TCloned);
+      }
+
+      if(usePropertyBasedClone) {
         throw new NotImplementedException("Not implemented yet");
+      } else {
+        Func<object, object> cloner = getOrCreateShallowFieldBasedCloner(typeof(TCloned));
+        return (TCloned)cloner(objectToCloneAsObject);
+      }
     }
 
     /// <summary>
@@ -121,478 +122,6 @@ namespace Nuclex.Support.Cloning {
       return ExpressionTreeCloner.ShallowClone<TCloned>(objectToClone, usePropertyBasedClone);
     }
 
-    /// <summary>
-    ///   Retrieves the existing clone method for the specified type or compiles one if
-    ///   none exists for the type yet
-    /// </summary>
-    /// <param name="clonedType">Type for which a clone method will be retrieved</param>
-    /// <returns>The clone method for the specified type</returns>
-    private static Func<object, object> getOrCreateDeepFieldBasedCloner(Type clonedType) {
-      Func<object, object> cloner;
-
-      if(!deepCloners.TryGetValue(clonedType, out cloner)) {
-        cloner = createDeepFieldBasedCloner(clonedType);
-        deepCloners.TryAdd(clonedType, cloner);
-      }
-
-      return cloner;
-    }
-
-    /// <summary>
-    ///   Generates state transfer expressions to copy an array of primitive types
-    /// </summary>
-    /// <param name="clonedType">Type of array that will be cloned</param>
-    /// <param name="original">Variable expression for the original array</param>
-    /// <param name="variables">Receives variables used by the transfer expressions</param>
-    /// <param name="transferExpressions">Receives the generated transfer expressions</param>
-    /// <returns>The variable holding the cloned array</returns>
-    private static Expression generatePrimitiveArrayTransferExpressions(
-      Type clonedType,
-      Expression original,
-      ICollection<ParameterExpression> variables,
-      ICollection<Expression> transferExpressions
-    ) {
-      MethodInfo arrayCloneMethodInfo = typeof(Array).GetMethod("Clone");
-      return Expression.Convert(
-        Expression.Call(
-          Expression.Convert(original, typeof(Array)), arrayCloneMethodInfo
-        ),
-        clonedType
-      );
-    }
-
-    /// <summary>
-    ///   Generates state transfer expressions to copy an array of complex types
-    /// </summary>
-    /// <param name="clonedType">Type of array that will be cloned</param>
-    /// <param name="original">Variable expression for the original array</param>
-    /// <param name="variables">Receives variables used by the transfer expressions</param>
-    /// <param name="transferExpressions">Receives the generated transfer expressions</param>
-    /// <returns>The variable holding the cloned array</returns>
-    private static ParameterExpression generateComplexArrayTransferExpressions(
-      Type clonedType,
-      Expression original,
-      IList<ParameterExpression> variables,
-      ICollection<Expression> transferExpressions
-    ) {
-      // We need a temporary variable in order to transfer the elements of the array
-      ParameterExpression clone = Expression.Variable(clonedType);
-      variables.Add(clone);
-
-      int dimensionCount = clonedType.GetArrayRank();
-      int baseVariableIndex = variables.Count;
-      Type elementType = clonedType.GetElementType();
-
-      var lengths = new List<ParameterExpression>();
-      var indexes = new List<ParameterExpression>();
-      var labels = new List<LabelTarget>();
-
-      // Retrieve the length of each of the array's dimensions
-      MethodInfo arrayGetLengthMethodInfo = typeof(Array).GetMethod("GetLength");
-      for(int index = 0; index < dimensionCount; ++index) {
-        lengths.Add(Expression.Variable(typeof(int)));
-        variables.Add(lengths[index]);
-
-        indexes.Add(Expression.Variable(typeof(int)));
-        variables.Add(indexes[index]);
-
-        labels.Add(Expression.Label());
-
-        transferExpressions.Add(
-          Expression.Assign(
-            lengths[index],
-            Expression.Call(
-              original, arrayGetLengthMethodInfo, Expression.Constant(index)
-            )
-          )
-        );
-      }
-
-      // Create a new (empty) array with the same dimensions and lengths as the original
-      transferExpressions.Add(
-        Expression.Assign(
-          clone, Expression.NewArrayBounds(elementType, lengths)
-        )
-      );
-
-      // Initialize the indexer of the outer loop (indexers are initialized one up
-      // in the loops (ie. before the loop using it begins), so we have to set this
-      // one outside of the loop building code.
-      transferExpressions.Add(
-        Expression.Assign(indexes[0], Expression.Constant(0))
-      );
-
-      // We use a temporary variable to store the element
-      ParameterExpression element = Expression.Variable(elementType);
-      variables.Add(element);
-
-      // Build the nested loops (one for each dimension) from the inside out
-      Expression innerLoop = null;
-      for(int index = dimensionCount - 1; index >= 0; --index) {
-        var loopVariables = new List<ParameterExpression>();
-        var loopExpressions = new List<Expression>();
-
-        // If we reached the end of the current array dimension, break the loop
-        loopExpressions.Add(
-          Expression.IfThen(
-            Expression.GreaterThanOrEqual(indexes[index], lengths[index]),
-            Expression.Break(labels[index])
-          )
-        );
-
-        if(innerLoop == null) {
-          // The innermost loop clones an actual array element
-          if(elementType.IsPrimitive || (elementType == typeof(string))) {
-            loopExpressions.Add(
-              Expression.Assign(
-                Expression.ArrayAccess(clone, indexes),
-                Expression.ArrayAccess(original, indexes)
-              )
-            );
-          } else if(elementType.IsValueType) {
-            generateComplexTypeTransferExpressions(
-              elementType,
-              Expression.ArrayAccess(original, indexes),
-              Expression.ArrayAccess(clone, indexes),
-              variables,
-              loopExpressions
-            );
-          } else {
-            ParameterExpression originalElement = Expression.Variable(elementType);
-            loopVariables.Add(originalElement);
-
-            loopExpressions.Add(
-              Expression.Assign(originalElement, Expression.ArrayAccess(original, indexes))
-            );
-
-            var nestedVariables = new List<ParameterExpression>();
-            var nestedTransferExpressions = new List<Expression>();
-
-            if(elementType.IsArray) {
-              Expression clonedElement;
-
-              Type nestedElementType = elementType.GetElementType();
-              if(nestedElementType.IsPrimitive || (nestedElementType == typeof(string))) {
-                clonedElement = generatePrimitiveArrayTransferExpressions(
-                  elementType, originalElement, nestedVariables, nestedTransferExpressions
-                );
-              } else {
-                clonedElement = generateComplexArrayTransferExpressions(
-                  elementType, originalElement, nestedVariables, nestedTransferExpressions
-                );
-              }
-              nestedTransferExpressions.Add(
-                Expression.Assign(Expression.ArrayAccess(clone, indexes), clonedElement)
-              );
-            } else {
-              // Complex types are cloned by checking their actual, concrete type (fields
-              // may be typed to an interface or base class) and requesting a cloner for that
-              // type during runtime
-              MethodInfo getOrCreateClonerMethodInfo = typeof(ExpressionTreeCloner).GetMethod(
-                "getOrCreateDeepFieldBasedCloner",
-                BindingFlags.NonPublic | BindingFlags.Static
-              );
-              MethodInfo getTypeMethodInfo = typeof(object).GetMethod("GetType");
-              MethodInfo invokeMethodInfo = typeof(Func<object, object>).GetMethod("Invoke");
-
-              // Generate expressions to do this:
-              //   clone.SomeField = getOrCreateDeepFieldBasedCloner(
-              //     original.SomeField.GetType()
-              //   ).Invoke(original.SomeField);
-              nestedTransferExpressions.Add(
-                Expression.Assign(
-                  Expression.ArrayAccess(clone, indexes),
-                  Expression.Convert(
-                    Expression.Call(
-                      Expression.Call(
-                        getOrCreateClonerMethodInfo,
-                        Expression.Call(originalElement, getTypeMethodInfo)
-                      ),
-                      invokeMethodInfo,
-                      originalElement
-                    ),
-                    elementType
-                  )
-                )
-              );
-            }
-
-            loopExpressions.Add(
-              Expression.IfThen(
-                Expression.NotEqual(originalElement, Expression.Constant(null)),
-                Expression.Block(
-                  nestedVariables,
-                  nestedTransferExpressions
-                )
-              )
-            );
-          }
-
-        } else {
-          // Outer loops of any level just reset the inner loop's indexer and execute
-          // the inner loop
-          loopExpressions.Add(
-            Expression.Assign(indexes[index + 1], Expression.Constant(0))
-          );
-          loopExpressions.Add(innerLoop);
-        }
-
-        // Each time we executed the loop instructions, increment the indexer
-        loopExpressions.Add(Expression.PreIncrementAssign(indexes[index]));
-
-        // Build the loop using the expressions recorded above
-        innerLoop = Expression.Loop(
-          Expression.Block(loopVariables, loopExpressions),
-          labels[index]
-        );
-      }
-
-      // After the loop builder has finished, the innerLoop variable contains
-      // the entire hierarchy of nested loops, so add this to the clone expressions.
-      transferExpressions.Add(innerLoop);
-
-      return clone;
-    }
-
-    /// <summary>Generates state transfer expressions to copy a complex type</summary>
-    /// <param name="clonedType">Complex type that will be cloned</param>
-    /// <param name="original">Variable expression for the original instance</param>
-    /// <param name="clone">Variable expression for the cloned instance</param>
-    /// <param name="variables">Receives variables used by the transfer expressions</param>
-    /// <param name="transferExpressions">Receives the generated transfer expressions</param>
-    private static void generateComplexTypeTransferExpressions(
-      Type clonedType, // Actual, concrete type (not declared type)
-      Expression original, // Expected to be an object
-      Expression clone,	// As actual, concrete type
-      IList<ParameterExpression> variables,
-      ICollection<Expression> transferExpressions
-    ) {
-      // Enumerate all of the type's fields and generate transfer expressions for each
-      FieldInfo[] fieldInfos = clonedType.GetFields(
-        BindingFlags.Public | BindingFlags.NonPublic |
-        BindingFlags.Instance | BindingFlags.FlattenHierarchy
-      );
-      for(int index = 0; index < fieldInfos.Length; ++index) {
-        FieldInfo fieldInfo = fieldInfos[index];
-        Type fieldType = fieldInfo.FieldType;
-
-        if(fieldType.IsPrimitive || (fieldType == typeof(string))) {
-          // Primitive types and strings can be transferred by simple assignment
-          transferExpressions.Add(
-            Expression.Assign(
-              Expression.Field(clone, fieldInfo),
-              Expression.Field(original, fieldInfo)
-            )
-          );
-        } else if(fieldType.IsValueType) {
-          // A nested value type is part of the parent and will have its fields directly
-          // assigned without boxing, new instance creation or anything like that.
-          generateComplexTypeTransferExpressions(
-            fieldType,
-            Expression.Field(original, fieldInfo),
-            Expression.Field(clone, fieldInfo),
-            variables,
-            transferExpressions
-          );
-        } else {
-          generateReferenceTypeTransferExpressions(
-            original, clone, transferExpressions, fieldInfo, fieldType
-          );
-        }
-      }
-    }
-
-    /// <summary>
-    ///   Generates the expressions to transfer a reference type (array or class)
-    /// </summary>
-    /// <param name="original">Original value that will be cloned</param>
-    /// <param name="clone">Variable that will receive the cloned value</param>
-    /// <param name="transferExpressions">
-    ///   Receives the expression generated to transfer the values
-    /// </param>
-    /// <param name="fieldInfo">Reflection informations about the field being cloned</param>
-    /// <param name="fieldType">Type of the field being cloned</param>
-    private static void generateReferenceTypeTransferExpressions(
-      Expression original,
-      Expression clone,
-      ICollection<Expression> transferExpressions,
-      FieldInfo fieldInfo,
-      Type fieldType
-    ) {
-      // Reference types and arrays require special care because they can be null,
-      // so gather the transfer expressions in a separate block for the null check
-      var fieldTransferExpressions = new List<Expression>();
-      var fieldVariables = new List<ParameterExpression>();
-
-      if(fieldType.IsArray) {
-        // Arrays need to be cloned element-by-element
-        Expression fieldClone;
-
-        Type elementType = fieldType.GetElementType();
-        if(elementType.IsPrimitive || (elementType == typeof(string))) {
-          // For primitive arrays, the Array.Clone() method is sufficient
-          fieldClone = generatePrimitiveArrayTransferExpressions(
-            fieldType,
-            Expression.Field(original, fieldInfo),
-            fieldVariables,
-            fieldTransferExpressions
-          );
-        } else {
-          // Arrays of complex types require manual cloning
-          fieldClone = generateComplexArrayTransferExpressions(
-            fieldType,
-            Expression.Field(original, fieldInfo),
-            fieldVariables,
-            fieldTransferExpressions
-          );
-        }
-
-        // Add the assignment to the transfer expressions. The array transfer expression
-        // generator will either have set up a temporary variable to hold the array or
-        // returned the conversion expression straight away
-        fieldTransferExpressions.Add(
-          Expression.Assign(Expression.Field(clone, fieldInfo), fieldClone)
-        );
-      } else {
-        // Complex types are cloned by checking their actual, concrete type (fields
-        // may be typed to an interface or base class) and requesting a cloner for that
-        // type during runtime
-        MethodInfo getOrCreateClonerMethodInfo = typeof(ExpressionTreeCloner).GetMethod(
-          "getOrCreateDeepFieldBasedCloner",
-          BindingFlags.NonPublic | BindingFlags.Static
-        );
-        MethodInfo getTypeMethodInfo = typeof(object).GetMethod("GetType");
-        MethodInfo invokeMethodInfo = typeof(Func<object, object>).GetMethod("Invoke");
-
-        // Generate expressions to do this:
-        //   clone.SomeField = getOrCreateDeepFieldBasedCloner(
-        //     original.SomeField.GetType()
-        //   ).Invoke(original.SomeField);
-        fieldTransferExpressions.Add(
-          Expression.Assign(
-            Expression.Field(clone, fieldInfo),
-            Expression.Convert(
-              Expression.Call(
-                Expression.Call(
-                  getOrCreateClonerMethodInfo,
-                  Expression.Call(
-                    Expression.Field(original, fieldInfo), getTypeMethodInfo
-                  )
-                ),
-                invokeMethodInfo,
-                Expression.Field(original, fieldInfo)
-              ),
-              fieldType
-            )
-          )
-        );
-      }
-
-      // Wrap up the generated array or complex reference type transfer expressions
-      // in a null check so the field is skipped if it is not holding an instance.
-      transferExpressions.Add(
-        Expression.IfThen(
-          Expression.NotEqual(
-            Expression.Field(original, fieldInfo), Expression.Constant(null)
-          ),
-          Expression.Block(fieldVariables, fieldTransferExpressions)
-        )
-      );
-    }
-
-    /// <summary>Compiles a method that creates a clone of an object</summary>
-    /// <param name="clonedType">Type for which a clone method will be created</param>
-    /// <returns>A method that clones an object of the provided type</returns>
-    /// <remarks>
-    ///   <para>
-    ///     The 'null' check is supposed to take place before running the cloner. This
-    ///     avoids having redundant 'null' checks on nested types - first before calling
-    ///     GetType() on the field to be cloned and second when runner the matching
-    ///     cloner for the field.
-    ///   </para>
-    ///   <para>
-    ///     This design also enables the cloning of nested value types (which can never
-    ///     be null) without any null check whatsoever.
-    ///   </para>
-    /// </remarks>
-    private static Func<object, object> createDeepFieldBasedCloner(Type clonedType) {
-      ParameterExpression original = Expression.Parameter(typeof(object), "original");
-
-      var transferExpressions = new List<Expression>();
-      var variables = new List<ParameterExpression>();
-
-      if(clonedType.IsPrimitive || (clonedType == typeof(string))) {
-        // Primitives and strings are copied on direct assignment
-        transferExpressions.Add(original);
-      } else if(clonedType.IsArray) {
-        // Arrays need to be cloned element-by-element
-        Type elementType = clonedType.GetElementType();
-
-        if(elementType.IsPrimitive || (elementType == typeof(string))) {
-          // For primitive arrays, the Array.Clone() method is sufficient
-          transferExpressions.Add(
-            generatePrimitiveArrayTransferExpressions(
-              clonedType, original, variables, transferExpressions
-            )
-          );
-        } else {
-          // To access the fields of the original type, we need it to be of the actual
-          // type instead of an object, so perform a downcast
-          ParameterExpression typedOriginal = Expression.Variable(clonedType);
-          variables.Add(typedOriginal);
-          transferExpressions.Add(
-            Expression.Assign(typedOriginal, Expression.Convert(original, clonedType))
-          );
-
-          // Arrays of complex types require manual cloning
-          transferExpressions.Add(
-            generateComplexArrayTransferExpressions(
-              clonedType, typedOriginal, variables, transferExpressions
-            )
-          );
-        }
-      } else {
-        // We need a variable to hold the clone because due to the assignments it
-        // won't be last in the block when we're finished
-        ParameterExpression clone = Expression.Variable(clonedType);
-        variables.Add(clone);
-
-        // Give it a new instance of the type being cloned
-        transferExpressions.Add(Expression.Assign(clone, Expression.New(clonedType)));
-
-        // To access the fields of the original type, we need it to be of the actual
-        // type instead of an object, so perform a downcast
-        ParameterExpression typedOriginal = Expression.Variable(clonedType);
-        variables.Add(typedOriginal);
-        transferExpressions.Add(
-          Expression.Assign(typedOriginal, Expression.Convert(original, clonedType))
-        );
-
-        // Generate the expressions required to transfer the type field by field
-        generateComplexTypeTransferExpressions(
-          clonedType, typedOriginal, clone, variables, transferExpressions
-        );
-
-        // Make sure the clone is the last thing in the block to set the return value
-        transferExpressions.Add(clone);
-      }
-
-      // Turn all transfer expressions into a single block if necessary
-      Expression resultExpression;
-      if((transferExpressions.Count == 1) && (variables.Count == 0)) {
-        resultExpression = transferExpressions[0];
-      } else {
-        resultExpression = Expression.Block(variables, transferExpressions);
-      }
-
-      // Value types require manual boxing
-      if(clonedType.IsValueType) {
-        resultExpression = Expression.Convert(resultExpression, typeof(object));
-      }
-
-      return Expression.Lambda<Func<object, object>>(resultExpression, original).Compile();
-    }
-
 #if false
     /// <summary>
     ///   Transfers the state of one object into another, creating clones of referenced objects
@@ -651,10 +180,48 @@ namespace Nuclex.Support.Cloning {
 
 #endif
 
+    /// <summary>
+    ///   Retrieves the existing clone method for the specified type or compiles one if
+    ///   none exists for the type yet
+    /// </summary>
+    /// <param name="clonedType">Type for which a clone method will be retrieved</param>
+    /// <returns>The clone method for the specified type</returns>
+    private static Func<object, object> getOrCreateShallowFieldBasedCloner(Type clonedType) {
+      Func<object, object> cloner;
+
+      if(!shallowFieldBasedCloners.TryGetValue(clonedType, out cloner)) {
+        cloner = createShallowFieldBasedCloner(clonedType);
+        shallowFieldBasedCloners.TryAdd(clonedType, cloner);
+      }
+
+      return cloner;
+    }
+
+    /// <summary>
+    ///   Retrieves the existing clone method for the specified type or compiles one if
+    ///   none exists for the type yet
+    /// </summary>
+    /// <param name="clonedType">Type for which a clone method will be retrieved</param>
+    /// <returns>The clone method for the specified type</returns>
+    private static Func<object, object> getOrCreateDeepFieldBasedCloner(Type clonedType) {
+      Func<object, object> cloner;
+
+      if(!deepFieldBasedCloners.TryGetValue(clonedType, out cloner)) {
+        cloner = createDeepFieldBasedCloner(clonedType);
+        deepFieldBasedCloners.TryAdd(clonedType, cloner);
+      }
+
+      return cloner;
+    }
+
     /// <summary>Compiled cloners that perform shallow clone operations</summary>
-    private static ConcurrentDictionary<Type, Func<object, object>> shallowCloners;
+    private static ConcurrentDictionary<Type, Func<object, object>> shallowFieldBasedCloners;
     /// <summary>Compiled cloners that perform deep clone operations</summary>
-    private static ConcurrentDictionary<Type, Func<object, object>> deepCloners;
+    private static ConcurrentDictionary<Type, Func<object, object>> deepFieldBasedCloners;
+    /// <summary>Compiled cloners that perform shallow clone operations</summary>
+    private static ConcurrentDictionary<Type, Func<object, object>> shallowPropertyBasedCloners;
+    /// <summary>Compiled cloners that perform deep clone operations</summary>
+    private static ConcurrentDictionary<Type, Func<object, object>> deepPropertyBasedCloners;
 
   }