.net core - modello di repository generico dell'unità di lavoro
.net .net-core asp.net-core asp.net-core-2.1 entity-framework-core
Domanda
Sto cercando di migrare un grande progetto che raccoglie informazioni sui prodotti. L'applicazione corrente utilizza CSLA come sua struttura (forme tradizionali di aspx).
Sto cercando di migrare / sviluppare l'applicazione su .net core 2.1. Ho esperienza nello sviluppo in MVC (4+ anni) e qualche recente esposizione al nucleo .net.
Sto volendo usare EF Core per chiamare le stored procedure esistenti. Sto cercando di utilizzare il modello di progettazione del deposito generico di Unit of Work. Ho usato il modello di repository prima e l'ho trovato molto utile.
Come parte della funzionalità esistente all'interno del processo corrente, contiene una tabella Master e un formato di struttura tabella Edits. Quando qualcuno modifica un prodotto, una nuova riga viene inserita nella tabella Modifica. Una volta approvato da un amministratore, inserisce / aggiorna la riga corrente nella tabella Master.
L'utilizzo del modello "Unity of Work / repository generico" ha funzionato bene per altri sviluppatori all'interno di .net core 2.1?
Quali problemi hai incontrato? Il mio obiettivo è produrre un'applicazione guidata efficiente ad alte prestazioni.
Qualsiasi altro pensiero e suggerimento sono ben accetti. Grazie.
Risposta popolare
Personalmente, uso l'Unità di lavoro per ridurre molta l'iniezione di dipendenza. Posso avere un database Unità di lavoro e una volta che uso dipendenza Injection per iniettare il contesto del database in quell'unità di lavoro, non ho bisogno di iniettare ogni repository di modelli in cui voglio usarli, ma accederò ai repository dal unità di lavoro. Questo mi aiuta anche a creare un'istanza di un repository solo quando ne ho bisogno in un metodo specifico.
public interface IDatabaseUnitOfWork
{
DbContext DatabaseContext { get; }
Task<bool> Save();
IBaseRepository<UserAccount> UserAccountRepository { get; }
}
public class DatabaseUnitOfWork : IDatabaseUnitOfWork
{
private IBaseRepository<UserAccount> _userAccountRepository;
public DatabaseUnitOfWork(DbContext databaseContext)
{
DatabaseContext = databaseContext;
}
public DbContext DatabaseContext { get; private set; }
public async Task<bool> Save()
{
try
{
int _save = await DatabaseContext.SaveChangesAsync();
return await Task.FromResult(true);
}
catch (System.Exception e)
{
return await Task.FromResult(false);
}
}
public IBaseRepository<UserAccount> UserAccountRepository
{
get
{
if (_userAccountRepository == null)
{
_userAccountRepository = new BaseRepository<UserAccount>(DatabaseContext);
}
return _userAccountRepository;
}
}
}
Poi
services.AddScoped<IDatabaseUnitOfWork, DatabaseUnitOfWork>();
services.AddScoped<IServiceUnitOfWork, ServiceUnitOfWork>();
Finalmente
public class DemoClass
{
private IServiceUnitOfWork _serviceUnitOfWork;
public DemoClass(IServiceUnitOfWork serviceUnitOfWork)
{
_serviceUnitOfWork = serviceUnitOfWork;
}
Public bool CreateUserAccount(UserAccount userAccount){
await _serviceUnitOfWork.UserAccountRepository.Add(userAccount);
return await _serviceUnitOfWork.Save();
}
----
}
AGGIORNARE
REPOSITORY BASE GENERICO
public interface IBaseRepository<T> where T : class
{
Task<bool> Add(T entity);
Task<List<T>> GetAll();
Task<List<T>> GetAll(params Expression<Func<T, object>>[] includes);
Task<List<T>> SearchBy(Expression<Func<T, bool>> searchBy, params Expression<Func<T, object>>[] includes);
Task<T> FindBy(Expression<Func<T, bool>> predicate, params Expression<Func<T, object>>[] includes);
Task<bool> Update(T entity);
Task<bool> Delete(Expression<Func<T, bool>> identity, params Expression<Func<T, object>>[] includes);
Task<bool> Delete(T entity);
}
public class BaseRepository<T> : IBaseRepository<T> where T : class
{
private DbContext _ctx;
public BaseRepository(DbContext context)
{
_ctx = context;
}
public virtual async Task<bool> Add(T entity)
{
try
{
_ctx.Set<T>().Add(entity);
return await Task.FromResult(true);
}
catch (Exception e)
{
return await Task.FromResult(false);
}
}
public virtual async Task<List<T>> GetAll()
{
return _ctx.Set<T>().ToList();
}
public virtual async Task<List<T>> GetAll(params Expression<Func<T, object>>[] includes)
{
var result = _ctx.Set<T>().Where(i => true);
foreach (var includeExpression in includes)
result = result.Include(includeExpression);
return await result.ToListAsync();
}
public virtual async Task<List<T>> SearchBy(Expression<Func<T, bool>> searchBy, params Expression<Func<T, object>>[] includes)
{
var result = _ctx.Set<T>().Where(searchBy);
foreach (var includeExpression in includes)
result = result.Include(includeExpression);
return await result.ToListAsync();
}
/// <summary>
/// Finds by predicate.
/// http://appetere.com/post/passing-include-statements-into-a-repository
/// </summary>
/// <param name="predicate">The predicate.</param>
/// <param name="includes">The includes.</param>
/// <returns></returns>
public virtual async Task<T> FindBy(Expression<Func<T, bool>> predicate, params Expression<Func<T, object>>[] includes)
{
var result = _ctx.Set<T>().Where(predicate);
foreach (var includeExpression in includes)
result = result.Include(includeExpression);
return await result.FirstOrDefaultAsync();
}
public virtual async Task<bool> Update(T entity)
{
try
{
_ctx.Set<T>().Attach(entity);
_ctx.Entry(entity).State = EntityState.Modified;
return await Task.FromResult(true);
}
catch (Exception e)
{
return await Task.FromResult(false);
}
}
public virtual async Task<bool> Delete(Expression<Func<T, bool>> identity, params Expression<Func<T, object>>[] includes)
{
var results = _ctx.Set<T>().Where(identity);
foreach (var includeExpression in includes)
results = results.Include(includeExpression);
try
{
_ctx.Set<T>().RemoveRange(results);
return await Task.FromResult(true);
}
catch (Exception e)
{
return await Task.FromResult(false);
}
}
public virtual async Task<bool> Delete(T entity)
{
_ctx.Set<T>().Remove(entity);
return await Task.FromResult(true);
}
}
ESTENSIONE DEL REPOSITORY BASE (es. DeleteAllAccounts )
public interface IUserAccountRepository : IBaseRepository<UserAccount>
{
Task DeleteAllAccounts();
}
public class UserAccountRepository : BaseRepository<UserAccount>, IUserAccountRepository
{
private DbContext _databaseContext;
public UserAccountRepository(DbContext databaseContext) : base(databaseContext)
{
_databaseContext = databaseContext;
}
public async Task DeleteAllAccounts()
{
......
}
}
Quindi invece di usare _userAccountRepository = new BaseRepository<UserAccount>(DatabaseContext); _userAccountRepository = new UserAccountRepository(DatabaseContext);
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow