Matthieu MEZIL

This Blog

Abonnements

Search

Actualités

follow me on Facebook
follow me on Twitter

English blog

Navigation

Entity cloner

La méthode ApplyPropertyChanges d'ObjectContext est très pratique, elle permet d'enregistrer des modifications apportées sur une entité sans que celle-ci soit rattaché à un ObjectContext. Cette méthode prend deux paramètres : l'entité dans son état initial et l'entité dans son état courant.

Pour conserver l'état initial, il serait intéressant d'avoir une méthode Clone.

ApplyPropertyChanges ne prend pas en compte les propriétés relationnelle, cependant, nous verrons dans un post à venir comment contourner cela, au moins pour les EntityReference.

Donc il va fallois cloner nos entités. Immédiatement, cela me fait penser à la reflection. Le problème de la reflection c'est que c'est lent. Ceux qui ont l'habitude de lire mon blog ont dû comprendre, je vais générer un délégué à la volée afin de ne faire de la reflection qu'une seule fois et d'utiliser du code fortement typé par la suite.

Pour des raisons évidentes de facilité, nous allons définir une extension method Clone :

public static class EntityObjectExtension
{
    public static T Clone<T>(this T entityObject) where T : EntityObject, new()
    {
        return EntityCloner<T>.Clone(entityObject);
    }
}
public static class EntityCloner<T>
    where T : EntityObject, new()
{
    private static bool AllowCloneProperty(PropertyInfo pi)
    {
        return !(typeof(EntityObject).IsAssignableFrom(pi.PropertyType) ||
            pi.PropertyType.IsGenericType && pi.PropertyType.GetGenericTypeDefinition() == typeof(EntityCollection<>));
    }
    public static T Clone(T entityObject)
    {
        Cloner<T>.ClonePropertyDelegate = (pi) => AllowCloneProperty(pi);
        return Cloner<T>.Clone(entityObject);
    }
}
public static class Cloner<T>
    where T : class, new()
{
    private static Func<T, T> _cloneDelegate;
    private static Func<PropertyInfo, bool> _clonePropertyDelegate;
 
    private static Func<T, T> CloneDelegate
    {
        get
        {
            if (_cloneDelegate == null)
                _cloneDelegate = GenerateCloneMethod().CreateDelegate(typeof(Func<T, T>)) as Func<T, T>;
            return _cloneDelegate;
        }
    }
 
    public static Func<PropertyInfo, bool> ClonePropertyDelegate
    {
        get { return _clonePropertyDelegate; }
        set
        {
            if (_clonePropertyDelegate != value)
            {
                _clonePropertyDelegate = value;
                _cloneDelegate = null;
            }
        }
    }
 
    private static DynamicMethod GenerateCloneMethod()
    {
        var dynamicMethod = new DynamicMethod("Clone", typeof(T), new Type[] { typeof(T) });
        var cloneIlGenerator = dynamicMethod.GetILGenerator();
        var value = cloneIlGenerator.DeclareLocal(typeof(T));
        cloneIlGenerator.Emit(OpCodes.Ldarg_0);
        var argNotNullLabel = cloneIlGenerator.DefineLabel();
        cloneIlGenerator.Emit(OpCodes.Brtrue_S, argNotNullLabel);
        cloneIlGenerator.Emit(OpCodes.Ldnull);
        cloneIlGenerator.Emit(OpCodes.Ret);
        cloneIlGenerator.MarkLabel(argNotNullLabel);
        cloneIlGenerator.Emit(OpCodes.Newobj, typeof(T).GetConstructor(new Type[0]));
        cloneIlGenerator.Emit(OpCodes.Stloc_S, value);
        CopyProps(cloneIlGenerator, value, typeof(T), () => cloneIlGenerator.Emit(OpCodes.Ldarg_0));
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, value);
        cloneIlGenerator.Emit(OpCodes.Ret);
        return dynamicMethod;
    }
 
    private static void CopyProps(ILGenerator cloneIlGenerator, LocalBuilder lb, Type typeT, Action getSource)
    {
        foreach (var prop in typeT.GetProperties().Where(p => p.CanRead && p.CanWrite && (ClonePropertyDelegate == null || ClonePropertyDelegate(p))))
        {
            if (typeof(ComplexObject).IsAssignableFrom(prop.PropertyType))
            {
                ConstructorInfo complexObjectCtor = prop.PropertyType.GetConstructor(new Type[0]);
                if (complexObjectCtor != null)
                {
                    cloneIlGenerator.Emit(OpCodes.Ldloc_S, lb);
                    var sourceComplexTypeProp = cloneIlGenerator.DeclareLocal(prop.PropertyType);
                    var valueComplexTypeProp = cloneIlGenerator.DeclareLocal(prop.PropertyType);
                    getSource();
                    cloneIlGenerator.Emit(OpCodes.Callvirt, typeT.GetMethod("get_" + prop.Name));
                    cloneIlGenerator.Emit(OpCodes.Stloc_S, sourceComplexTypeProp);
                    cloneIlGenerator.Emit(OpCodes.Newobj, complexObjectCtor);
                    cloneIlGenerator.Emit(OpCodes.Stloc_S, valueComplexTypeProp);
                    cloneIlGenerator.Emit(OpCodes.Ldloc_S, valueComplexTypeProp);
                    cloneIlGenerator.Emit(OpCodes.Callvirt, typeT.GetMethod("set_" + prop.Name));
                    CopyProps(cloneIlGenerator, valueComplexTypeProp, prop.PropertyType, () => cloneIlGenerator.Emit(OpCodes.Ldloc, sourceComplexTypeProp));
                }
            }
            else if (prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(EntityReference<>))
                CopyEntityReference(cloneIlGenerator, () => cloneIlGenerator.Emit(OpCodes.Ldloc, lb), typeT, getSource, prop, false);
            else
            {
                cloneIlGenerator.Emit(OpCodes.Ldloc_S, lb);
                getSource();
                cloneIlGenerator.Emit(OpCodes.Callvirt, typeT.GetMethod("get_" + prop.Name));
                cloneIlGenerator.Emit(OpCodes.Callvirt, typeT.GetMethod("set_" + prop.Name));
            }
        }
    }
 
    internal static void CopyEntityReference(ILGenerator cloneIlGenerator, Action loadNewObject, Type typeT, Action getSource, PropertyInfo prop, bool copyNull)
    {
        var sourceEntityReferenceEntityKeyProp = cloneIlGenerator.DeclareLocal(typeof(EntityKey));
        var sourceEntityReferenceEntityKeyMemberProp = cloneIlGenerator.DeclareLocal(typeof(EntityKeyMember));
        var sourceEntityReferenceEntityKeysMemberProp = cloneIlGenerator.DeclareLocal(typeof(EntityKeyMember[]));
        var sourceEntityReferenceEntityKeysMemberLength = cloneIlGenerator.DeclareLocal(typeof(int));
        var valueEntityReferenceProp = cloneIlGenerator.DeclareLocal(prop.PropertyType);
        var valueEntityReferenceEntityKeyProp = cloneIlGenerator.DeclareLocal(typeof(EntityKey));
        var valueEntityReferenceEntityKeysMemberProp = cloneIlGenerator.DeclareLocal(typeof(EntityKeyMember[]));
        var loopIndex = cloneIlGenerator.DeclareLocal(typeof(int));
        loadNewObject();
        cloneIlGenerator.Emit(OpCodes.Newobj, prop.PropertyType.GetConstructor(new Type[0]));
        cloneIlGenerator.Emit(OpCodes.Stloc_S, valueEntityReferenceProp);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, valueEntityReferenceProp);
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeT.GetMethod("set_" + prop.Name));
        getSource();
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeT.GetMethod("get_" + prop.Name));
        cloneIlGenerator.Emit(OpCodes.Callvirt, prop.PropertyType.GetMethod("get_EntityKey"));
        cloneIlGenerator.Emit(OpCodes.Stloc_S, sourceEntityReferenceEntityKeyProp);
        var entityKeyNullLabel = cloneIlGenerator.DefineLabel();
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeyProp);
        cloneIlGenerator.Emit(OpCodes.Brfalse, entityKeyNullLabel);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, valueEntityReferenceProp);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeyProp);
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeof(EntityKey).GetMethod("get_EntityKeyValues")); // We suppose EntityKeyValues is not null
        cloneIlGenerator.Emit(OpCodes.Stloc_S, sourceEntityReferenceEntityKeysMemberProp);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeysMemberProp);
        cloneIlGenerator.Emit(OpCodes.Ldlen);
        cloneIlGenerator.Emit(OpCodes.Conv_I4);
        cloneIlGenerator.Emit(OpCodes.Stloc_S, sourceEntityReferenceEntityKeysMemberLength);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeysMemberLength);
        cloneIlGenerator.Emit(OpCodes.Newarr, typeof(EntityKeyMember));
        cloneIlGenerator.Emit(OpCodes.Stloc_S, valueEntityReferenceEntityKeysMemberProp);
        var noEntityKeyValues = cloneIlGenerator.DefineLabel();
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeysMemberLength);
        cloneIlGenerator.Emit(OpCodes.Brfalse_S, noEntityKeyValues);
        cloneIlGenerator.Emit(OpCodes.Ldc_I4_0);
        cloneIlGenerator.Emit(OpCodes.Stloc_S, loopIndex);
        var startLoopLabel = cloneIlGenerator.DefineLabel();
        cloneIlGenerator.MarkLabel(startLoopLabel);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, loopIndex);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeysMemberLength);
        cloneIlGenerator.Emit(OpCodes.Ceq);
        var endOfLoopLable = cloneIlGenerator.DefineLabel();
        cloneIlGenerator.Emit(OpCodes.Brtrue_S, endOfLoopLable);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeysMemberProp);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, loopIndex);
        cloneIlGenerator.Emit(OpCodes.Ldelem_Ref);
        cloneIlGenerator.Emit(OpCodes.Stloc_S, sourceEntityReferenceEntityKeyMemberProp);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, valueEntityReferenceEntityKeysMemberProp);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, loopIndex);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeyMemberProp);
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeof(EntityKeyMember).GetMethod("get_Key"));
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeyMemberProp);
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeof(EntityKeyMember).GetMethod("get_Value"));
        cloneIlGenerator.Emit(OpCodes.Newobj, typeof(EntityKeyMember).GetConstructor(new Type[] { typeof(string), typeof(object) }));
        cloneIlGenerator.Emit(OpCodes.Stelem_Ref);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, loopIndex);
        cloneIlGenerator.Emit(OpCodes.Ldc_I4_1);
        cloneIlGenerator.Emit(OpCodes.Add);
        cloneIlGenerator.Emit(OpCodes.Stloc_S, loopIndex);
        cloneIlGenerator.Emit(OpCodes.Br, startLoopLabel);
        cloneIlGenerator.MarkLabel(endOfLoopLable);
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, sourceEntityReferenceEntityKeyProp);
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeof(EntityKey).GetMethod("get_EntityContainerName"));
        cloneIlGenerator.Emit(OpCodes.Ldstr, ".");
        cloneIlGenerator.Emit(OpCodes.Ldloc, sourceEntityReferenceEntityKeyProp);
        cloneIlGenerator.Emit(OpCodes.Callvirt, typeof(EntityKey).GetMethod("get_EntitySetName"));
        cloneIlGenerator.Emit(OpCodes.Call, typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) })); // We suppose EntityContainerName and EntitySetName aren't null
        cloneIlGenerator.Emit(OpCodes.Ldloc_S, valueEntityReferenceEntityKeysMemberProp);
        cloneIlGenerator.Emit(OpCodes.Newobj, typeof(EntityKey).GetConstructor(new Type[] { typeof(string), typeof(IEnumerable<EntityKeyMember>) }));
        var noEntityKeyValuesEnd = cloneIlGenerator.DefineLabel();
        cloneIlGenerator.Emit(OpCodes.Br_S, noEntityKeyValuesEnd);
        cloneIlGenerator.MarkLabel(noEntityKeyValues);
        cloneIlGenerator.Emit(OpCodes.Newobj, typeof(EntityKey).GetConstructor(new Type[0]));
        cloneIlGenerator.MarkLabel(noEntityKeyValuesEnd);
        cloneIlGenerator.Emit(OpCodes.Callvirt, prop.PropertyType.GetMethod("set_EntityKey"));
        if (copyNull)
        {
            var endCopyReferenceLabel = cloneIlGenerator.DefineLabel();
            cloneIlGenerator.Emit(OpCodes.Br_S, endCopyReferenceLabel);
            cloneIlGenerator.MarkLabel(entityKeyNullLabel);
            cloneIlGenerator.Emit(OpCodes.Ldloc, valueEntityReferenceProp);
            cloneIlGenerator.Emit(OpCodes.Ldnull);
            cloneIlGenerator.Emit(OpCodes.Callvirt, typeof(T).GetMethod("set_" + prop.Name));
            cloneIlGenerator.MarkLabel(endCopyReferenceLabel);
        }
        else
            cloneIlGenerator.MarkLabel(entityKeyNullLabel);
    }
 
    public static T Clone(T obj)
    {
        return CloneDelegate(obj);
    }
}

