public static T CloneObject <T>(T obj) { // this is faster than typeof(T).IsValueType if (obj is ValueType) { if (typeof(T) == obj.GetType()) { return(obj); } // we're here so, we clone value type obj as object type T // so, we need to copy it, bcs we have a reference, not real object. return((T)ShallowObjectCloner.CloneObject(obj)); } if (ReferenceEquals(obj, null)) { return((T)(object)null); } if (DeepClonerSafeTypes.CanReturnSameObject(obj.GetType())) { return(obj); } return((T)ShallowObjectCloner.CloneObject(obj)); }
private static object CloneClassRoot(object obj) { if (obj == null) { return(null); } // we can receive an poco objects which is faster to copy in shallow way if possible var type = obj.GetType(); // 200ms if (DeepClonerSafeTypes.IsClassSafe(type)) { return(ShallowObjectCloner.CloneObject(obj)); } // 350ms var cloner = (Func <object, DeepCloneState, object>)DeepClonerCache.GetOrAddClass(type, t => GenerateCloner(t, true)); if (cloner == null) { return(obj); } // 200ms return(cloner(obj, new DeepCloneState())); }
/// <summary> /// Purpose of this method is testing variants /// </summary> internal static void SwitchTo(bool isSafe) { DeepClonerCache.ClearCache(); if (isSafe) { _instance = new ShallowSafeObjectCloner(); } else { _instance = _unsafeInstance; } }
public static T CloneObject <T>(T obj) { // this is faster than typeof(T).IsValueType if (obj is ValueType) { if (typeof(T) == obj.GetType()) { return(obj); } } return((T)ShallowObjectCloner.CloneObject(obj)); }
private static object GenerateCloner(Type t, bool asObject) { #if !NETCORE if (ShallowObjectCloner.IsSafeVariant()) { return(DeepClonerExprGenerator.GenerateClonerInternal(t, asObject)); } else { return(DeepClonerMsilGenerator.GenerateClonerInternal(t, asObject)); } #else return(DeepClonerExprGenerator.GenerateClonerInternal(t, asObject)); #endif }
static ShallowObjectCloner() { #if !NETCORE _unsafeInstance = GenerateUnsafeCloner(); _instance = _unsafeInstance; try { _instance.DoCloneObject(new object()); } catch (Exception) { // switching to safe _instance = new ShallowSafeObjectCloner(); } #else _instance = new ShallowSafeObjectCloner(); // no unsafe variant for core _unsafeInstance = _instance; #endif }
private static object GenerateCloner(Type t, bool asObject) { if (DeepClonerSafeTypes.CanReturnSameObject(t) && (asObject && !t.IsValueType())) { return(null); } #if !NETCORE if (ShallowObjectCloner.IsSafeVariant()) { return(DeepClonerExprGenerator.GenerateClonerInternal(t, asObject)); } else { return(DeepClonerMsilGenerator.GenerateClonerInternal(t, asObject)); } #else return(DeepClonerExprGenerator.GenerateClonerInternal(t, asObject)); #endif }
private static object CloneClassRoot(object obj) { if (obj == null) { return(null); } Type type = obj.GetType(); if (DeepClonerSafeTypes.CanNotDeepCopyClass(type)) { return(ShallowObjectCloner.CloneObject(obj)); } Func <object, DeepCloneState, object> func = (Func <object, DeepCloneState, object>)DeepClonerCache.GetOrAddClass(type, (Type t) => GenerateCloner(t, true)); if (func == null) { return(obj); } return(func(obj, new DeepCloneState())); }
static ShallowObjectCloner() { _instance = new ShallowSafeObjectCloner(); _unsafeInstance = _instance; }