Marco de la entidad objeto separado de la fusión

Question

Tengo un escenario donde estoy usando un marco de entidad en un servicio WCF, y los cambios ocurren en una instancia que no se puede rastrear de un tipo que se asigna a la base de datos a través de código: primero (actualizaciones no triviales y eliminan en todo el Árbol de objeto de la instancia). Cuando intento adjuntar la instancia no seguida en el contexto, EF solo reconoce los cambios en los tipos de valores simples en el objeto raíz.

¿Alguien sabe de una solución elegante para este escenario? Estoy buscando una forma de hacer esto usando un repositorio genérico y evitando tener que correr a través de todo el árbol de objetos de la instancia que administra el estado "Adjuntar / separar" de cada objeto. He considerado posiblemente usando el corral de valor o automóvil para ejecutar los cambios en una instancia totalmente hidratada y rastreada del estado "antiguo" para que el contexto retire los cambios. Además, ¿cómo manejaría la situación de NHIBERNATE esta situación?

¡Gracias de antemano por su entrada!

update (7/31/2012): He actualizado el código para manejar las claves genéricas escritas, y algunos problemas de escritura con los proxies EF. También se agregaron algunas extensiones auxiliares cuando se ocupan de los tipos de ientity. Esta implementación no es perfecta, pero es muy funcional.

Actualizar (3/13/2012): He agregado una solicitud de función para la fusión limpia en EF. La solicitud se encuentra aquí: http://data.uservoice.com/forums/72025-ado-net-entity-framework-ef-feature-suggestions/suggestions/2679160-better-merging-change-tracking

update (3/12/2012): He publicado mi solución a continuación. Utiliza fubuucore , valiniinjer , y requiere que las entidades se marcarán con una de las dos interfaces , ya sea ientity , o irecursiveentity para clases recursivas. La solución manejará entidades recursivas y autosuidos.

También, estoy haciendo referencia a un repositorio genérico (repositorio) que me permite obtener una referencia al IDBSET que EF expone. Esto podría ser sustituido con cualquier otro repositorio genérico o específico. Por último, la interfaz de ientity usa un INT? Sin embargo, la identificación podría definir que como quieras (GUID / GUID?). La solución en sí misma no es tan elegante como me gustaría, sin embargo, permite un código de acceso de datos mucho más elegante cuando está detrás de un límite de servicio de WCF físico.

public class DomainMergeInjection : ConventionInjection
{
    private readonly Repository _repository;
    private readonly Dictionary<string, object> _potentialParentObjectDump;
    private readonly Cache<Type, Type> _entityTypesAndKeysCache;

    public DomainMergeInjection(Repository repository)
    {
        _repository = repository;
        _potentialParentObjectDump = new Dictionary<string, object>();
        _entityTypesAndKeysCache = new Cache<Type, Type>();
    }

    protected override bool Match(ConventionInfo c)
    {
        return c.SourceProp.Name == c.TargetProp.Name;
    }

    protected override object SetValue(ConventionInfo c)
    {
        if(c.SourceProp.Value == null)
            return null;

        //for value types and string just return the value as is 
        if(c.SourceProp.Type.IsSimple())
            return c.SourceProp.Value;

        //TODO: Expand on this to handle IList/IEnumerable (i.e. the non-generic collections and arrays).
        //handle arrays
        if(c.SourceProp.Type.IsArray)
        {
            var sourceArray = c.SourceProp.Value as Array;
            // ReSharper disable PossibleNullReferenceException
            var clonedArray = sourceArray.Clone() as Array;
            // ReSharper restore PossibleNullReferenceException

            for(int index = 0; index < sourceArray.Length; index++)
            {
                var sourceValueAtIndex = sourceArray.GetValue(index);

                //Skip null and simple values that would have already been moved in the clone.
                if(sourceValueAtIndex == null || sourceValueAtIndex.GetType().IsSimple())
                    continue;

                // ReSharper disable PossibleNullReferenceException
                clonedArray.SetValue(RetrieveComplexSourceValue(sourceValueAtIndex), index);
                // ReSharper restore PossibleNullReferenceException
            }

            return clonedArray;
        }

        //handle IEnumerable<> also ICollection<> IList<> List<>
        if(c.SourceProp.Type.IsGenericEnumerable())
        {
            var t = c.SourceProp.Type.GetGenericArguments()[0];

            if(t.IsSimple())
                return c.SourceProp.Value;

            var tlist = typeof(List<>).MakeGenericType(t);
            dynamic list = Activator.CreateInstance(tlist);

            var addMethod = tlist.GetMethod("Add");

            foreach(var sourceItem in (IEnumerable)c.SourceProp.Value)
            {
                addMethod.Invoke(list, new[] { RetrieveComplexSourceValue(sourceItem) });
            }

            return list;
        }

        //Get a source value that is in the right state and is tracked if needed.
        var itemStateToInject = RetrieveComplexSourceValue(c.SourceProp.Value);
        return itemStateToInject;
    }

    private object RetrieveComplexSourceValue(object source)
    {
        //If the source is a non-tracked type, or the source is a new value, then return its value.
        if(!source.ImplementsIEntity(_entityTypesAndKeysCache) || source.IsEntityIdNull(_entityTypesAndKeysCache))
            return source;

        object sourceItemFromContext;

        //Handle recursive entities, this could probably be cleaned up.
        if(source.ImplementsIRecursiveEntity())
        {
            var itemKey = source.GetEntityIdString(_entityTypesAndKeysCache) + " " + ObjectContext.GetObjectType(source.GetType());

            //If we have a context item for this key already, just return it.  This solves a recursion problem with self-linking items.
            if(_potentialParentObjectDump.ContainsKey(itemKey))
                return _potentialParentObjectDump[itemKey];

            //Get the source from the context to ensure it is tracked.
            sourceItemFromContext = GetSourceItemFromContext(source);

            //Add the class into the object dump in order to avoid any infinite recursion issues with self-linked objects
            _potentialParentObjectDump.Add(itemKey, sourceItemFromContext);
        }
        else
            //Get the source from the context to ensure it is tracked.
            sourceItemFromContext = GetSourceItemFromContext(source);

        //Recursively use this injection class instance to inject the source state on to the context source state.
        var itemStateToInject = sourceItemFromContext.InjectFrom(this, source);

        return itemStateToInject;
    }

    private object GetSourceItemFromContext(object source)
    {
        if(source == null)
            return null;

        //Using dynamic here to "AutoCast" to an IEntity<>.  We should have one, but it's important to note just in case.
        dynamic sourceEntityValue = source;
        var sourceEntityType = ObjectContext.GetObjectType(source.GetType());
        var sourceKeyType = sourceEntityType.GetEntityKeyType();

        var method = typeof(DomainMergeInjection).GetMethod("GetFromContext", BindingFlags.Instance | BindingFlags.NonPublic);
        var generic = method.MakeGenericMethod(sourceEntityType, sourceKeyType);

        var sourceItemFromContext = generic.Invoke(this, new object[] { new object[] { sourceEntityValue.Id } });
        return sourceItemFromContext;
    }

    // ReSharper disable UnusedMember.Local
    private TItem GetFromContext<TItem, TKey>(object[] keys) where TItem : class, IEntity<TKey>
    // ReSharper restore UnusedMember.Local
    {
        var foundItem = _repository.GetDbSet<TItem>().Find(keys);

        return foundItem;
    }
}

public static class EntityTypeExtensions
{
    /// <summary>
    /// Determines if an object instance implements IEntity.
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="entityCache">A cache to hold types that do implement IEntity.  If the cache does not have the Type and the Type does implement IEntity, it will add the type to the cache along with the </param>
    /// <returns></returns>
    public static bool ImplementsIEntity(this object entity, Cache<Type, Type> entityCache = null)
    {
        //We need to handle getting the proxy type if this is an EF Code-First proxy.
        //Please see for more info: http://msdn.microsoft.com/en-us/library/dd456853.aspx
        var entityType = ObjectContext.GetObjectType(entity.GetType());

        if(entityCache != null && entityCache.Has(entityType))
            return true;

        var implementationOfIEntity = entityType.GetInterfaces().FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof (IEntity<>));

        if(implementationOfIEntity == null)
            return false;

        if(entityCache != null)
        {
            var keyType = implementationOfIEntity.GetGenericArguments()[0];
            entityCache.Fill(entityType, keyType);
        }