Ce post vous a plu ? Ajoutez le dans vos favoris pour ne pas perdre de temps à le retrouver le jour où vous en aurez besoin :

Publié vendredi 16 mai 2008 00:17 par Matthieu MEZIL

Classé sous : .Net, ADO, Entity Framework (EF), IL

Commentaires

Pas de commentaires

Les commentaires anonymes sont désactivés

Les 10 derniers blogs postés

- Merci par Blog de Jérémy Jeanson le 10-01-2019, 20:47

- Office 365: Script PowerShell pour auditer l’usage des Office Groups de votre tenant par Blog Technique de Romelard Fabrice le 04-26-2019, 11:02

- Office 365: Script PowerShell pour auditer l’usage de Microsoft Teams de votre tenant par Blog Technique de Romelard Fabrice le 04-26-2019, 10:39

- Office 365: Script PowerShell pour auditer l’usage de OneDrive for Business de votre tenant par Blog Technique de Romelard Fabrice le 04-25-2019, 15:13

- Office 365: Script PowerShell pour auditer l’usage de SharePoint Online de votre tenant par Blog Technique de Romelard Fabrice le 02-27-2019, 13:39

- Office 365: Script PowerShell pour auditer l’usage d’Exchange Online de votre tenant par Blog Technique de Romelard Fabrice le 02-25-2019, 15:07

- Office 365: Script PowerShell pour auditer le contenu de son Office 365 Stream Portal par Blog Technique de Romelard Fabrice le 02-21-2019, 17:56

- Office 365: Script PowerShell pour auditer le contenu de son Office 365 Video Portal par Blog Technique de Romelard Fabrice le 02-18-2019, 18:56

- Office 365: Script PowerShell pour extraire les Audit Log basés sur des filtres fournis par Blog Technique de Romelard Fabrice le 01-28-2019, 16:13

- SharePoint Online: Script PowerShell pour désactiver l’Option IRM des sites SPO non autorisés par Blog Technique de Romelard Fabrice le 12-14-2018, 13:01