From 976b1ddba55ddfb1ed90e30e2d431c1c5ddf6468 Mon Sep 17 00:00:00 2001 From: Markus Ewald Date: Fri, 3 Feb 2012 14:49:31 +0000 Subject: [PATCH] Cloners now offer their methods as static members for easy access in non-service oriented applications; began implementing the expression tree cloner git-svn-id: file:///srv/devel/repo-conversion/nusu@228 d2e56fa2-650e-0410-a79f-9358c0239efd --- Nuclex.Support (net-4.0).csproj | 3 + Nuclex.Support (xna-4.0-phone7).csproj | 3 + Nuclex.Support (xna-4.0-xbox360).csproj | 3 + Source/Cloning/ExpressionTreeCloner.Test.cs | 177 ++++++++++++++++++++ Source/Cloning/ExpressionTreeCloner.cs | 72 ++++++-- Source/Cloning/ReflectionCloner.cs | 43 ++++- Source/Cloning/SerializationCloner.Test.cs | 2 +- Source/Cloning/SerializationCloner.cs | 63 ++++--- 8 files changed, 323 insertions(+), 43 deletions(-) create mode 100644 Source/Cloning/ExpressionTreeCloner.Test.cs diff --git a/Nuclex.Support (net-4.0).csproj b/Nuclex.Support (net-4.0).csproj index 70420ef..6519c0d 100644 --- a/Nuclex.Support (net-4.0).csproj +++ b/Nuclex.Support (net-4.0).csproj @@ -63,6 +63,9 @@ + + ExpressionTreeCloner.cs + diff --git a/Nuclex.Support (xna-4.0-phone7).csproj b/Nuclex.Support (xna-4.0-phone7).csproj index 698f1b1..b0e753a 100644 --- a/Nuclex.Support (xna-4.0-phone7).csproj +++ b/Nuclex.Support (xna-4.0-phone7).csproj @@ -94,6 +94,9 @@ + + ExpressionTreeCloner.cs + diff --git a/Nuclex.Support (xna-4.0-xbox360).csproj b/Nuclex.Support (xna-4.0-xbox360).csproj index 7b32470..fe0c9e7 100644 --- a/Nuclex.Support (xna-4.0-xbox360).csproj +++ b/Nuclex.Support (xna-4.0-xbox360).csproj @@ -105,6 +105,9 @@ + + ExpressionTreeCloner.cs + diff --git a/Source/Cloning/ExpressionTreeCloner.Test.cs b/Source/Cloning/ExpressionTreeCloner.Test.cs new file mode 100644 index 0000000..618338a --- /dev/null +++ b/Source/Cloning/ExpressionTreeCloner.Test.cs @@ -0,0 +1,177 @@ +#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 UNITTEST + +using System; +using System.Collections.Generic; + +using NUnit.Framework; + +namespace Nuclex.Support.Cloning { + + /// Unit Test for the expression tree-based cloner + [TestFixture] + public class ExpressionTreeClonerTest : CloneFactoryTest { + + /// Initializes a new unit test suite for the reflection cloner + public ExpressionTreeClonerTest() { + this.cloneFactory = new ExpressionTreeCloner(); + } + + /// Verifies that clones of primitive types can be created + [Test] + public void PrimitiveTypesCanBeCloned() { + int original = 12345; + int clone = this.cloneFactory.ShallowClone(original, false); + Assert.AreEqual(original, clone); + } + + /// Verifies that shallow clones of arrays can be made + [Test] + public void ShallowClonesOfArraysCanBeMade() { + var original = new TestReferenceType[] { + new TestReferenceType() { TestField = 123, TestProperty = 456 } + }; + TestReferenceType[] clone = this.cloneFactory.ShallowClone(original, false); + + Assert.AreSame(original[0], clone[0]); + } + + /// Verifies that deep clones of arrays can be made + [Test] + public void DeepClonesOfArraysCanBeMade() { + var original = new TestReferenceType[] { + new TestReferenceType() { TestField = 123, TestProperty = 456 } + }; + TestReferenceType[] clone = this.cloneFactory.DeepClone(original, false); + + Assert.AreNotSame(original[0], clone[0]); + Assert.AreEqual(original[0].TestField, clone[0].TestField); + Assert.AreEqual(original[0].TestProperty, clone[0].TestProperty); + } + + /// Verifies that deep clones of a generic list can be made + [Test] + public void GenericListsCanBeCloned() { + var original = new List(new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 }); + List clone = this.cloneFactory.DeepClone(original, false); + + CollectionAssert.AreEqual(original, clone); + } + + /// Verifies that deep clones of a generic dictionary can be made + [Test] + public void GenericDictionariesCanBeCloned() { + var original = new Dictionary(); + original.Add(1, "one"); + Dictionary clone = this.cloneFactory.DeepClone(original, false); + + Assert.AreEqual("one", clone[1]); + } + + /// + /// Verifies that a field-based shallow clone of a value type can be performed + /// + [Test] + public void ShallowFieldBasedClonesOfValueTypesCanBeMade() { + HierarchicalValueType original = CreateValueType(); + HierarchicalValueType clone = this.cloneFactory.ShallowClone(original, false); + VerifyClone(ref original, ref clone, isDeepClone: false, isPropertyBasedClone: false); + } + + /// + /// Verifies that a field-based shallow clone of a reference type can be performed + /// + [Test] + public void ShallowFieldBasedClonesOfReferenceTypesCanBeMade() { + HierarchicalReferenceType original = CreateReferenceType(); + HierarchicalReferenceType clone = this.cloneFactory.ShallowClone(original, false); + VerifyClone(original, clone, isDeepClone: false, isPropertyBasedClone: false); + } + + /// + /// Verifies that a field-based deep clone of a value type can be performed + /// + [Test] + public void DeepFieldBasedClonesOfValueTypesCanBeMade() { + HierarchicalValueType original = CreateValueType(); + HierarchicalValueType clone = this.cloneFactory.DeepClone(original, false); + VerifyClone(ref original, ref clone, isDeepClone: true, isPropertyBasedClone: false); + } + + /// + /// Verifies that a field-based deep clone of a reference type can be performed + /// + [Test] + public void DeepFieldBasedClonesOfReferenceTypesCanBeMade() { + HierarchicalReferenceType original = CreateReferenceType(); + HierarchicalReferenceType clone = this.cloneFactory.DeepClone(original, false); + VerifyClone(original, clone, isDeepClone: true, isPropertyBasedClone: false); + } + + /// + /// Verifies that a property-based shallow clone of a value type can be performed + /// + [Test] + public void ShallowPropertyBasedClonesOfValueTypesCanBeMade() { + HierarchicalValueType original = CreateValueType(); + HierarchicalValueType clone = this.cloneFactory.ShallowClone(original, true); + VerifyClone(ref original, ref clone, isDeepClone: false, isPropertyBasedClone: true); + } + + /// + /// Verifies that a property-based shallow clone of a reference type can be performed + /// + [Test] + public void ShallowPropertyBasedClonesOfReferenceTypesCanBeMade() { + HierarchicalReferenceType original = CreateReferenceType(); + HierarchicalReferenceType clone = this.cloneFactory.ShallowClone(original, true); + VerifyClone(original, clone, isDeepClone: false, isPropertyBasedClone: true); + } + + /// + /// Verifies that a property-based deep clone of a value type can be performed + /// + [Test] + public void DeepPropertyBasedClonesOfValueTypesCanBeMade() { + HierarchicalValueType original = CreateValueType(); + HierarchicalValueType clone = this.cloneFactory.DeepClone(original, true); + VerifyClone(ref original, ref clone, isDeepClone: true, isPropertyBasedClone: true); + } + + /// + /// Verifies that a property-based deep clone of a reference type can be performed + /// + [Test] + public void DeepPropertyBasedClonesOfReferenceTypesCanBeMade() { + HierarchicalReferenceType original = CreateReferenceType(); + HierarchicalReferenceType clone = this.cloneFactory.DeepClone(original, true); + VerifyClone(original, clone, isDeepClone: true, isPropertyBasedClone: true); + } + + /// Clone factory being tested + private ICloneFactory cloneFactory; + + } + +} // namespace Nuclex.Support.Cloning + +#endif // UNITTEST diff --git a/Source/Cloning/ExpressionTreeCloner.cs b/Source/Cloning/ExpressionTreeCloner.cs index 3086634..cedc9af 100644 --- a/Source/Cloning/ExpressionTreeCloner.cs +++ b/Source/Cloning/ExpressionTreeCloner.cs @@ -18,15 +18,13 @@ License along with this library */ #endregion +#if !(XBOX360 || WINDOWS_PHONE) + using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; +using System.Collections.Concurrent; namespace Nuclex.Support.Cloning { -#if false - /// 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 @@ -40,7 +38,13 @@ namespace Nuclex.Support.Cloning { /// Cloning factory which uses expression trees to improve performance when cloning /// is a high-frequency action. /// - public class ExpressionTreeCloneFactory : ICloneFactory { + 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 @@ -52,9 +56,10 @@ namespace Nuclex.Support.Cloning { /// Whether to clone the object based on its properties only /// /// A deep clone of the provided object - public TCloned DeepClone(TCloned objectToClone, bool usePropertyBasedClone) - where TCloned : new() { - throw new NotImplementedException(); + public static TCloned DeepClone( + TCloned objectToClone, bool usePropertyBasedClone + ) { + throw new NotImplementedException("Not implemented yet"); } /// @@ -66,11 +71,44 @@ namespace Nuclex.Support.Cloning { /// Whether to clone the object based on its properties only /// /// A shallow clone of the provided object - public TCloned ShallowClone(TCloned objectToClone, bool usePropertyBasedClone) - where TCloned : new() { - throw new NotImplementedException(); + 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); + } + +#if false /// /// Transfers the state of one object into another, creating clones of referenced objects /// @@ -145,9 +183,15 @@ namespace Nuclex.Support.Cloning { 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; } -#endif - } // namespace Nuclex.Support.Cloning + +#endif // !(XBOX360 || WINDOWS_PHONE) diff --git a/Source/Cloning/ReflectionCloner.cs b/Source/Cloning/ReflectionCloner.cs index a145255..df30ef0 100644 --- a/Source/Cloning/ReflectionCloner.cs +++ b/Source/Cloning/ReflectionCloner.cs @@ -42,7 +42,9 @@ namespace Nuclex.Support.Cloning { /// Whether to clone the object based on its properties only /// /// A shallow clone of the provided object - public TCloned ShallowClone(TCloned objectToClone, bool usePropertyBasedClone) { + public static TCloned ShallowClone( + TCloned objectToClone, bool usePropertyBasedClone + ) { Type originalType = objectToClone.GetType(); if(originalType.IsPrimitive || (originalType == typeof(string))) { return objectToClone; // Being value types, primitives are copied by default @@ -73,7 +75,9 @@ namespace Nuclex.Support.Cloning { /// Whether to clone the object based on its properties only /// /// A deep clone of the provided object - public TCloned DeepClone(TCloned objectToClone, bool usePropertyBasedClone) { + public static TCloned DeepClone( + TCloned objectToClone, bool usePropertyBasedClone + ) { if(usePropertyBasedClone) { return (TCloned)deepCloneSinglePropertyBased(objectToClone); } else { @@ -81,10 +85,39 @@ namespace Nuclex.Support.Cloning { } } + /// + /// 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 ReflectionCloner.ShallowClone(objectToClone, usePropertyBasedClone); + } + + /// + /// 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 ReflectionCloner.DeepClone(objectToClone, usePropertyBasedClone); + } + /// Clones a complex type using field-based value transfer /// Original instance that will be cloned /// A clone of the original instance - private object shallowCloneComplexFieldBased(object original) { + private static object shallowCloneComplexFieldBased(object original) { Type originalType = original.GetType(); object clone = Activator.CreateInstance(originalType); @@ -107,7 +140,7 @@ namespace Nuclex.Support.Cloning { /// Clones a complex type using property-based value transfer /// Original instance that will be cloned /// A clone of the original instance - private object shallowCloneComplexPropertyBased(object original) { + private static object shallowCloneComplexPropertyBased(object original) { Type originalType = original.GetType(); object clone = Activator.CreateInstance(originalType); @@ -140,7 +173,7 @@ namespace Nuclex.Support.Cloning { /// Clones an array using field-based value transfer /// Original array that will be cloned /// A clone of the original array - private object shallowCloneArray(object original) { + private static object shallowCloneArray(object original) { return ((Array)original).Clone(); } diff --git a/Source/Cloning/SerializationCloner.Test.cs b/Source/Cloning/SerializationCloner.Test.cs index 75cbe11..f4bcd01 100644 --- a/Source/Cloning/SerializationCloner.Test.cs +++ b/Source/Cloning/SerializationCloner.Test.cs @@ -27,7 +27,7 @@ using NUnit.Framework; namespace Nuclex.Support.Cloning { - /// Unit Test for the reflection-based cloner + /// Unit Test for the binary serializer-based cloner [TestFixture] public class SerializationClonerTest : CloneFactoryTest { diff --git a/Source/Cloning/SerializationCloner.cs b/Source/Cloning/SerializationCloner.cs index 8cf973a..b14e02e 100644 --- a/Source/Cloning/SerializationCloner.cs +++ b/Source/Cloning/SerializationCloner.cs @@ -18,6 +18,8 @@ License along with this library */ #endregion +#if !(XBOX360 || WINDOWS_PHONE) + using System; using System.IO; using System.Reflection; @@ -222,22 +224,15 @@ namespace Nuclex.Support.Cloning { #endregion // class PropertySerializationSurrogate - /// Initializes a new serialization-based cloner - public SerializationCloner() { - var fieldSurrogateSelector = new SurrogateSelector(); - fieldSurrogateSelector.ChainSelector( - new StaticSurrogateSelector(new FieldSerializationSurrogate()) + /// Initializes the static members of the serialization-based cloner + static SerializationCloner() { + fieldBasedFormatter = new BinaryFormatter( + new StaticSurrogateSelector(new FieldSerializationSurrogate()), + new StreamingContext(StreamingContextStates.All) ); - this.fieldBasedFormatter = new BinaryFormatter( - fieldSurrogateSelector, new StreamingContext(StreamingContextStates.All) - ); - - var propertySurrogateSelector = new SurrogateSelector(); - propertySurrogateSelector.ChainSelector( - new StaticSurrogateSelector(new PropertySerializationSurrogate()) - ); - this.propertyBasedFormatter = new BinaryFormatter( - propertySurrogateSelector, new StreamingContext(StreamingContextStates.All) + propertyBasedFormatter = new BinaryFormatter( + new StaticSurrogateSelector(new PropertySerializationSurrogate()), + new StreamingContext(StreamingContextStates.All) ); } @@ -251,20 +246,38 @@ namespace Nuclex.Support.Cloning { /// Whether to clone the object based on its properties only /// /// A deep clone of the provided object - public TCloned DeepClone(TCloned objectToClone, bool usePropertyBasedClone) { + public static TCloned DeepClone( + TCloned objectToClone, bool usePropertyBasedClone + ) { using(var memoryStream = new MemoryStream()) { if(usePropertyBasedClone) { - this.propertyBasedFormatter.Serialize(memoryStream, objectToClone); + propertyBasedFormatter.Serialize(memoryStream, objectToClone); memoryStream.Position = 0; - return (TCloned)this.propertyBasedFormatter.Deserialize(memoryStream); + return (TCloned)propertyBasedFormatter.Deserialize(memoryStream); } else { - this.fieldBasedFormatter.Serialize(memoryStream, objectToClone); + fieldBasedFormatter.Serialize(memoryStream, objectToClone); memoryStream.Position = 0; - return (TCloned)this.fieldBasedFormatter.Deserialize(memoryStream); + return (TCloned)fieldBasedFormatter.Deserialize(memoryStream); } } } + /// + /// 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 SerializationCloner.DeepClone(objectToClone, usePropertyBasedClone); + } + /// /// Creates a shallow clone of the specified object, reusing any referenced objects /// @@ -274,15 +287,19 @@ namespace Nuclex.Support.Cloning { /// Whether to clone the object based on its properties only /// /// A shallow clone of the provided object - public TCloned ShallowClone(TCloned objectToClone, bool usePropertyBasedClone) { + TCloned ICloneFactory.ShallowClone( + TCloned objectToClone, bool usePropertyBasedClone + ) { throw new NotSupportedException("The serialization cloner cannot create shallow clones"); } /// Serializes objects by storing their fields - private BinaryFormatter fieldBasedFormatter; + private static BinaryFormatter fieldBasedFormatter; /// Serializes objects by storing their properties - private BinaryFormatter propertyBasedFormatter; + private static BinaryFormatter propertyBasedFormatter; } } // namespace Nuclex.Support.Cloning + +#endif // !(XBOX360 || WINDOWS_PHONE)