私のDataContextがオブジェクト（Unit Of Work）に対する変更をなぜ見ないのですか？

Question

私はUnitOfWorkとRepositoryパターンを使用するプロジェクトを設定しようとしています。

私はIoCとEF4を使うことができないので、私はLinqとDataContextを少しの依存関係で試しています:(私はすべての統合についてちょっと混乱しているこれらの概念。私は、DataContextは、オブジェクトに加えられた更新が表示されませんが、データベースに新しいエンティティを追加するたびに、私のコードのデバッグに気づいた。

私は多くを読んだが、

たとえば、私はfooというオブジェクトを持っています...私はfooRepositoryの新しいインスタンスを作成するfooコントローラを持っていますが、私はそれが単純なステップである可能性があります。 fooRepository私のUnitOfWorkへの参照を追加するそれはDataContextをラップします...そうですか？ は、ここに私のコード

public class ListaController : Controller 
{ 

    IListaRepository _listaRepository;  

    public ListaController() 
     : this(new ListaRepository()) { 
    } 

    public ListaController(IListaRepository repository) 
    { 
     _listaRepository = repository; 
    } 

    [HttpPost] 
    public ActionResult Edit(int id, Lista lista) 
    { 
     try 
     { 
      this._listaRepository.Save(lista); 
      return RedirectToAction("Index"); 

     } 
     catch 
     { 
      return View(); 
     } 
    } 
} 

    public class ListaRepository : LinqRepository<Lista>, IListaRepository 
    { 

    protected IUnitOfWork uow 
    { 
     get { return base.GetCurrentUnitOfWork<IUnitOfWork>(); } 
    } 

    public ListaRepository() 
     : base() 
    { 
    } 

    public override void Add(Lista lista) 
    { 
     this.uow.Context.Listas.InsertOnSubmit(lista); 
     this.uow.Commit(); 
    } 

    public override void Save(Lista lista) 
    { 
     Add(lista); 
    } 
    } 

    public static class UnitOfWork 
    { 
    private const string HTTPCONTEXTKEY = "Domain.HttpContext.Key"; 

    private static IUnitOfWorkFactory _unitOfWorkFactory; 
    private static readonly Hashtable _threads = new Hashtable(); 

    public static void Commit() 
    { 
     IUnitOfWork unitOfWork = GetUnitOfWork(); 
     if (unitOfWork != null) 
     { 
      unitOfWork.Commit(); 
     } 
    } 

    public static IUnitOfWork Current 
    { 
     get 
     { 
      IUnitOfWork unitOfWork = GetUnitOfWork(); 
      if (unitOfWork == null) 
      { 
       //Qui inserisco dipendenza in quanto non uso un IoC 
       //_unitOfWorkFactory = ObjectFactory.GetInstance<IUnitOfWorkFactory>(); 
       _unitOfWorkFactory = new LinqUnitOfWorkFactory(); 
       unitOfWork = _unitOfWorkFactory.Create(); 
       SaveUnitOfWork(unitOfWork); 
      } 
      return unitOfWork; 
     } 
    } 

    private static IUnitOfWork GetUnitOfWork() 
    { 
     if (HttpContext.Current != null) 
     { 
      if (HttpContext.Current.Items.Contains(HTTPCONTEXTKEY)) 
      { 
       return (IUnitOfWork)HttpContext.Current.Items[HTTPCONTEXTKEY]; 
      } 
      return null; 
     } 
     else 
     { 
      Thread thread = Thread.CurrentThread; 
      if (string.IsNullOrEmpty(thread.Name)) 
      { 
       thread.Name = Guid.NewGuid().ToString(); 
       return null; 
      } 
      else 
      { 
       lock (_threads.SyncRoot) 
       { 
        return (IUnitOfWork)_threads[Thread.CurrentThread.Name]; 
       } 
      } 
     } 
    } 

    private static void SaveUnitOfWork(IUnitOfWork unitOfWork) 
    { 
     if (HttpContext.Current != null) 
     { 
      HttpContext.Current.Items[HTTPCONTEXTKEY] = unitOfWork; 
     } 
     else 
     { 
      lock (_threads.SyncRoot) 
      { 
       _threads[Thread.CurrentThread.Name] = unitOfWork; 
      } 
     } 
    } 
    } 

public abstract class LinqRepository<T> : IRepository<T> where T : class 
{ 
    protected ManagerEmailDataContext _context = new ManagerEmailDataContext(); 

    protected ManagerEmailDataContext Context 
    { 
     get 
     { 
      if (_context == null) 
      { 
       _context = GetCurrentUnitOfWork<LinqUnitOfWork>().Context; 
      } 
      return _context; 
     } 
    } 

    public TUnitOfWork GetCurrentUnitOfWork<TUnitOfWork>() where TUnitOfWork : IUnitOfWork 
    { 
     return (TUnitOfWork)UnitOfWork.Current; 
    } 


    public abstract IQueryable<T> GetAll(); 
    public abstract void Add(T entity); 
    public abstract void Save(T entity); 
    public abstract T Get(int id); 
} 

protected void Application_Start() 
{ 
    AreaRegistration.RegisterAllAreas(); 
    RegisterGlobalFilters(GlobalFilters.Filters); 
    RegisterRoutes(RouteTable.Routes); 
    LinqUnitOfWorkFactory.SetDataContext(() => new ManagerEmailDataContext()); 
} 

public class LinqUnitOfWorkFactory : ManagerEmail.Models.IUnitOfWorkFactory 
{ 
    private static Func<ManagerEmailDataContext> _objectContextDelegate; 
    private static readonly Object _lockObject = new object(); 

    public static void SetDataContext(Func<ManagerEmailDataContext> objectDataContextDelegate) 
    { 
     _objectContextDelegate = objectDataContextDelegate; 
    } 

    public IUnitOfWork Create() 
    { 
     ManagerEmailDataContext context; 
     lock (_lockObject) 
     { 
      context = _objectContextDelegate(); 
     } 
     return new LinqUnitOfWork(context); 
    } 
}`enter code here` 

すべてのヘルプをか理解されるであろうことをお勧めです！

申し訳ありませんすべてのコードを投稿しても申し訳ありませんが、このことで狂っているのは約1週間です。

Answer 1

問題はLINQに関連しています。私のコントローラで私はSave（Tエンティティ）メソッドを呼び出し、私のリポジトリには

public override void Save(Lista lista) 
{ 
    Lista original = CloneEntity<Lista>(this.Get(lista.Id)); 
    this._uow = new LinqUnitOfWorkFactory().Create(); //I must renew the DataContext 
    this._uow.Context.Listas.Attach(lista, original); 
    this._uow.Context.Refresh(RefreshMode.KeepChanges, lista); 
    this._uow.Commit(); 
} 

internal static T CloneEntity<T>(T originalEntity) 
{ 
    Type entityType = typeof(T); 
    DataContractSerializer ser = new DataContractSerializer(entityType); 
    using (MemoryStream ms = new MemoryStream()) 
    { 
     ser.WriteObject(ms, originalEntity); 
     ms.Position = 0; 
     return (T)ser.ReadObject(ms); 
    } 
} 

これは誰かを助けてくれることを願っています。

Answer 2

DataContext.SubmitChanges()とはどこに電話がありませんか。あなたの作業単位Commit()メソッドは、dbに変更を保存するために、ある時点でそれを呼び出す必要があります。