/// <summary>
        /// Clone any object
        /// </summary>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="options">The cloning options</param>
        /// <param name="maxTreeDepth">The maximum tree depth</param>
        /// <returns></returns>
        public T Clone(T sourceObject, CloneOptions options, int maxTreeDepth, params Expression <Func <T, object> >[] ignoreProperties)

        {
            var configuration = CloneConfiguration.CreateFromOptions(options);

            return((T)InspectAndCopy(sourceObject, null, null, 0, maxTreeDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty, ConvertToPropertyNameList(ignoreProperties)));
        }
Exemple #2
0
 /// <summary>
 /// Returns true if an ignore configuration is configured
 /// </summary>
 /// <param name="configuration"></param>
 /// <param name="ignorePropertiesOrPaths"></param>
 /// <returns></returns>
 private bool HasIgnoreConfiguration(CloneConfiguration configuration, ICollection <string> ignorePropertiesOrPaths)
 {
     if (configuration.IgnorePropertiesWithAttributes.Count == 0 && (ignorePropertiesOrPaths == null || ignorePropertiesOrPaths.Count == 0))
     {
         return(false);
     }
     return(true);
 }
Exemple #3
0
        /// <summary>
        /// Returns true if object name should be ignored
        /// </summary>
        /// <param name="name">Property or field name</param>
        /// <param name="path">Full path to object</param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <param name="ignorePropertiesOrPaths">List of names or paths to ignore</param>
        /// <returns></returns>
        private bool IgnoreObjectName(string name, string path, CloneConfiguration configuration, ICollection <string> ignorePropertiesOrPaths, IEnumerable <CustomAttributeData> attributes = null)
        {
            var ignoreByNameOrPath = ignorePropertiesOrPaths?.Contains(name) == true || ignorePropertiesOrPaths?.Contains(path) == true;

            if (ignoreByNameOrPath)
            {
                return(true);
            }
#if FEATURE_CUSTOM_ATTRIBUTES
            if (attributes?.Any(x => configuration.IgnorePropertiesWithAttributes?.Contains(x.AttributeType.Name) == true) == true)
#else
            if (attributes?.Any(x => configuration.IgnorePropertiesWithAttributes?.Contains(x.Constructor.DeclaringType.Name) == true) == true)
#endif
            { return(true); }
            return(false);
        }
