Organizational Research By

Surprising Reserch Topic

how to de attach an entity from a context in entity framework


how to de attach an entity from a context in entity framework  using -'asp.net,entity-framework,entity-framework-4,repository-pattern'

I use EF 4.1 with Repository and DbContext.. POCO with T4 template.
For every Repository I use a separate DbContext.

I need to update an object with has a related property, at the moment I receive this error

An entity object cannot be referenced by multiple instances of IEntityChangeTracker.


I suppose my problem is beacuse eventObj and candidate are created from different Repositories.

So i'm trying to solve the problem with this code, with no success.

My question?


How do I get rid of this error?
Is is possible remove the candidate from its context?

public void UpdateAddingCandidate(Event eventObj, Candidate candidate){
    Event updatedEvent = new Event();
    Candidate updatedCandidate = new Candidate();
    updatedEvent = eventObj;
    updatedCandidate = candidate;
    updatedEvent.Candidate = updatedCandidate;
    db.Entry(updatedEvent).State = EntityState.Modified;     
}



EDIT

    public void UpdateAddingCandidate(Event eventObj, Candidate candidate)
    {
        /*
        db.Events.AsNoTracking();
        db.Candidates.AsNoTracking();
        */
        db.Entry(eventObj).State = EntityState.Detached;
        db.Entry(candidate).State = EntityState.Detached;

        Event updatedEvent = new Event();
        Candidate updatedCandidate = new Candidate();
        updatedEvent = eventObj;
        updatedCandidate = candidate;
        updatedEvent.Candidate = updatedCandidate;
        db.Entry(updatedEvent).State = EntityState.Detached;
        db.Entry(updatedEvent).State = EntityState.Modified;

    }

    

asked Sep 22, 2015 by akhilesh
0 votes
21 views



Related Hot Questions

3 Answers

0 votes

This error is indeed thrown when the entity you're trying to update is attached to a different objectcontext than the context you're using to update it. Only one objectcontext can track an entity

You can detach objects from it's context by calling:

where context is the context the entity currently is attached to.

using (var context = new UnicornsContext())
{
    var unicorn = new Unicorn { Name = "Franky", PrincessId = 1};
    context.Entry(unicorn).State = EntityState.Detached;
    context.SaveChanges();
}

http://blogs.msdn.com/b/adonet/archive/2011/01/29/using-dbcontext-in-ef-feature-ctp5-part-4-add-attach-and-entity-states.aspx

And in your implementation:

public void UpdateAddingCandidate(Event eventObj, Candidate candidate)
{
    db.Entry(candidate).State = EntityState.Detached;
    db.SaveChanges();

    eventObj.Candidate = candidate;
    db.Entry(eventObj).State = EntityState.Modified;
    db.SaveChanges();
}
answered Sep 22, 2015 by akasati02
0 votes

Why do you create new instance of Event and Candidate? You could just change the state of these you already have them. If you share the same instance of ObjectContext accross your repositories, you can try to resolve these entities from context with ObjectStateManager.GetObjectStateEntry(string key) ObjectStateManager.

answered Sep 22, 2015 by dhananjayksharma
0 votes

Instead of only using the repository pattern also use the Unit of Work pattern. That way you have 1 point for every entity you use.

Data/Contracts/IRepository.cs

namespace Data.Contracts
{
    public interface IRepository where T : class
    {
        IQueryable GetAll();
        T GetById(int id);
        void Add(T entity);
        void Update(T entity);
        void Delete(T entity);
        void Delete(int id);
}

Data/Contracts/IUnitOfWork.cs

namespace Data.Contracts
{
    /// 
    /// Interface for the "Unit of Work"
    /// 
    public interface IUnitOfWork
    {
        // Save pending changes to the data store.
        void Commit();

        // Repositories
        IRepository Events { get; }
        IRepository Candidates { get; }
    }
}

Data/EFRepository.cs

using System;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;
using System.Linq;
using Data.Contracts;

namespace Data
{
    /// 
    /// The EF-dependent, generic repository for data access
    /// 
    /// Type of entity for this Repository.
    public class EFRepository : IRepository where T : class
    {
        public EFRepository(DbContext dbContext)
        {
            if (dbContext == null)
                throw new ArgumentNullException("dbContext");
            DbContext = dbContext;
            DbSet = DbContext.Set();
        }

        protected DbContext DbContext { get; set; }

        protected DbSet DbSet { get; set; }

        public virtual IQueryable GetAll()
        {
            return DbSet;
        }

