#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 {
/// An action that takes its arguments as references to a structure
/// Type of the first argument to the method
/// Type of the second argument to the method
/// First argument to the method
/// Second argument to the method
public delegate void ReferenceAction(ref TFirst first, ref TSecond second)
where TFirst : struct
where TSecond : struct;
///
/// Cloning factory which uses expression trees to improve performance when cloning
/// is a high-frequency action.
///
public class ExpressionTreeCloner : ICloneFactory {
/// Initializes the static members of the expression tree cloner
static ExpressionTreeCloner() {
shallowCloners = new ConcurrentDictionary>();
deepCloners = new ConcurrentDictionary>();
}
///
/// Creates a deep clone of the specified object, also creating clones of all
/// child objects being referenced
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A deep clone of the provided object
public static TCloned DeepClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
object objectToCloneAsObject = objectToClone;
if(objectToCloneAsObject == null) {
return default(TCloned);
}
if(usePropertyBasedClone) {
throw new NotImplementedException("Not implemented yet");
} else {
Func cloner = getOrCreateDeepFieldBasedCloner(typeof(TCloned));
return (TCloned)cloner(objectToCloneAsObject);
}
}
///
/// Creates a shallow clone of the specified object, reusing any referenced objects
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A shallow clone of the provided object
public static TCloned ShallowClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
throw new NotImplementedException("Not implemented yet");
}
///
/// Creates a deep clone of the specified object, also creating clones of all
/// child objects being referenced
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A deep clone of the provided object
TCloned ICloneFactory.DeepClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
return ExpressionTreeCloner.DeepClone(objectToClone, usePropertyBasedClone);
}
///
/// Creates a shallow clone of the specified object, reusing any referenced objects
///
/// Type of the object that will be cloned
/// Object that will be cloned
///
/// Whether to clone the object based on its properties only
///
/// A shallow clone of the provided object
TCloned ICloneFactory.ShallowClone(
TCloned objectToClone, bool usePropertyBasedClone
) {
return ExpressionTreeCloner.ShallowClone(objectToClone, usePropertyBasedClone);
}
///
/// Retrieves the existing clone method for the specified type or compiles one if
/// none exists for the type yet
///
/// Type for which a clone method will be retrieved
/// The clone method for the specified type
private static Func getOrCreateDeepFieldBasedCloner(Type clonedType) {
Func cloner;
if(!deepCloners.TryGetValue(clonedType, out cloner)) {
cloner = createDeepFieldBasedCloner(clonedType);
deepCloners.TryAdd(clonedType, cloner);
}
return cloner;
}
///
/// Generates state transfer expressions to copy an array of primitive types
///
/// Type of array that will be cloned
/// Variable expression for the original array
/// Receives variables used by the transfer expressions
/// Receives the generated transfer expressions
/// The variable holding the cloned array
private static Expression generatePrimitiveArrayTransferExpressions(
Type clonedType,
Expression original,
ICollection variables,
ICollection transferExpressions
) {
MethodInfo arrayCloneMethodInfo = typeof(Array).GetMethod("Clone");
return Expression.Convert(
Expression.Call(
Expression.Convert(original, typeof(Array)), arrayCloneMethodInfo
),
clonedType
);
}
///
/// Generates state transfer expressions to copy an array of complex types
///
/// Type of array that will be cloned
/// Variable expression for the original array
/// Receives variables used by the transfer expressions
/// Receives the generated transfer expressions
/// The variable holding the cloned array
private static ParameterExpression generateComplexArrayTransferExpressions(
Type clonedType,
Expression original,
IList variables,
ICollection 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();
var indexes = new List();
var labels = new List();
// 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();
var loopExpressions = new List();
// 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();
var nestedTransferExpressions = new List();
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 {
ParameterExpression clonedElement = Expression.Variable(elementType);
loopVariables.Add(clonedElement);
nestedTransferExpressions.Add(
Expression.Assign(clonedElement, originalElement)
);
//generateComplexTypeTransferExpressions(
// elementType,
// originalElement,
// clonedElement,
// loopVariables,
// loopExpressions
//);
nestedTransferExpressions.Add(
Expression.Assign(Expression.ArrayAccess(clone, indexes), clonedElement)
);
}
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;
}
/// Generates state transfer expressions to copy a complex type
/// Complex type that will be cloned
/// Variable expression for the original instance
/// Variable expression for the cloned instance
/// Receives variables used by the transfer expressions
/// Receives the generated transfer expressions
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 variables,
ICollection 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
);
}
}
}
///
/// Generates the expressions to transfer a reference type (array or class)
///
/// Original value that will be cloned
/// Variable that will receive the cloned value
///
/// Receives the expression generated to transfer the values
///
/// Reflection informations about the field being cloned
/// Type of the field being cloned
private static void generateReferenceTypeTransferExpressions(
Expression original,
Expression clone,
ICollection 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();
var fieldVariables = new List();
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).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)
)
);
}
/// Compiles a method that creates a clone of an object
/// Type for which a clone method will be created
/// A method that clones an object of the provided type
///
///
/// 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.
///
///
/// This design also enables the cloning of nested value types (which can never
/// be null) without any null check whatsoever.
///
///
private static Func createDeepFieldBasedCloner(Type clonedType) {
ParameterExpression original = Expression.Parameter(typeof(object), "original");
var transferExpressions = new List();
var variables = new List();
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>(resultExpression, original).Compile();
}
#if false
///
/// Transfers the state of one object into another, creating clones of referenced objects
///
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void DeepCopyState(TState original, TState target, bool propertyBased)
where TState : class {
throw new NotImplementedException();
}
///
/// Transfers the state of one object into another, creating clones of referenced objects
///
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void DeepCopyState(ref TState original, ref TState target, bool propertyBased)
where TState : struct {
throw new NotImplementedException();
}
/// Transfers the state of one object into another
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void ShallowCopyState(TState original, TState target, bool propertyBased)
where TState : class {
throw new NotImplementedException();
}
/// Transfers the state of one object into another
/// Type of the object whose sate will be transferred
/// Original instance the state will be taken from
/// Target instance the state will be written to
/// Whether to perform a property-based state copy
public void ShallowCopyState(ref TState original, ref TState target, bool propertyBased)
where TState : struct {
throw new NotImplementedException();
}
///
/// Compiles a method that copies the state of one object into another object
///
/// Type of object whose state will be copied
/// Whether to create clones of the referenced objects
/// A method that copies the state from one object into another object
public static Action CreateReferenceCopier(bool deepClone)
where TCloned : class {
throw new NotImplementedException();
}
///
/// Compiles a method that copies the state of one object into another object
///
/// Type of object whose state will be copied
/// Whether to create clones of the referenced objects
/// A method that copies the state from one object into another object
public static ReferenceAction CreateValueCopier(bool deepClone)
where TCloned : struct {
throw new NotImplementedException();
}
/// Compiles a method that creates a clone of an object
/// Type of object that will be cloned
/// Whether to create clones of the referenced objects
/// A method that clones an object of the provided type
public static Func CreateCloner(bool deepClone)
where TCloned : class, new() {
throw new NotImplementedException();
}
#endif
/// Compiled cloners that perform shallow clone operations
private static ConcurrentDictionary> shallowCloners;
/// Compiled cloners that perform deep clone operations
private static ConcurrentDictionary> deepCloners;
}
} // namespace Nuclex.Support.Cloning
#endif // !(XBOX360 || WINDOWS_PHONE)