工作+库模式PetaPoco +单位 [英] PetaPoco + unit of work + repository pattern

问题描述

下面的代码似乎用这个工作：

  VAR unitOfWorkProvider =新PetaPocoUnitOfWorkProvider（）; 
变种库=新FakeRepository（）; 
变种假=假新
 {
 //等
}; 
 
使用（VAR UOW = unitOfWorkProvider.GetUnitOfWork（BlaConnectionString））
 {
 repository.Insert（UOW，假）; 
 uow.Commit（）; 
} 
  

这最终可能会移动到服务层。我将不胜感激任何反馈，以提高该代码。

  public接口IUnitOfWork：IDisposable的
 {
无效提交（）; 
数据库数据库{搞定; } 
} 
 
公共接口IUnitOfWorkProvider 
 {
 IUnitOfWork GetUnitOfWork（字符串的connectionString）; 
} 
 
公共类PetaPocoUnitOfWorkProvider：IUnitOfWorkProvider 
 {
公共IUnitOfWork GetUnitOfWork（字符串的connectionString）
 {
返回新PetaPocoUnitOfWork（的connectionString）; 
} 
} 
 
公共接口IRepository< T> 
 {
无效插入（IUnitOfWork的UnitOfWork，T实体）; 
无效更新（IUnitOfWork的UnitOfWork，T实体）; 
无效删除（IUnitOfWork的UnitOfWork，T实体）; $ B $（B T）取（IUnitOfWork的UnitOfWork，长UID）; 
} 
 
公共类PetaPocoUnitOfWork：IUnitOfWork 
 {
私人只读交易_petaTransaction; 
私人只读数据库_database; 
 
公共PetaPocoUnitOfWork（字符串的connectionString）
 {
 _database =新的数据库（的connectionString）; 
 _petaTransaction =新交易（_database）; 
} 
 
公共无效的Dispose（）
 {
 _petaTransaction.Dispose（）; 
} 
 
公共数据库数据库
 {
 {返回_database; } 
} 
 
公共无效提交（）
 {
 _petaTransaction.Complete（）; 
} 
} 
 
公共类FakeRepository：IRepository<&假GT; 
 {
公共无效插入（IUnitOfWork的UnitOfWork，假实体）
 {
 unitOfWork.Database.Save（实体）; 
} 
 
公共无效更新（IUnitOfWork的UnitOfWork，假实体）
 {
 unitOfWork.Database.Update（实体）; 
} 
 
公共无效删除（IUnitOfWork的UnitOfWork，假实体）
 {
 unitOfWork.Database.Delete（实体）; 
} 
 
公共FakeJobFact取（IUnitOfWork的UnitOfWork，长UID）
 {
返回unitOfWork.Database.Fetch<假>（SELECT * FROM假货WHERE [FakeId ] = @ 0时，UID）.FirstOrDefault（）; 
} 
} 
  

PS：

我照着@Plebsori目前的答案改编代码：

 公共抽象类BaseRepository< T> 
 {
保护数据库了IDatabase 
 {
得到
 {
返回UnitOfWork.Current; 
} 
} 
 
公共无效插入（T实体）
 {
 Database.Save（实体）; 
} 
 
公共无效更新（T实体）
 {
 Database.Update（实体）; 
} 
 
公共无效删除（T实体）
 {
 Database.Delete（实体）; 
} 
} 
 
公共接口IRepository< T> 
 {
无效插入（T实体）; 
无效更新（T实体）; 
无效删除（T实体）; $ B $（B T）获取（长UID）; 
} 
 
公共接口IUnitOfWork：IDisposable的
 {
无效提交（）; 
数据库数据库{搞定; } 
} 
 
公共接口IUnitOfWorkProvider 
 {
 IUnitOfWork GetUnitOfWork（字符串的connectionString）; 
} 
 
公共类PetaPocoUnitOfWork：IUnitOfWork 
 {
私人只读交易_petaTransaction; 
私人只读数据库_database; 
 
公共PetaPocoUnitOfWork（字符串的connectionString）
 {
 _database =新的数据库（的connectionString）; 
 _petaTransaction =新交易（_database）; 
} 
 
公共无效的Dispose（）
 {
 UnitOfWork.Current = NULL; 
 _petaTransaction.Dispose（）; 
} 
 
公共数据库数据库
 {
 {返回_database; } 
} 
 
公共无效提交（）
 {
 _petaTransaction.Complete（）; 
} 
} 
 
公共类PetaPocoUnitOfWorkProvider：IUnitOfWorkProvider 
 {
公共IUnitOfWork GetUnitOfWork（字符串的connectionString）
 {
如果（ ！UnitOfWork.Current = NULL）
 {
抛出新的InvalidOperationException异常（「现有的工作单位。）; 
} 
 
变种petaPocoUnitOfWork =新PetaPocoUnitOfWork（的connectionString）; 
 UnitOfWork.Current = petaPocoUnitOfWork.Database; 
返回petaPocoUnitOfWork; 
} 
} 
 
