I forum Ricerca FAQ
Fai una domanda
Ultimo messaggio
LostInSpace
LostInSpace
il 7 aprile 2017 alle 09:44
8 messaggi dal 25 marzo 2016
Ciao a tutti,

sto iniziando a studiare la unit of work associata al repository pattern ma sinceramente non capisco il valore aggiunto di utilizzarla con entity framework. Ho l'impressione che si complichino soltanto le cose.

L'obbiettivo sarebbe quello di utilizzare questo pattern con più data source ma non capisco come implementarlo.

Vi descrivo il mio scenario.
Nella mia applicazione ho due data source: web service e SQL Server (entity framework);
-il web service mi serve per ottenere i dati
-il DB per leggere e scrivere.

Vorrei utilizzare la unit of work per accedere alle due fonti dati in modo intercambiabile.
Per ora riesco solo ad accedere al DB

Ho creato il repository

public interface IRepository<T> where T : class
{
    IEnumerable<T> GetAll(Func<T, bool> predicate = null);
    T Get(Func<T, bool> predicate);
    void Add(T entity);
    void Attach(T entity);
    void Delete(T entity);
}

class GenericRepository<T> : IRepository<T> where T : class
{
    private DBEntities entities = null;
    IObjectSet<T> _objectSet;

    public GenericRepository(DBEntities _entities)
    {
        entities = _entities;
        _objectSet = entities.CreateObjectSet<T>();
    }

    public IEnumerable<T> GetAll(string uri, string ragneUri)
    {
        IEnumerable<T> t = new List<T>();
        return t.AsEnumerable();
    }

    public IEnumerable<T> GetAll(Func<T, bool> predicate = null)
    {
        if (predicate != null)
  {
      return _objectSet.Where(predicate);
  }

  return _objectSet.AsEnumerable();
    }

    public T Get(Func<T, bool> predicate)
    {
  return _objectSet.First(predicate);
    }

    public void Add(T entity)
    {
  _objectSet.AddObject(entity);
    }

    public void Attach(T entity)
    {
  _objectSet.Attach(entity);
    }

    public void Delete(T entity)
    {
  _objectSet.DeleteObject(entity);
    }
}


e la Unit Of Work

public class GenericUnitOfWork : IDisposable
{
    private DBEntities entities = null;
    private DataActions da = null;

    public GenericUnitOfWork(DBEntities PE)
    {
        entities = PE;
    }

    public Dictionary<Type, object> repositories = new Dictionary<Type, object>();

    public IRepositoryIPSE<T> Repository<T>() where T : class
    {
        if (repositories.Keys.Contains(typeof(T)) == true)
        {
            return repositories[typeof(T)] as IRepository<T>;
        }
        IRepository<T> repo = new GenericRepository<T>(entities);
        repositories.Add(typeof(T), repo);
        return repo;
    }

    public void SaveChanges()
    {
        entities.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                entities.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}


Per accedere al web service avevo pensato di creare un nuovo repository con il solo metodo GetData ma poi non capisco come integrarlo con la Unit of Work
E' possible realizzare questo scenario o sto facendo confusione?

Grazie a tutti
RispondiQuoting

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.