Linq 为什么我的DataContext没有'；看不到对象（工作单元）的更改吗？

我正在尝试建立一个使用UnitOfWork和Repository模式的项目

现在我不能使用IoC和EF4，所以我尝试使用Linq和DataContext，但有一点依赖：（.我并不掩饰我对所有这些概念的集成有点困惑。我注意到调试代码时DataContext没有看到对对象的更新，但每次它都会向数据库添加一个新实体

我已经读了很多，但我找不到我的问题，也许这是一个简单的步骤。在我继续之前，我有以下几点：

例如，我有一个名为foo的对象…我有一个foo控制器，它在构造函数中创建一个新的foorRepository实例。在foorRepository中，我添加了一个对我的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`

公共类ListaController:控制器
{
IListaRepository(列表存储);；
公共列表控制器（）
：此（新列表存储（））{
}
公共列表控制器（IListaRepository存储库）
{
_listaRepository=存储库；
}
[HttpPost]
公共操作结果编辑（int-id，Lista-Lista）
{
尝试
{
此._listaRepository.Save（lista）；
返回操作（“索引”）；
}
接住
{
返回视图（）；
}
}
}
公共类列表位置：LinqRepository、IListaRepository
{
受保护的工作单元uow
{
获取{return base.GetCurrentUnitOfWork（）；}
}
公开上市公司
：base（）
{
}
公共覆盖无效添加（Lista Lista）
{
this.uow.Context.Listas.InsertOnSubmit（lista）；
this.uow.Commit（）；
}
公共覆盖无效保存（Lista Lista）
{
添加（列表a）；
}
}
公共静态类UnitOfWork
{
私有常量字符串HTTPCONTEXTKEY=“Domain.HttpContext.Key”；
私有静态IUnitOfWorkFactory(联合工厂)；
私有静态只读哈希表_threads=new Hashtable（）；
公共静态void Commit（）
{
IUnitOfWork unitOfWork=GetUnitOfWork（）；
if（unitOfWork！=null）
{
unitOfWork.Commit（）；
}
}
公共静态工作电流
{
收到
{
IUnitOfWork unitOfWork=GetUnitOfWork（）；
如果（unitOfWork==null）
{
//Qui inserisco dipendenza在quanto非uso联合国国际奥委会
//_unitOfWorkFactory=ObjectFactory.GetInstance（）；
_unitOfWorkFactory=新的LinqUnitOfWorkFactory（）；
unitOfWork=\u unitOfWorkFactory.Create（）；
保存unitOfWork（unitOfWork）；
}
返回工作单元；
}
}
私有静态IUnitOfWork GetUnitOfWork（）
{
if（HttpContext.Current！=null）
{
if（HttpContext.Current.Items.Contains（HTTPCONTEXTKEY））
{
返回（IUnitOfWork）HttpContext.Current.Items[HTTPCONTEXTKEY]；
}
返回null；
}
其他的
{
Thread Thread=Thread.CurrentThread；
if（string.IsNullOrEmpty（thread.Name））
{
thread.Name=Guid.NewGuid（）.ToString（）；
返回null；
}
其他的
{
锁定（_threads.SyncRoot）
{
return（IUnitOfWork）_threads[Thread.CurrentThread.Name]；
}
}
}
}
私有静态void SaveUnitOfWork（IUnitOfWork unitOfWork）
{
if（HttpContext.Current！=null）
{
HttpContext.Current.Items[HTTPCONTEXTKEY]=工作单元；
}
其他的
{
锁定（_threads.SyncRoot）
{
_threads[Thread.CurrentThread.Name]=工作单元；
}
}
}
}
公共抽象类LinqRepository:IRepository，其中T:class
{
受保护的ManagerMailDataContext _context=new ManagerMailDataContext（）；
受保护的ManagerMailDataContext上下文
{
收到
{
if（_context==null）
{
_context=GetCurrentUnitOfWork（）.context；
}
返回上下文；
}
}
公共TunitoWork GetCurrentUnitOfWork（），其中TunitoWork:IUnitOfWork
{
返回（TUnitOfWork）UnitOfWork.Current；
}
公共抽象IQueryable GetAll（）；
公开摘要无效添加（T实体）；
公开摘要作废保存（T实体）；
公共摘要T-Get（int-id）；
}
受保护的无效应用程序\u Start（）
{
RegisterAllAreas（）；
RegisterGlobalFilters（GlobalFilters.Filters）；
注册地址（RouteTable.Routes）；
SetDataContext（（）=>newManagerMailDataContext（））；
}
公共类LinqUnitOfWorkFactory:ManagerEmail.Models.IUnitOfWorkFactory
{
私有静态函数objectContextDelegate；
私有静态只读对象_lockObject=新对象（）；
公共静态无效SetDataContext（Func objectDataContextDelegate）
{
_objectContextDelegate=objectDataContextDelegate；
}
公共IUnitOfWork创建（）
{
ManagerEmailDataContext；
锁定（锁定对象）
{
上下文=_objectContextDelegate（）；
}
返回新的LinqUnitOfWork（上下文）；
}
}`在这里输入代码`

任何帮助或建议都将不胜感激

---

抱歉，如果我发布了所有的代码，但是我已经花了大约一周的时间对这件事发疯了。

问题与LINQ有关。在我的控制器中，我调用Save（T entity）方法，在我的存储库中，我有

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);
   }
}

public覆盖无效保存（Lista Lista）
{
Lista original=CloneEntity（this.Get（Lista.Id））；
此._uow=new LinqUnitOfWorkFactory（）.Create（）；//我必须续订DataContext
此.uuow.Context.Listas.Attach（lista，原件）；
此._uow.Context.Refresh（RefreshM