Matthieu MEZIL

I love .Net

This Blog

Abonnements

Search

Actualités

English blog

EDM Designer

Navigation

Bloggeurs Winwise

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

- [Refactoring] ReSharper pour Visual Studio 2010 (Preview) par Thomas Jaskula le il y a 59 minutes

- [Refactoring] Analyser vos exceptions avec ReSharper Exceptional par Thomas Jaskula le il y a 2 heures et 13 minutes

- SharePoint 2007 : patterns & practices SharePoint Guidance par Philippe Sentenac [MVP SharePoint] le il y a 15 heures et 52 minutes

- [Visual Studio 2010] Les tests cases c’est bien, mais je vais devoir tout réécrire ? par Etienne Margraff le il y a 16 heures et 49 minutes

- MVP[Gribouillon].AddYear par The Grib's Lair [Sébastien PICAMELOT - MVP SharePoint] le il y a 17 heures et 4 minutes

- Clinique INSIA - Projet de fin d’Etudes (Silverlight 3 MVVM et OutOfBrowser, WCF, TFS) - Part 1 par David REI le 07-02-2009, 23:38

- C’est la crise ? Bah pourquoi cramer du budget pub alors ? par Nix's Blog le 07-02-2009, 15:31

- Soyons MVP ! par TheSaib .NET blog le 07-02-2009, 12:15

- SharePoint : Gestion des Erreurs 6398, 7076 et 6482 par Blog Technique de Romelard Fabrice le 07-02-2009, 11:53

- EF avec WPF par Matthieu MEZIL le 07-02-2009, 10:18