        public virtual T GetById(int id)
        {
            //return DbSet.FirstOrDefault(PredicateBuilder.GetByIdPredicate(id));
            return DbSet.Find(id);
        }

        public virtual void Add(T entity)
        {
            DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
            if (dbEntityEntry.State != EntityState.Detached)
            {
                dbEntityEntry.State = EntityState.Added;
            }
            else
            {
                DbSet.Add(entity);
            }
        }

        public virtual void Update(T entity)
        {
            DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
            if (dbEntityEntry.State == EntityState.Detached)
            {
                DbSet.Attach(entity);
            }
            dbEntityEntry.State = EntityState.Modified;
        }

        public virtual void Delete(T entity)
        {
            DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
            if (dbEntityEntry.State != EntityState.Deleted)
            {
                dbEntityEntry.State = EntityState.Deleted;
            }
            else
            {
                DbSet.Attach(entity);
                DbSet.Remove(entity);
            }
        }

        public virtual void Delete(int id)
        {
            var entity = GetById(id);
            if (entity == null) return; // not found; assume already deleted.
            Delete(entity);
        }
    }
}

Data/UnitOfWork.cs

using System;
using Data.Contracts;
using Data.Helpers;
using Models;

namespace Data
{
    /// 
    /// The "Unit of Work"
    ///     1) decouples the repos from the controllers
    ///     2) decouples the DbContext and EF from the controllers
    ///     3) manages the UoW
    /// 
    /// 
    /// This class implements the "Unit of Work" pattern in which
    /// the "UoW" serves as a facade for querying and saving to the database.
    /// Querying is delegated to "repositories".
    /// Each repository serves as a container dedicated to a particular
    /// root entity type such as a .
    /// A repository typically exposes "Get" methods for querying and
    /// will offer add, update, and delete methods if those features are supported.
    /// The repositories rely on their parent UoW to provide the interface to the
    /// data layer (which is the EF DbContext in this example).
    /// 
    public class UnitOfWork : IUnitOfWork, IDisposable
    {
        public UnitOfWork(IRepositoryProvider repositoryProvider)
        {
            CreateDbContext();

            repositoryProvider.DbContext = DbContext;
            RepositoryProvider = repositoryProvider;       
        }

        // Repositories
        public IRepository Events { get { return GetStandardRepo(); } }
        public IRepository Candidates { get { return GetStandardRepo(); } }

        /// 
        /// Save pending changes to the database
        /// 
        public void Commit()
        {
            //System.Diagnostics.Debug.WriteLine("Committed");
            DbContext.SaveChanges();
        }

        protected void CreateDbContext()
        {
            DbContext = new UnicornsContext();

            // Do NOT enable proxied entities, else serialization fails
            DbContext.Configuration.ProxyCreationEnabled = false;

            // Load navigation properties explicitly (avoid serialization trouble)
            DbContext.Configuration.LazyLoadingEnabled = false;

            // Because Web API will perform validation, I don't need/want EF to do so
            DbContext.Configuration.ValidateOnSaveEnabled = false;
        }

        protected IRepositoryProvider RepositoryProvider { get; set; }

        private IRepository GetStandardRepo() where T : class
        {
            return RepositoryProvider.GetRepositoryForEntityType();
        }
        private T GetRepo() where T : class
        {
            return RepositoryProvider.GetRepository();
        }

        private UnicornsContext DbContext { get; set; }

        #region IDisposable

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (DbContext != null)
                {
                    DbContext.Dispose();
                }
            }
        }

        #endregion
    }
}

Data/Helpers/IRepositoryProvider.cs

using System;
using System.Data.Entity;
using Data.Contracts;

namespace Data.Helpers
{
    /// 
    /// Interface for a class that can provide repositories by type.
    /// The class may create the repositories dynamically if it is unable
    /// to find one in its cache of repositories.
    /// 
    /// 
    /// Repositories created by this provider tend to require a 
    /// to retrieve data.
    /// 
    public interface IRepositoryProvider
    {
        /// 
        /// Get and set the  with which to initialize a repository
        /// if one must be created.
        /// 
        DbContext DbContext { get; set; }

        /// 
        /// Get an  for entity type, T.
        /// 
        /// 
        /// Root entity type of the .
        /// 
        IRepository GetRepositoryForEntityType() where T : class;