Exemple #4
0
        /// <summary>
        /// Clone any object
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <param name="ignorePropertiesOrPaths">A list of property names or fully qualified paths to ignore</param>
        /// <returns></returns>
        public static T Clone <T>(this T sourceObject, CloneConfiguration configuration, params string[] ignorePropertiesOrPaths)
        {
            var cloneProvider = new CloneProvider <T>();

            return(cloneProvider.Clone(sourceObject, configuration, configuration?.MaxDepth ?? CloneConfiguration.DefaultMaxDepth, ignorePropertiesOrPaths));
        }
 /// <summary>
 /// Clone any object
 /// </summary>
 /// <param name="sourceObject">The object to clone</param>
 /// <param name="configuration">Configure custom cloning options</param>
 /// <param name="maxTreeDepth">The maximum tree depth</param>
 /// <returns></returns>
 public T Clone(T sourceObject, CloneConfiguration configuration, int maxTreeDepth, params string[] ignorePropertiesOrPaths)
 => (T)InspectAndCopy(sourceObject, null, null, 0, maxTreeDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty, ignorePropertiesOrPaths);
        /// <summary>
        /// Clone any object
        /// </summary>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="options">The cloning options</param>
        /// <param name="maxTreeDepth">The maximum tree depth</param>
        /// <returns></returns>
        public T Clone(T sourceObject, CloneOptions options, int maxTreeDepth, params string[] ignorePropertiesOrPaths)
        {
            var configuration = CloneConfiguration.CreateFromOptions(options);

            return((T)InspectAndCopy(sourceObject, null, null, 0, maxTreeDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty, ignorePropertiesOrPaths));
        }
        /// <summary>
        /// Clone any object
        /// </summary>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="options">The cloning options</param>
        /// <param name="maxTreeDepth">The maximum tree depth</param>
        /// <returns></returns>
        public T Clone(T sourceObject, CloneOptions options, int maxTreeDepth)
        {
            var configuration = CloneConfiguration.CreateFromOptions(options);

            return((T)InspectAndCopy(sourceObject, 0, maxTreeDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty));
        }
 /// <summary>
 /// Clone any object
 /// </summary>
 /// <param name="sourceObject">The object to clone</param>
 /// <param name="configuration">Configure custom cloning options</param>
 /// <returns></returns>
 public T Clone(T sourceObject, CloneConfiguration configuration)
 {
     return((T)InspectAndCopy(sourceObject, 0, configuration?.MaxDepth ?? CloneConfiguration.DefaultMaxDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty));
 }
 /// <summary>
 /// (Recursive) Recursive function that inspects an object and its properties/fields and clones it
 /// </summary>
 /// <param name="sourceObject">The object to clone</param>
 /// <param name="currentDepth">The current tree depth</param>
 /// <param name="maxDepth">The max tree depth</param>
 /// <param name="configuration">The cloning options</param>
 /// <param name="objectTree">The object tree to prevent cyclical references</param>
 /// <param name="path">The current path being traversed</param>
 /// <returns></returns>
 private object InspectAndCopy(object sourceObject, int currentDepth, int maxDepth, CloneConfiguration configuration, ObjectTreeReferenceTracker objectTree, string path)
 => InspectAndCopy(sourceObject, null, null, currentDepth, maxDepth, configuration, objectTree, path, null);
 /// <summary>
 /// Clone any object to another type and provide an existing instance to clone to
 /// </summary>
 /// <typeparam name="TIn">The type to clone from</typeparam>
 /// <typeparam name="TOut">The type to clone to</typeparam>
 /// <param name="sourceObject"></param>
 /// <param name="destinationInstance">The existing instance to clone to</param>
 /// <param name="configuration">Configure custom cloning options</param>
 /// <returns></returns>
 public TOut CloneTo <TIn, TOut>(TIn sourceObject, TOut destinationInstance, CloneConfiguration configuration)
 => (TOut)InspectAndCopy(sourceObject, destinationInstance, typeof(TOut), 0, configuration?.MaxDepth ?? CloneConfiguration.DefaultMaxDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty, null);
        /// <summary>
        /// Clone any object to another type
        /// </summary>
        /// <typeparam name="TIn">The type to clone from</typeparam>
        /// <typeparam name="TOut">The type to clone to</typeparam>
        /// <param name="sourceObject"></param>
        /// <returns></returns>
        public TOut CloneTo <TIn, TOut>(TIn sourceObject)
        {
            var configuration = new CloneConfiguration();

            return((TOut)InspectAndCopy(sourceObject, null, typeof(TOut), 0, CloneConfiguration.DefaultMaxDepth, configuration, new ObjectTreeReferenceTracker(configuration.ReferenceTrackingType, configuration.AllowUseCustomHashCodes), string.Empty, null));
        }
Exemple #12
0
        /// <summary>
        /// Clone any object
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <returns></returns>
        public static T Clone <T>(this T sourceObject, CloneConfiguration configuration)
        {
            var cloneProvider = new CloneProvider <T>();

            return(cloneProvider.Clone(sourceObject, configuration));
        }
Exemple #13
0
        /// <summary>
        /// Clone any object
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="options">Specify the Clone options</param>
        /// <returns></returns>
        public static T Clone <T>(this T sourceObject, CloneOptions options)
        {
            var cloneProvider = new CloneProvider <T>();

            return(cloneProvider.Clone(sourceObject, CloneConfiguration.CreateFromOptions(options)));
        }
Exemple #14
0
        /// <summary>
        /// Clone any object to another type and provide an existing instance to clone to
        /// </summary>
        /// <typeparam name="TIn"></typeparam>
        /// <typeparam name="TOut"></typeparam>
        /// <param name="sourceObject"></param>
        /// <param name="destinationInstance"></param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <returns></returns>
        public static TOut CloneTo <TIn, TOut>(this TIn sourceObject, TOut destinationInstance, CloneConfiguration configuration)
        {
            var cloneProvider = new CloneProvider <TIn>();

            return(cloneProvider.CloneTo(sourceObject, destinationInstance, configuration));
        }