公共静态类的UnitOfWork 
 {
 [ThreadStatic]公共静态电流了IDatabase; 
} 
  

解决方案

您可能会或可能不喜欢，但这里就是我如何删除工作单位，从界面的工作单元的传递。

  VAR unitOfWorkProvider =新PetaPocoUnitOfWorkProvider （）; 
变种库=新FakeRepository（）; 
变种假=假新
 {
 //等
}; 
 
使用（VAR UOW = unitOfWorkProvider.GetUnitOfWork（BlaConnectionString））
 {
 repository.Insert（假的）; 
 uow.Commit（）; 
} 
  

代码

 公共接口IUnitOfWorkProvider 
 {
 IUnitOfWork GetUnitOfWork（字符串的connectionString）; 
} 
 
公共静态类的UnitOfWork 
 {
 [ThreadStatic] 
公共静态IUnitOfWork当前{搞定;组; } 
} 
 
公共类PetaPocoUnitOfWorkProvider：IUnitOfWorkProvider 
 {
公共IUnitOfWork GetUnitOfWork（字符串的connectionString）
 {
如果（UnitOfWork.Current！ = NULL）
 {
抛出新的InvalidOperationException异常（「现有的工作单位。）; 
} 
 UnitOfWork.Current =新PetaPocoUnitOfWork（的connectionString）; 
返回UnitOfWork.Current; 
} 
} 
 
公共接口IRepository< T> 
 {
无效插入（T实体）; 
无效更新（T实体）; 
无效删除（T实体）; $ B $（B T）获取（长UID）; 
} 
 
公共类PetaPocoUnitOfWork：IUnitOfWork 
 {
私人只读交易_petaTransaction; 
私人只读数据库_database; 
 
公共PetaPocoUnitOfWork（字符串的connectionString）
 {
 _database =新的数据库（的connectionString）; 
 _petaTransaction =新交易（_database）; 
} 
 
公共无效的Dispose（）
 {
 UnitOfWork.Current = NULL; 
 _petaTransaction.Dispose（）; 
} 
 
公共数据库数据库
 {
 {返回_database; } 
} 
 
公共无效提交（）
 {
 _petaTransaction.Complete（）; 
} 
} 
 
公共抽象类BaseRepository< T> ：IRepository< T> 
 {
保护分贝了IDatabase 
 {
得到
 {
返回UnitOfWork.Current; 
} 
} 
} 
 
公共类FakeRepository：BaseRepository< T> 
 {
公共无效插入（假实体）
 {
 Db.Save（实体）; 
} 
 
公共无效更新（假实体）
 {
 Db.Update（实体）; 
} 
 
公共无效删除（假实体）
 {
 Db.Delete（实体）; 
} 
 
公共FakeJobFact获取（长UID）
 {
返回Db.Fetch<假>（SELECT * FROM假货WHERE [FakeId] = @ 0 ，UID）.FirstOrDefault（）; 
} 
} 
  

The code below seems to work using this:

var unitOfWorkProvider = new PetaPocoUnitOfWorkProvider();
var repository = new FakeRepository();
var fake = new Fake
{     
    // etc.
};

using (var uow = unitOfWorkProvider.GetUnitOfWork("BlaConnectionString"))
{
    repository.Insert(uow, fake);
    uow.Commit();
}

which may eventually move into a service layer. I would appreciate any feedback to improve this code.

public interface IUnitOfWork : IDisposable
{
    void Commit();
    Database Database { get; }
}

public interface IUnitOfWorkProvider
{
    IUnitOfWork GetUnitOfWork(string connectionString);
}

public class PetaPocoUnitOfWorkProvider : IUnitOfWorkProvider
{
    public IUnitOfWork GetUnitOfWork(string connectionString)
    {
        return new PetaPocoUnitOfWork(connectionString);
    }
}

public interface IRepository<T>
{
    void Insert(IUnitOfWork unitOfWork, T entity);
    void Update(IUnitOfWork unitOfWork, T entity);
    void Delete(IUnitOfWork unitOfWork, T entity);
    T Fetch(IUnitOfWork unitOfWork, long uid);
}

public class PetaPocoUnitOfWork : IUnitOfWork
{
    private readonly Transaction _petaTransaction;
    private readonly Database _database;

    public PetaPocoUnitOfWork(string connectionString)
    {
        _database = new Database(connectionString);
        _petaTransaction = new Transaction(_database);
    }

    public void Dispose()
    {
        _petaTransaction.Dispose();
    }

    public Database Database
    {
        get { return _database; }
    }

    public void Commit()
    {
        _petaTransaction.Complete();
    }
}

public class FakeRepository : IRepository<Fake>
{
    public void Insert(IUnitOfWork unitOfWork, Fake entity)
    {
        unitOfWork.Database.Save(entity);
    }