        /// 
        /// Get a repository of type T.
        /// 
        /// 
        /// Type of the repository, typically a custom repository interface.
        /// 
        /// 
        /// An optional repository creation function that takes a 
        /// and returns a repository of T. Used if the repository must be created.
        /// 
        /// 
        /// Looks for the requested repository in its cache, returning if found.
        /// If not found, tries to make one with the factory, fallingback to 
        /// a default factory if the factory parameter is null.
        /// 
        T GetRepository(Func factory = null) where T : class;


        /// 
        /// Set the repository to return from this provider.
        /// 
        /// 
        /// Set a repository if you don't want this provider to create one.
        /// Useful in testing and when developing without a backend
        /// implementation of the object returned by a repository of type T.
        /// 
        void SetRepository(T repository);
    }
}

Data/Helpers/RepositoryProvider.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using Data.Contracts;

namespace Data.Helpers
{
    /// 
    /// Provides an  for a client request.
    /// 
    /// 
    /// Caches repositories of a given type so that repositories are only created once per provider.
    /// There should be a a new provider per client request.
    /// 
    public class RepositoryProvider : IRepositoryProvider
    {
        public RepositoryProvider(RepositoryFactories repositoryFactories)
        {
            _repositoryFactories = repositoryFactories;
            Repositories = new Dictionary();
        }

        /// 
        /// Get and set the  with which to initialize a repository
        /// if one must be created.
        /// 
        public DbContext DbContext { get; set; }

        /// 
        /// Get or create-and-cache the default  for an entity of type T.
        /// 
        /// 
        /// Root entity type of the .
        /// 
        /// 
        /// If can't find repository in cache, use a factory to create one.
        /// 
        public IRepository GetRepositoryForEntityType() where T : class
        {
            return GetRepository>(
                _repositoryFactories.GetRepositoryFactoryForEntityType());
        }

        /// 
        /// Get or create-and-cache a repository of type T.
        /// 
        /// 
        /// Type of the repository, typically a custom repository interface.
        /// 
        /// 
        /// An optional repository creation function that takes a DbContext argument
        /// and returns a repository of T. Used if the repository must be created and
        /// caller wants to specify the specific factory to use rather than one
        /// of the injected .
        /// 
        /// 
        /// Looks for the requested repository in its cache, returning if found.
        /// If not found, tries to make one using .
        /// 
        public virtual T GetRepository(Func factory = null) where T : class
        {
            // Look for T dictionary cache under typeof(T).
            object repoObj;
            Repositories.TryGetValue(typeof(T), out repoObj);
            if (repoObj != null)
            {
                return (T)repoObj;
            }

            // Not found or null; make one, add to dictionary cache, and return it.
            return MakeRepository(factory, DbContext);
        }

        /// 
        /// Get the dictionary of repository objects, keyed by repository type.
        /// 
        /// 
        /// Caller must know how to cast the repository object to a useful type.
        /// 

This is an extension point. You can register fully made repositories here /// and they will be used instead of the ones this provider would otherwise create.

///
protected Dictionary Repositories { get; private set; } /// Make a repository of type T. /// Type of repository to make. /// /// The with which to initialize the repository. /// /// /// Factory with argument. Used to make the repository. /// If null, gets factory from . /// /// protected virtual T MakeRepository(Func factory, DbContext dbContext) { var f = factory ?? _repositoryFactories.GetRepositoryFactory(); if (f == null) { throw new NotImplementedException("No factory for repository type, " + typeof(T).FullName); } var repo = (T)f(dbContext); Repositories[typeof(T)] = repo; return repo; } /// /// Set the repository for type T that this provider should return. /// /// /// Plug in a custom repository if you don't want this provider to create one. /// Useful in testing and when developing without a backend /// implementation of the object returned by a repository of type T. /// public void SetRepository(T repository) { Repositories[typeof(T)] = repository; } /// /// The with which to create a new repository. /// /// /// Should be initialized by constructor injection /// private RepositoryFactories _repositoryFactories; } }

Data/Helpers/RepositoryFactories.cs

using System;
using System.Collections.Generic;
using System.Data.Entity;
using Data.Contracts;

namespace Data.Helpers
{
    /// 
    /// A maker of Repositories.
    /// 
    /// 
    /// An instance of this class contains repository factory functions for different types.
    /// Each factory function takes an EF  and returns
    /// a repository bound to that DbContext.
    /// 
    /// Designed to be a "Singleton", configured at web application start with
    /// all of the factory functions needed to create any type of repository.
    /// Should be thread-safe to use because it is configured at app start,
    /// before any request for a factory, and should be immutable thereafter.
    /// 
    /// 
    public class RepositoryFactories
    {
        /// 
        /// Return the runtime repository factory functions,
        /// each one is a factory for a repository of a particular type.
        /// 
        /// 
        /// MODIFY THIS METHOD TO ADD CUSTOM FACTORY FUNCTIONS
        /// 
        private IDictionary> GetFactories()
        {
            return new Dictionary>
                {
                   //If you have an custom implementation of an IRepository
                   //{typeof(IArticleRepository), dbContext => new ArticleRepository(dbContext)}
                };
        }

        /// 
        /// Constructor that initializes with runtime repository factories
        /// 
        public RepositoryFactories()
        {
            _repositoryFactories = GetFactories();
        }

        /// 
        /// Constructor that initializes with an arbitrary collection of factories
        /// 
        /// 
        /// The repository factory functions for this instance. 
        /// 
        /// 
        /// This ctor is primarily useful for testing this class
        /// 
        public RepositoryFactories(IDictionary> factories)
        {
            _repositoryFactories = factories;
        }

        /// 
        /// Get the repository factory function for the type.
        /// 
        /// Type serving as the repository factory lookup key.
        /// The repository function if found, else null.
        /// 
        /// The type parameter, T, is typically the repository type 
        /// but could be any type (e.g., an entity type)
        /// 
        public Func GetRepositoryFactory()
        {

            Func factory;
            _repositoryFactories.TryGetValue(typeof(T), out factory);
            return factory;
        }

        /// 
        /// Get the factory for  where T is an entity type.
        /// 
        /// The root type of the repository, typically an entity type.
        /// 
        /// A factory that creates the , given an EF .
        /// 
        /// 
        /// Looks first for a custom factory in .
        /// If not, falls back to the .
        /// You can substitute an alternative factory for the default one by adding
        /// a repository factory for type "T" to .
        /// 
        public Func GetRepositoryFactoryForEntityType() where T : class
        {
            return GetRepositoryFactory() ?? DefaultEntityRepositoryFactory();
        }

        /// 
        /// Default factory for a  where T is an entity.
        /// 
        /// Type of the repository's root entity
        protected virtual Func DefaultEntityRepositoryFactory() where T : class
        {
            return dbContext => new EFRepository(dbContext);
        }

        /// 
        /// Get the dictionary of repository factory functions.
        /// 
        /// 
        /// A dictionary key is a System.Type, typically a repository type.
        /// A value is a repository factory function
        /// that takes a  argument and returns
        /// a repository object. Caller must know how to cast it.
        /// 
        private readonly IDictionary> _repositoryFactories;
    }
}

Now if you have this to use your UnitOfWork you can't simply call it because of all the dependencies, if you have used an IoC container before you know that you can simply resolve those dependencies. In my case I used Ninject so the code to set it up would be:

var kernel = new StandardKernel(); // Ninject IoC

kernel.Bind().To().InSingletonScope();
kernel.Bind().To();
kernel.Bind().To();

Then for your pages you can add a base page class:

Web.BasePage.cs

namespace Web
{
    public abstract class BasePage : System.Web.UI.Page
    {
        // NOT NECESSARY TO DISPOSE THE UOW IN OUR CONTROLLERS
        // Recall that we let IoC inject the Uow into our controllers
        // We can depend upon on IoC to dispose the UoW for us
        protected IUnitOfWork Uow { get; set; }
    }
}

Or in the case of MVC you can add a base controller:

Web/Controllers/BaseController.cs

using System.Web.Mvc;

namespace Site.Controllers
{
    public abstract class BaseController : Controller
    {
        // NOT NECESSARY TO DISPOSE THE UOW IN OUR CONTROLLERS
        // Recall that we let IoC inject the Uow into our controllers
        // We can depend upon on IoC to dispose the UoW for us
        protected IUnitOfWork Uow { get; set; }
    }
}

Then in your code when you want to access you entities it is very easy. You can simply call the UnitOfWork which is available in every page and access the different repositories in it. Because they all share the same DbContext your problem ceases to exist.


I have made a very simple example of the Unit of Work pattern with support of Ninject for the Inversion of Control.

In my example there is a ASP.NET Webforms AND and ASP.NET MVC4 example

The example is a single page site and every time you load the site it will add an Event to the example database and and Category to the Database, both with random names. (I needed something for the DB so I just made 2 simple pocos). After that the page will display everything in in both lists. Just look into the Mvc4/Controllers/HomeController.cs or WebForms/Default.aspx.cs.

Example on skydrive

answered Sep 22, 2015 by tejas lakhani

...