我让我的存储库能够开始事务，然后将 TransactionCommand 传递给所有相关的存储库。一旦最终存储库完成更新，我就会提交它。这样，我仍然可以使用现有的存储库（基本上每个模型/实体一个），而无需编写临时/自定义查询。
我只希望我自己的模型/实体实现存储库接口，而不是为每个接口定义一个单独的存储库。前者将允许多态存储库操作，而后者则不允许。生活和燃烧。
这里是事务存储库的用法，该方法取自 Entity1Service 类（我的服务层，每个实体一个类，包含使用一个或多个存储库来完成某些目标的静态方法）
public class Entity1Service
{
public static bool WriteEntity1(Entity1 entity1)
{
Entity1RepositorySQLite sqlRepo = new Entity1RepositorySQLite();
sqlRepo.BeginTransaction();
int entity1Id;
if (!LocalIdService.ReadAndIncrementEntity1Id(out entity1Id, sqlRepo.TransactionCommand))
{
sqlRepo.RollbackTransaction();
return false;
}
int entity1IdOld = entity1.Id;
try
{
IdMapService.CreateMapEntity1Id(entity1Id, entity1Id, sqlRepo.TransactionCommand);
entity1.Id = entity1Id;
sqlRepo.Write(attachment);
}
catch (Exception)
{
sqlRepo.RollbackTransaction();
attachment.Entity1Id = attachmentIdOld;
throw;
}
sqlRepo.EndTransaction();
return true;
}
}
存储库定义
public interface ITransaction
{
SqliteCommand TransactionCommand { get; set; }
bool InTransaction { get; }
void BeginTransaction();
void RollbackTransaction();
void CloseTransaction();
void EndTransaction();
}
public class RepositorySQLiteTransactional<T> : RepositorySQLite<T>, ITransaction where T : new()
{
public RepositorySQLiteTransactional(IDataMapperSQLite<T, string[]> dataMapper) : base(dataMapper) { }
public RepositorySQLiteTransactional(IDataMapperSQLite<T, string[]> dataMapper, SqliteCommand transactionCommand) : this(dataMapper)
{
_dbLayer.DblTransactionCommand = transactionCommand;
}
public SqliteCommand TransactionCommand
{
get { return (SqliteCommand)_dbLayer.DblTransactionCommand; }
set
{
_dbLayer.DblTransactionCommand = value;
}
}
public bool InTransaction
{
get { return _dbLayer.DblInTransaction; }
}
public void BeginTransaction()
{
try
{
_dbLayer.DblBeginTransaction();
}
catch( Exception )
{
_dbLayer.DblCloseTransaction();
throw;
}
}
public void RollbackTransaction()
{
_dbLayer.DblRollbackTransaction();
}
public void CloseTransaction()
{
_dbLayer.DblCloseTransaction();
}
public void EndTransaction()
{
_dbLayer.DblEndTransaction();
}
}
public interface IRepository<T>
{
List<T> Read(IConditions conditions);
T FindOne(IQuery query);
List<T> FindAll(IQuery query);
void WriteOne(T obj);
void WriteOne(T obj, out int newId);
void WriteOne(IQuery query);
void WriteAll(List<T> objs);
void UpdateOne(T obj);
void UpdateAll(List<T> objs);
void UpdateOne(IQuery query);
void ReplaceAll(List<T> objs);
void DeleteAll();
void DeleteAll(List<T> objs);
//void Add(T entity);
//void Delete(T entity);
//void Edit(T entity);
//void Save();
}
public class RepositorySQLite<T> : IRepository<T> where T : new()
{
protected AndroidDB _dbLayer;
protected IDataMapperSQLite<T, string[]> _dataMapper;
private RepositorySQLite() // force data mapper init
{
}
public RepositorySQLite(IDataMapperSQLite<T, string[]> dataMapper)
{
}
public List<T> Read(IConditions conditions) { throw new NotImplementedException(); }
public void WriteOne(T obj, out int newId) { throw new NotImplementedException(); }
public void WriteOne(IQuery query) { throw new NotImplementedException(); }
private void ClearMapState()
{
}
public void ReplaceAll(List<T> objs)
{
}
public void WriteAll(List<T> objList)
{
}
public void WriteOne(T obj)
{
}
public void UpdateOne(T obj)
{
}
public void UpdateAll(List<T> objs)
{
}
public void UpdateOne(IQuery query)
{
}
public T FindOne(IQuery query)
{
}
public List<T> FindAll(IQuery query)
{
}
public void DeleteAll(List<T> objs)
{
}
public void DeleteAll()
{
}
public void DeleteAll( IQuery query )
{
}
}