    public void Update(IUnitOfWork unitOfWork, Fake entity)
    {
        unitOfWork.Database.Update(entity);
    }

    public void Delete(IUnitOfWork unitOfWork, Fake entity)
    {
        unitOfWork.Database.Delete(entity);
    }

    public FakeJobFact Fetch(IUnitOfWork unitOfWork, long uid)
    {
        return unitOfWork.Database.Fetch<Fake>("SELECT * FROM Fakes WHERE [FakeId] = @0", uid).FirstOrDefault();
    }
}

PS:

I have adapted the code according to @Plebsori current answer:

public abstract class BaseRepository<T>
{
    protected IDatabase Database
    {
        get
        {
        return UnitOfWork.Current;
        }
    }

    public void Insert(T entity)
    {
        Database.Save(entity);
    }

    public void Update(T entity)
    {
        Database.Update(entity);
    }

    public void Delete(T entity)
    {
        Database.Delete(entity);
    }
}

public interface IRepository<T>
{
    void Insert(T entity);
    void Update(T entity);
    void Delete(T entity);
    T Fetch(long uid);
}

public interface IUnitOfWork : IDisposable
{
    void Commit();
    Database Database { get; }
}

public interface IUnitOfWorkProvider
{
    IUnitOfWork GetUnitOfWork(string connectionString);
}

public class PetaPocoUnitOfWork : IUnitOfWork
{
    private readonly Transaction _petaTransaction;
    private readonly Database _database;

    public PetaPocoUnitOfWork(string connectionString)
    {
        _database = new Database(connectionString);
        _petaTransaction = new Transaction(_database);
    }

    public void Dispose()
    {
        UnitOfWork.Current = null;
        _petaTransaction.Dispose();
    }

    public Database Database
    {
        get { return _database; }
    }

    public void Commit()
    {
        _petaTransaction.Complete();
    }
}

public class PetaPocoUnitOfWorkProvider : IUnitOfWorkProvider
{
    public IUnitOfWork GetUnitOfWork(string connectionString)
    {
        if (UnitOfWork.Current != null)
        {
        throw new InvalidOperationException("Existing unit of work.");
        }

        var petaPocoUnitOfWork = new PetaPocoUnitOfWork(connectionString);
        UnitOfWork.Current = petaPocoUnitOfWork.Database;
        return petaPocoUnitOfWork;
    }
}

public static class UnitOfWork
{
    [ThreadStatic] public static IDatabase Current;
}

解决方案

You may or may not like, but here's how I removed the passing of unit of work and the unit of work from the interface.

var unitOfWorkProvider = new PetaPocoUnitOfWorkProvider();
var repository = new FakeRepository();
var fake = new Fake
{     
    // etc.
};

using (var uow = unitOfWorkProvider.GetUnitOfWork("BlaConnectionString"))
{
    repository.Insert(fake);
    uow.Commit();
}

Code

public interface IUnitOfWorkProvider
{
    IUnitOfWork GetUnitOfWork(string connectionString);
}

public static class UnitOfWork
{
    [ThreadStatic]
    public static IUnitOfWork Current { get; set; }
}

public class PetaPocoUnitOfWorkProvider : IUnitOfWorkProvider
{
    public IUnitOfWork GetUnitOfWork(string connectionString)
    {
        if (UnitOfWork.Current != null) 
        {
           throw new InvalidOperationException("Existing unit of work.");
        }
        UnitOfWork.Current = new PetaPocoUnitOfWork(connectionString);
        return UnitOfWork.Current;
    }
}

public interface IRepository<T>
{
    void Insert(T entity);
    void Update(T entity);
    void Delete(T entity);
    T Fetch(long uid);
}

public class PetaPocoUnitOfWork : IUnitOfWork
{
    private readonly Transaction _petaTransaction;
    private readonly Database _database;

    public PetaPocoUnitOfWork(string connectionString)
    {
        _database = new Database(connectionString);
        _petaTransaction = new Transaction(_database);
    }

    public void Dispose()
    {
        UnitOfWork.Current = null;
        _petaTransaction.Dispose();
    }

    public Database Database
    {
        get { return _database; }
    }

    public void Commit()
    {
        _petaTransaction.Complete();
    }
}

public abstract class BaseRepository<T> : IRepository<T>
{
    protected IDatabase Db
    {
        get
        {
            return UnitOfWork.Current;
        }
    }
}

public class FakeRepository : BaseRepository<T>
{
    public void Insert(Fake entity)
    {
        Db.Save(entity);
    }

    public void Update(Fake entity)
    {
        Db.Update(entity);
    }

    public void Delete(Fake entity)
    {
        Db.Delete(entity);
    }

    public FakeJobFact Fetch(long uid)
    {
        return Db.Fetch<Fake>("SELECT * FROM Fakes WHERE [FakeId] = @0", uid).FirstOrDefault();
    }
}

这篇关于工作+库模式PetaPoco +单位的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！