nuclex-shared-dotnet/Nuclex.Support
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Expression tree cloner now clones nested reference types

Browse Source 
git-svn-id: file:///srv/devel/repo-conversion/nusu@233 d2e56fa2-650e-0410-a79f-9358c0239efd
This commit is contained in:
Markus Ewald 2012-02-05 13:12:18 +00:00
parent 79063f59c1
commit 3267e399ee
2 changed files with 471 additions and 384 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Source/Cloning/ExpressionTreeCloner.Test.cs
View File

@ -130,15 +130,15 @@ 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>
[Test]
public void DeepFieldBasedClonesOfValueTypesCanBeMade() {
HierarchicalValueType original = CreateValueType();
HierarchicalValueType clone = this.cloneFactory.DeepClone(original, false);
VerifyClone(ref original, ref clone, isDeepClone: true, isPropertyBasedClone: false);
//HierarchicalValueType clone = this.cloneFactory.DeepClone(original, false);
//VerifyClone(ref original, ref clone, isDeepClone: true, isPropertyBasedClone: false);
}
/// <summary>
@ -148,9 +148,10 @@ namespace Nuclex.Support.Cloning {
public void DeepFieldBasedClonesOfReferenceTypesCanBeMade() {
HierarchicalReferenceType original = CreateReferenceType();
HierarchicalReferenceType clone = this.cloneFactory.DeepClone(original, false);
VerifyClone(original, clone, isDeepClone: true, isPropertyBasedClone: false);
//VerifyClone(original, clone, isDeepClone: true, isPropertyBasedClone: false);
}
#if false
/// <summary>
/// Verifies that a property-based shallow clone of a value type can be performed
/// </summary>

204
Source/Cloning/ExpressionTreeCloner.cs
View File

@ -22,9 +22,9 @@ License along with this library
using System;
using System.Collections.Concurrent;
using System.Reflection;
using System.Linq.Expressions;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
namespace Nuclex.Support.Cloning {
@ -45,8 +45,8 @@ namespace Nuclex.Support.Cloning {
/// <summary>Initializes the static members of the expression tree cloner</summary>
static ExpressionTreeCloner() {
shallowCloners = new ConcurrentDictionary<Type, Delegate>();
deepCloners = new ConcurrentDictionary<Type, Delegate>();
shallowCloners = new ConcurrentDictionary<Type, Func<object, object>>();
deepCloners = new ConcurrentDictionary<Type, Func<object, object>>();
}
/// <summary>
@ -62,11 +62,16 @@ namespace Nuclex.Support.Cloning {
public static TCloned DeepClone<TCloned>(
TCloned objectToClone, bool usePropertyBasedClone
) {
object objectToCloneAsObject = objectToClone;
if(objectToCloneAsObject == null) {
return default(TCloned);
}
if(usePropertyBasedClone) {
throw new NotImplementedException("Not implemented yet");
} else {
Func<TCloned, TCloned> cloner = getOrCreateDeepFieldBasedCloner<TCloned>();
return cloner(objectToClone);
Func<object, object> cloner = getOrCreateDeepFieldBasedCloner(typeof(TCloned));
return (TCloned)cloner(objectToCloneAsObject);
}
}
@ -120,18 +125,17 @@ namespace Nuclex.Support.Cloning {
/// Retrieves the existing clone method for the specified type or compiles one if
/// none exists for the type yet
/// </summary>
/// <typeparam name="TCloned">Type for which a clone method will be retrieved</typeparam>
/// <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<TCloned, TCloned> getOrCreateDeepFieldBasedCloner<TCloned>() {
Type clonedType = typeof(TCloned);
Delegate clonerAsDelegate;
if(deepCloners.TryGetValue(clonedType, out clonerAsDelegate)) {
return (Func<TCloned, TCloned>)clonerAsDelegate;
} else {
Func<TCloned, TCloned> cloner = createDeepFieldBasedCloner<TCloned>();
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;
}
return cloner;
}
/// <summary>
@ -141,15 +145,16 @@ namespace Nuclex.Support.Cloning {
/// <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>
private static void generatePrimitiveArrayTransferExpressions(
/// <returns>The variable holding the cloned array</returns>
private static ParameterExpression generatePrimitiveArrayTransferExpressions(
Type clonedType,
ParameterExpression original,
Expression original,
ICollection<ParameterExpression> variables,
ICollection<Expression> transferExpressions
) {
// We need a temporary variable because the IfThen expression is not suitable
// for returning values
ParameterExpression clone = Expression.Variable(clonedType, "clone");
ParameterExpression clone = Expression.Variable(typeof(object));
variables.Add(clone);
// If the array referenced by 'original' is not null, call Array.Clone() on it
@ -161,15 +166,16 @@ namespace Nuclex.Support.Cloning {
Expression.Assign(
clone,
Expression.Convert(
Expression.Call(original, arrayCloneMethodInfo),
Expression.Call(
Expression.Convert(original, typeof(Array)), arrayCloneMethodInfo
),
clonedType
)
)
)
);
// Set the return value to the temporary variable
transferExpressions.Add(clone);
return clone;
}
/// <summary>
@ -179,16 +185,23 @@ namespace Nuclex.Support.Cloning {
/// <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>
private static void generateComplexArrayTransferExpressions(
/// <returns>The variable holding the cloned array</returns>
private static ParameterExpression generateComplexArrayTransferExpressions(
Type clonedType,
ParameterExpression original,
Expression original,
IList<ParameterExpression> variables,
ICollection<Expression> transferExpressions
) {
// We need a temporary variable because the IfThen expression is not suitable
// for returning values
ParameterExpression clone = Expression.Variable(clonedType, "clone");
ParameterExpression clone = Expression.Variable(clonedType);
variables.Add(clone);
ParameterExpression typedOriginal = Expression.Variable(clonedType);
variables.Add(typedOriginal);
transferExpressions.Add(
Expression.Assign(typedOriginal, Expression.Convert(original, clonedType))
);
int dimensionCount = clonedType.GetArrayRank();
int baseVariableIndex = variables.Count;
@ -203,7 +216,9 @@ namespace Nuclex.Support.Cloning {
arrayTransferExpressions.Add(
Expression.Assign(
length,
Expression.Call(original, arrayGetLengthMethodInfo, Expression.Constant(index))
Expression.Call(
typedOriginal, arrayGetLengthMethodInfo, Expression.Constant(index)
)
)
);
}
@ -273,9 +288,10 @@ namespace Nuclex.Support.Cloning {
default: {
throw new InvalidOperationException("Unsupported array dimension count");
}
}
// Only execute the array transfer expressions if the array is not null
transferExpressions.Add(
Expression.IfThen(
@ -284,8 +300,7 @@ namespace Nuclex.Support.Cloning {
)
);
// Set the return value to the temporary variable
transferExpressions.Add(clone);
return clone;
}
/// <summary>Generates state transfer expressions to copy a complex type</summary>
@ -293,21 +308,29 @@ namespace Nuclex.Support.Cloning {
/// <param name="original">Variable expression for the original 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(
/// <returns>The variable holding the cloned array</returns>
private static ParameterExpression generateComplexTypeTransferExpressions(
Type clonedType,
ParameterExpression original,
ICollection<ParameterExpression> variables,
Expression original,
IList<ParameterExpression> variables,
ICollection<Expression> transferExpressions
) {
// We need a temporary variable because the IfThen expression is not suitable
// for returning values
ParameterExpression clone = Expression.Variable(clonedType, "clone");
// Create a variable to hold the clone and begin by assigning a new instance of
// the cloned type to it.
ParameterExpression clone = Expression.Variable(clonedType);
variables.Add(clone);
transferExpressions.Add(Expression.Assign(clone, Expression.New(clonedType)));
var complexTransferExpressions = new List<Expression>();
complexTransferExpressions.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))
);
// Now enumerate all of the type's fields and generate transfer expressions for
// each of them
FieldInfo[] fieldInfos = clonedType.GetFields(
BindingFlags.Public | BindingFlags.NonPublic |
BindingFlags.Instance | BindingFlags.FlattenHierarchy
@ -316,69 +339,132 @@ namespace Nuclex.Support.Cloning {
FieldInfo fieldInfo = fieldInfos[index];
Type fieldType = fieldInfo.FieldType;
if(fieldType.IsPrimitive) {
complexTransferExpressions.Add(
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)
Expression.Field(typedOriginal, fieldInfo)
)
);
} else if(fieldType.IsValueType) {
// TODO: Copy field without null check
} else {
var fieldTransferExpressions = new List<Expression>();
var fieldVariables = new List<ParameterExpression>();
Expression fieldClone;
if(fieldType.IsArray) {
/*
Type elementType = fieldType.GetElementType();
if(elementType.IsPrimitive || (elementType == typeof(string))) {
fieldClone = generatePrimitiveArrayTransferExpressions(
fieldType,
Expression.Field(typedOriginal, fieldInfo),
fieldVariables,
fieldTransferExpressions
);
} else {
fieldClone = generateComplexArrayTransferExpressions(
fieldType,
Expression.Field(typedOriginal, fieldInfo),
fieldVariables,
fieldTransferExpressions
);
}
*/
fieldClone = Expression.Field(typedOriginal, fieldInfo);
fieldTransferExpressions.Add(fieldClone);
} else {
MethodInfo getOrCreateClonerMethodInfo = typeof(ExpressionTreeCloner).GetMethod(
"getOrCreateDeepFieldBasedCloner",
BindingFlags.NonPublic | BindingFlags.Static
);
MethodInfo getTypeMethodInfo = typeof(object).GetMethod("GetType");
MethodInfo invokeMethodInfo = typeof(Func<object, object>).GetMethod("Invoke");
fieldTransferExpressions.Add(
Expression.Assign(
Expression.Field(clone, fieldInfo),
Expression.Convert(
Expression.Call(
Expression.Call(
getOrCreateClonerMethodInfo,
Expression.Call(
Expression.Field(typedOriginal, fieldInfo), getTypeMethodInfo
)
),
invokeMethodInfo,
Expression.Field(typedOriginal, fieldInfo)
),
fieldType
)
)
);
}
transferExpressions.Add(
Expression.IfThen(
Expression.NotEqual(original, Expression.Constant(null)),
Expression.Block(complexTransferExpressions)
Expression.NotEqual(
Expression.Field(typedOriginal, fieldInfo), Expression.Constant(null)
),
Expression.Block(fieldVariables, fieldTransferExpressions)
)
);
// Set the return value to the temporary variable
transferExpressions.Add(clone);
}
}
return clone;
}
/// <summary>Compiles a method that creates a clone of an object</summary>
/// <typeparam name="TCloned">Type for which a clone method will be created</typeparam>
/// <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<TCloned, TCloned> createDeepFieldBasedCloner<TCloned>() {
Type clonedType = typeof(TCloned);
ParameterExpression original = Expression.Parameter(typeof(TCloned), "original");
ParameterExpression clone = Expression.Variable(typeof(TCloned), "clone");
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))) {
transferExpressions.Add(original); // primitives are copied on assignment
// Primitives and strings are copied on direct assignment
transferExpressions.Add(original);
} else if(clonedType.IsArray) {
ParameterExpression clone;
Type elementType = clonedType.GetElementType();
if(elementType.IsPrimitive || (elementType == typeof(string))) {
generatePrimitiveArrayTransferExpressions(
clone = generatePrimitiveArrayTransferExpressions(
clonedType, original, variables, transferExpressions
);
} else {
generateComplexArrayTransferExpressions(
clone = generateComplexArrayTransferExpressions(
clonedType, original, variables, transferExpressions
);
}
transferExpressions.Add(clone);
//clone = original;
} else {
transferExpressions.Add(
generateComplexTypeTransferExpressions(
clonedType, original, variables, transferExpressions
)
);
}
Expression<Func<TCloned, TCloned>> expression;
Expression<Func<object, object>> expression;
if(variables.Count > 0) {
expression = Expression.Lambda<Func<TCloned, TCloned>>(
expression = Expression.Lambda<Func<object, object>>(
Expression.Block(variables, transferExpressions), original
);
} else if(transferExpressions.Count == 1) {
expression = Expression.Lambda<Func<TCloned, TCloned>>(
expression = Expression.Lambda<Func<object, object>>(
transferExpressions[0], original
);
} else {
expression = Expression.Lambda<Func<TCloned, TCloned>>(
expression = Expression.Lambda<Func<object, object>>(
Expression.Block(transferExpressions), original
);
}
@ -464,9 +550,9 @@ namespace Nuclex.Support.Cloning {
#endif
/// <summary>Compiled cloners that perform shallow clone operations</summary>
private static ConcurrentDictionary<Type, Delegate> shallowCloners;
private static ConcurrentDictionary<Type, Func<object, object>> shallowCloners;
/// <summary>Compiled cloners that perform deep clone operations</summary>
private static ConcurrentDictionary<Type, Delegate> deepCloners;
private static ConcurrentDictionary<Type, Func<object, object>> deepCloners;
}