        return true;
    }

    /// <summary>
    /// Determines if an object instances implements IRecurisveEntity
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    public static bool ImplementsIRecursiveEntity(this object entity)
    {
        //We need to handle getting the proxy type if this is an EF Code-First proxy.
        //Please see for more info: http://msdn.microsoft.com/en-us/library/dd456853.aspx
        var entityType = ObjectContext.GetObjectType(entity.GetType());

        var implementsIRecursiveEntity = entityType.GetInterfaces().Any(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IRecursiveEntity<>));

        return implementsIRecursiveEntity;
    }

    /// <summary>
    /// Determines whether or not an Entity's Id is null.  Will throw an exception if a type that does not implement IEntity is passed through.
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="entityCache"></param>
    /// <returns></returns>
    public static bool IsEntityIdNull(this object entity, Cache<Type, Type> entityCache = null)
    {
        bool isEntityIdNull = ExecuteEntityIdMethod<bool>("IsEntityIdNull", entity, entityCache);

        return isEntityIdNull;
    }

    /// <summary>
    /// Determines whether or not an Entity's Id is null.  Will throw an exception if a type that does not implement IEntity is passed through.
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="entityCache"></param>
    /// <returns></returns>
    public static string GetEntityIdString(this object entity, Cache<Type, Type> entityCache = null)
    {
        string entityIdString = ExecuteEntityIdMethod<string>("GetEntityIdString", entity, entityCache);

        return entityIdString;
    }

    private static T ExecuteEntityIdMethod<T>(string methodName, object entityInstance, Cache<Type, Type> entityCache = null)
    {
        if(!entityInstance.ImplementsIEntity(entityCache))
            throw new ArgumentException(string.Format("Parameter entity of type {0} does not implement IEntity<>, and so ist not executable for {1}!", entityInstance.GetType(), methodName));

        //We need to handle getting the proxy type if this is an EF Code-First proxy.
        //Please see for more info: http://msdn.microsoft.com/en-us/library/dd456853.aspx
        var entityType = ObjectContext.GetObjectType(entityInstance.GetType());
        var keyType = entityCache != null ? entityCache[entityType] : entityType.GetEntityKeyType();

        var method = typeof(EntityTypeExtensions).GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic);
        var generic = method.MakeGenericMethod(keyType);

        T returnValue = (T)generic.Invoke(null, new[] { entityInstance });

        return returnValue;
    }

    private static string GetEntityIdString<TKey>(IEntity<TKey> entity)
    {
        var entityIdString = entity.Id.ToString();

        return entityIdString;
    }

    private static bool IsEntityIdNull<TKey>(IEntity<TKey> entity)
    {
        //We need to handle getting the proxy type if this is an EF Code-First proxy.
        //Please see for more info: http://msdn.microsoft.com/en-us/library/dd456853.aspx
        var entityType = ObjectContext.GetObjectType(entity.GetType());

        if(entityType.IsPrimitive)
            return false;

        //NOTE:  We know that this entity's type is NOT primitive, therefore we can cleanly test for null, and return properly.
        // ReSharper disable CompareNonConstrainedGenericWithNull
        var entityIdIsNull = entity.Id == null;
        // ReSharper restore CompareNonConstrainedGenericWithNull

        return entityIdIsNull;
    }

    public static Type GetEntityKeyType(this Type typeImplementingIEntity)
    {
        var implementationOfIEntity = typeImplementingIEntity.GetInterfaces().FirstOrDefault(x => x.IsGenericType && x.GetGenericTypeDefinition() == typeof(IEntity<>));

        if(implementationOfIEntity == null)
            throw new ArgumentException(string.Format("Type {0} does not implement IEntity<>", typeImplementingIEntity));

        var keyType = implementationOfIEntity.GetGenericArguments()[0];
        return keyType;
    }
}

public interface IEntity<TKey>
{
    TKey Id { get; set; }
}


public interface IRecursiveEntity<TKey> : IEntity<TKey>
{
    IRecursiveEntity<TKey> Parent { get; }
    IEnumerable<IRecursiveEntity<TKey>> Children { get; }
}

Answer 1

Podría usar el objeto separado solo como una DTO,

y después de rellenar el objeto del contexto con valores de la DTO

con el valorinigrio Esto sería:

//manually
conObj.InjectFrom(dto);
conObj.RefTypeProp.InjectFrom(dto.RefTypeProp);
...

//or by writing a custom injection:
conObj.InjectFrom<ApplyChangesInjection>(dto);

Aquí está la inyección que lo hará automáticamente, (lo hice modificando un poco la inyección de gloclone de la página de inicio de VI)

El truco aquí es que la inyección se usa en sí misma en el método SETVALUE

public class ApplyChangesInjection : ConventionInjection
{
    protected override bool Match(ConventionInfo c)
    {
        return c.SourceProp.Name == c.TargetProp.Name;
    }

    protected override object SetValue(ConventionInfo c)
    {
        if (c.SourceProp.Value == null) return null;

        //for value types and string just return the value as is
        if (c.SourceProp.Type.IsValueType || c.SourceProp.Type == typeof(string))
            return c.SourceProp.Value;

        //handle arrays - not impl
        //handle IEnumerable<> also ICollection<> IList<> List<> - not impl

        //for simple object types apply the inject using the corresponding source

        return c.TargetProp.Value
            .InjectFrom<ApplyChangesInjection>(c.SourceProp.Value);
    }
}

// Nota: No estoy manejando colecciones en esta inyección, solo quería que entendieras el principio, Puede mirar el original http://valueinjer.codeplex.com/wikipage?title= Profundo% 20Cloning & referenceTitle= Home