Exemple #15
0
        /// <summary>
        /// Clone any object to another type
        /// </summary>
        /// <typeparam name="TOut"></typeparam>
        /// <param name="sourceObject"></param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <returns></returns>
        public static TOut CloneTo <TOut>(this object sourceObject, CloneConfiguration configuration)
        {
            var cloneProvider = new CloneProvider <object>();

            return(cloneProvider.CloneTo <object, TOut>(sourceObject, configuration));
        }
Exemple #16
0
        /// <summary>
        /// Clone any object
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <param name="ignoreProperties">A list of property names to ignore</param>
        /// <returns></returns>
        public static T Clone <T>(this T sourceObject, CloneConfiguration configuration, params Expression <Func <T, object> >[] ignoreProperties)
        {
            var cloneProvider = new CloneProvider <T>();

            return(cloneProvider.Clone(sourceObject, configuration, configuration?.MaxDepth ?? CloneConfiguration.DefaultMaxDepth, ignoreProperties));
        }
Exemple #17
0
        /// <summary>
        /// Recursive function that inspects an object and its properties/fields and clones it to a new or existing type
        /// </summary>
        /// <param name="sourceObject">The object to clone</param>
        /// <param name="destinationObject">An existing object to clone values to</param>
        /// <param name="destinationObjectType">The type of the destination object to clone to</param>
        /// <param name="currentDepth">The current tree depth</param>
        /// <param name="maxDepth">The max tree depth</param>
        /// <param name="configuration">Configure custom cloning options</param>
        /// <param name="objectTree">The object tree to prevent cyclical references</param>
        /// <param name="path">The current path being traversed</param>
        /// <param name="ignorePropertiesOrPaths">A list of properties or paths to ignore</param>
        /// <returns></returns>
        private object InspectAndCopy(object sourceObject, object destinationObject, Type destinationObjectType, int currentDepth, int maxDepth, CloneConfiguration configuration, ObjectTreeReferenceTracker objectTree, string path, ICollection <string> ignorePropertiesOrPaths)
        {
            if (_hasIgnoreConfiguration == null)
            {
                _hasIgnoreConfiguration = HasIgnoreConfiguration(configuration, ignorePropertiesOrPaths);
            }

            if (_hasIgnoreConfiguration.Value && IgnoreObjectName(null, path, configuration, ignorePropertiesOrPaths))
            {
                return(null);
            }

            if (sourceObject == null)
            {
                return(null);
            }

            // ensure we don't go too deep if specified
            if (maxDepth > 0 && currentDepth >= maxDepth)
            {
                throw new CloneException($"The maximum clone recursion depth has exceeded maxDepth of '{maxDepth}'. Try setting the configuration option {nameof(CloneConfiguration.AllowUseCustomHashCodes)} to true or increase the {nameof(CloneConfiguration.MaxDepth)}. The last path traversed was '{path}'.", path);
            }

            var          type = sourceObject.GetType();
            ExtendedType typeSupport;

            try
            {
                typeSupport = type.GetExtendedType(DefaultExtendedTypeOptions);
            }
            // certain attributes such as .net remoting SoapTypeAttribute can cause issues trying to inspect. Possibly a framework bug with reflection
            catch (CustomAttributeFormatException)
            {
                return(sourceObject);
            }

            ExtendedType destinationTypeSupport;

            if (destinationObjectType == null || destinationObjectType == type)
            {
                destinationTypeSupport = typeSupport;
            }
            else
            {
                destinationTypeSupport = destinationObjectType.GetExtendedType(DefaultExtendedTypeOptions);
            }

            // always return the original value on value types
            if (typeSupport.IsValueType)
            {
                return(sourceObject);
            }

            // drop any objects we are ignoring by attribute
            if (_hasIgnoreConfiguration.Value && typeSupport.Attributes.Any(x => configuration.IgnorePropertiesWithAttributes.Contains(x.Name)))
            {
                return(null);
            }

            // for delegate types, copy them by reference rather than returning null
            if (typeSupport.IsDelegate)
            {
                return(sourceObject);
            }

            object newObject = null;

            // create a new empty object of the desired type
            if (typeSupport.IsArray)
            {
                if (!(sourceObject is Array sourceArray))
                {
                    throw new NullReferenceException($"{nameof(sourceArray)} cannot be null!");
                }
                // calculate the dimensions of the array
                var arrayRank = sourceArray.Rank;
                // get the length of each dimension
                var arrayDimensions = new List <int>();
                for (var dimension = 0; dimension < arrayRank; dimension++)
                {
                    arrayDimensions.Add(sourceArray.GetLength(dimension));
                }
                newObject = _objectFactory.CreateEmptyObject(destinationTypeSupport, default(TypeRegistry), arrayDimensions.ToArray());
            }
            else if (typeSupport.Type == typeof(string))
            {
                // copy the item directly
                newObject = string.Copy((string)sourceObject);
                return(newObject);
            }
            else
            {
                newObject = destinationObject ?? _objectFactory.CreateEmptyObject(destinationTypeSupport);
            }

            if (newObject == null)
            {
                return(null);
            }

            // increment the current recursion depth
            currentDepth++;

            // construct a hashtable of objects we have already inspected (recursion loop preventer)
            if (!typeSupport.IsValueType)
            {
                if (!objectTree.Contains(sourceObject))
                {
                    objectTree.Add(sourceObject);
                }
                else
                {
                    // object has already been traversed
                    return(sourceObject);
                }
            }

            // clone using IClonable interface if exists
            if (configuration.AllowIClonableImplementations && typeSupport.Interfaces.Contains(typeof(ICloneable)))
            {
                var iClonable = sourceObject as ICloneable;
                return(iClonable?.Clone());
            }

            // clone a dictionary's key/values
            else if (typeSupport.IsDictionary && typeSupport.IsGeneric)
            {
                var    genericType = typeSupport.Type.GetGenericArguments().ToList();
                Type[] typeArgs    = { genericType[0], genericType[1] };

                var listType      = typeof(Dictionary <,>).MakeGenericType(typeArgs);
                var newDictionary = Activator.CreateInstance(listType) as IDictionary;
                newObject = newDictionary ?? throw new NullReferenceException($"{nameof(newDictionary)} cannot be null");
                var iDictionary = sourceObject as IDictionary;
                var success     = false;
                var retryCount  = 0;
                while (!success && retryCount < 10)
                {
                    try
                    {
                        foreach (DictionaryEntry item in iDictionary)
                        {
                            var key   = InspectAndCopy(item.Key, null, null, currentDepth, maxDepth, configuration, objectTree, path, ignorePropertiesOrPaths);
                            var value = InspectAndCopy(item.Value, null, null, currentDepth, maxDepth, configuration, objectTree, path, ignorePropertiesOrPaths);
                            newDictionary.Add(key, value);
                        }
                        success = true;
                    }
                    catch (InvalidOperationException)
                    {
                        // if the collection was modified during enumeration, stop re-initialize and retry
                        success = false;
                        retryCount++;
                        newDictionary.Clear();
                    }
                }
                if (!success)
                {
                    throw new CloneException($"Error cloning Dictionary<,> at path '{path}'. Ensure the object is not modified while cloning data utilizing thread-safe access.");
                }
                return(newObject);
            }
            else if (typeSupport.IsHashtable && !typeSupport.IsGeneric)
            {
                var newHashtable = new Hashtable();
                newObject = newHashtable ?? throw new NullReferenceException($"{nameof(newHashtable)} cannot be null");
                var hashtable  = (Hashtable)sourceObject;
                var success    = false;
                var retryCount = 0;
                while (!success && retryCount < 10)
                {
                    try
                    {
                        foreach (DictionaryEntry item in hashtable)
                        {
                            var key   = InspectAndCopy(item.Key, null, null, currentDepth, maxDepth, configuration, objectTree, path, ignorePropertiesOrPaths);
                            var value = InspectAndCopy(item.Value, null, null, currentDepth, maxDepth, configuration, objectTree, path, ignorePropertiesOrPaths);
                            newHashtable.Add(key, value);
                        }
                        success = true;
                    }
                    catch (InvalidOperationException)
                    {
                        // if the collection was modified during enumeration, stop re-initialize and retry
                        success = false;
                        retryCount++;
                        newHashtable.Clear();
                    }
                }
                if (!success)
                {
                    throw new CloneException($"Error cloning Hashtable at path '{path}'. Ensure the object is not modified while cloning data utilizing thread-safe access.");
                }
                return(newObject);
            }
            else if (typeSupport.IsEnumerable && !typeSupport.IsArray)
            {
                // clone enumerable elements
                var  enumerable = (IEnumerable)sourceObject;
                bool hasEntries;
                if (typeSupport.IsCollection)
                {
                    hasEntries = ((ICollection)sourceObject).Count > 0;
                }
                else
                {
                    hasEntries = enumerable.Cast <object>().Any();
                }
                if (hasEntries)
                {
#if NET45_OR_GREATER || NETSTANDARD1_0_OR_GREATER
                    var readOnlyCollectionTypes = new[] { typeof(ReadOnlyCollection <>), typeof(ReadOnlyDictionary <,>) };
                    if (type.IsGenericType && readOnlyCollectionTypes.Contains(type.GetGenericTypeDefinition()))
                    {
                        // return as-is, since they can't be modified anyways
                        return(sourceObject);
                    }
#endif

                    var addMethod = typeSupport.Type.GetMethod("Add");
                    if (addMethod == null)
                    {
                        addMethod = typeSupport.Type.GetMethod("Enqueue");
                        if (addMethod == null)
                        {
                            addMethod = typeSupport.Type.GetMethod("Push");
                            if (addMethod == null)
                            {
                                addMethod = typeSupport.Methods.FirstOrDefault(x => x.Name.StartsWith("Add"));
                                if (addMethod == null)
                                {
                                    // as a backup, try utilizing memberwise clone
                                    return(_memberwiseCloneMethod.Invoke(sourceObject, null));
                                }
                            }
                        }
                    }

                    var success    = false;
                    var retryCount = 0;
                    while (!success && retryCount < 10)
                    {
                        try
                        {
                            foreach (var item in enumerable)
                            {
                                var element = InspectAndCopy(item, null, null, currentDepth, maxDepth, configuration,
                                                             objectTree, path, ignorePropertiesOrPaths);
                                addMethod.Invoke(newObject, new[] { element });
                            }

                            success = true;
                        }
                        catch (InvalidOperationException)
                        {
                            // if the collection was modified during enumeration, stop re-initialize and retry
                            success = false;
                            retryCount++;
                            var clearMethod = typeSupport.Type.GetMethod("Clear");
                            clearMethod?.Invoke(newObject, null);
                        }
                    }
                    if (!success)
                    {
                        throw new CloneException($"Error cloning IEnumerable at path '{path}'. Ensure the object is not modified while cloning data utilizing thread-safe access.");
                    }
                }

                return(newObject);
            }

            // clone an arrays' elements
            if (typeSupport.IsArray)
            {
                var sourceArray = sourceObject as Array;
                var newArray    = newObject as Array;

                // performance optimization, value typed primitive arrays can be block copied
                if (typeSupport.ElementType.IsPrimitive)
                {
                    var bytesPerValue = GetBytesPerValue(typeSupport.ElementType);
                    try
                    {
                        Buffer.BlockCopy(sourceArray, 0, newArray, 0, sourceArray.Length * bytesPerValue);
                    }
                    catch (Exception ex)
                    {
                        throw new CloneException($"Error block copying array at path '{path}'", ex);
                    }
                }
                else
                {
                    // copy each array element and clone the value
                    var arrayRank       = newArray.Rank;
                    var arrayDimensions = new List <int>();
                    for (var dimension = 0; dimension < arrayRank; dimension++)
                    {
                        arrayDimensions.Add(newArray.GetLength(dimension));
                    }
                    var flatRowIndex = 0;
                    foreach (var row in sourceArray)
                    {
                        var newElement = InspectAndCopy(row, null, null, currentDepth, maxDepth, configuration, objectTree, path, ignorePropertiesOrPaths);
                        // performance optimization, skip dimensional processing if it's a 1d array
                        if (arrayRank > 1)
                        {
                            // this is an optimized multi-dimensional array reconstruction
                            // based on the formula: indices.Add((i / (arrayDimensions[arrayRank - 1] * arrayDimensions[arrayRank - 2] * arrayDimensions[arrayRank - 3] * arrayDimensions[arrayRank - 4] * arrayDimensions[arrayRank - 5])) % arrayDimensions[arrayRank - 6]);
                            var indices = new List <int>();
                            for (var r = 1; r <= arrayRank; r++)
                            {
                                var multi = 1;
                                for (var p = 1; p < r; p++)
                                {
                                    multi *= arrayDimensions[arrayRank - p];
                                }
                                var b = (flatRowIndex / multi) % arrayDimensions[arrayRank - r];
                                indices.Add(b);
                            }
                            indices.Reverse();
                            // set element of multi-dimensional array
                            newArray.SetValue(newElement, indices.ToArray());
                        }
                        else
                        {
                            // set element of 1d array
                            newArray.SetValue(newElement, flatRowIndex);
                        }
                        flatRowIndex++;
                    }
                }
                return(newArray);
            }

            if (typeSupport.IsExpression)
            {
                // utilize MemberwiseClone for expressions
                try
                {
                    var newExpression = _memberwiseCloneMethod.Invoke(sourceObject, null);
                    return(newExpression);
                }
                catch (Exception ex)
                {
                    throw new CloneException($"Error cloning expression with type '{typeSupport.FullName}' at path '{path}'", ex);
                }
            }

            var fields    = typeSupport.Fields.Where(x => !x.IsConstant && !x.IsStatic);
            var rootPath  = path;
            var localPath = string.Empty;
            // clone and recurse fields
            foreach (var field in fields)
            {
                localPath = $"{rootPath}.{field.Name}";
                // optimization to disable ignores by attribute if configured
                //System.Diagnostics.Debug.WriteLine($"Copying {localPath}");
                if (_hasIgnoreConfiguration.Value)
                {
                    if (IgnoreObjectName(field.Name, localPath, configuration, ignorePropertiesOrPaths, configuration.IgnorePropertiesWithAttributes.Count > 0 ? field.CustomAttributes : null))
                    {
                        continue;
                    }
                    // also check the property for ignore, if this is a auto-backing property
                    if (field.BackedProperty != null && IgnoreObjectName(field.BackedProperty.Name, $"{rootPath}.{field.BackedPropertyName}", configuration, ignorePropertiesOrPaths, configuration.IgnorePropertiesWithAttributes.Count > 0 ? field.BackedProperty.CustomAttributes : null))
                    {
                        continue;
                    }
                }
#if FEATURE_DISABLE_SET_INITONLY
                // we can't duplicate init-only fields since .net core 3.0+
                // make use of IL to get around this limitation
                if (field.FieldInfo.IsInitOnly && configuration.AllowCloningOfReadOnlyEntities)
                {
                    try
                    {
                        var updateFieldValue = sourceObject.GetFieldValue(field);
                        var updater          = GetWriterForField(field);
                        updater(ref newObject, updateFieldValue);
                    }
                    catch (Exception ex)
                    {
                        throw new CloneException($"Failed to set field value named '{field.Name}' at path '{path}' using IL DynamicMethod", ex);
                    }
                    continue;
                }
#endif
                // only copy readonly fields if we allow as such
                if (field.FieldInfo.IsInitOnly && !configuration.AllowCloningOfReadOnlyEntities)
                {
                    continue;
                }

                // utilize reflection
                var fieldTypeSupport = field.Type;
                var fieldValue       = sourceObject.GetFieldValue(field);
                var destinationField = newObject.GetField(field.Name, true);
                // does this field exist on the destination object with the same type?
                if (destinationField != null && destinationField.FieldType == field.FieldInfo.FieldType)
                {
                    if (fieldTypeSupport.IsValueType || fieldTypeSupport.IsImmutable)
                    {
                        SetFieldValue(newObject, destinationField, fieldValue, localPath);
                    }
                    else if (fieldValue != null)
                    {
                        var clonedFieldValue = InspectAndCopy(fieldValue, null, null, currentDepth, maxDepth,
                                                              configuration, objectTree, localPath, ignorePropertiesOrPaths);
                        SetFieldValue(newObject, destinationField, clonedFieldValue, localPath);
                    }
                }
            }

            return(newObject);
        }