Os cinco padrões de desenho de sw essenciais

1. Singleton
2. Facade
3. Adapter
4. Strategy
5. Observer (Pub/Sub)

Video YouTube, 5 Design Patterns Every Engineer Should Know

que fazem a tradução entre os modelos dos sistemas externos e o nosso.

Relacionado: Mapear objectos com Automapper, Modelo C4 para arquitectura de software

Invocação de Web API em DDD

using System.Threading.Tasks;

using WebApiClient.Poc.Core.Interfaces;
using WebApiClient.Poc.Core.Entities;
using WebApiClient.PoC.HttpClientServices.Inventory;
using WebApiClient.PoC.HttpClientServices;

namespace WebApiClient.Poc.Console
{
    class Program
    {
        static void Main(string[] args)
        {
            RunAsync("19072000408").GetAwaiter().GetResult();
        }

        private static async Task RunAsync(string authorCode)
        {
            IAuthorInventoryService _inventoryService = new AuthorInventoryService(new HttpClientWrapper<Author>());
            await _inventoryService.GetInventoryAsync(authorCode);
        }
    }
}

The foundation of domain-driven design at the very end of the day is that ubiquitous language as a tool to discover the business needs and come up with a design driven by the domain in which presentation commands places orders, orders commands are executed, and somewhere, somehow, data is saved. For this way of working for this model, more effective practices and architectures are emerging. One is CQRS.

(Container and dynamic)

Notação

// Set up a timer to trigger every minute.  
System.Timers.Timer timer = new System.Timers.Timer();  
timer.Interval = 60000; // 60 seconds  
timer.Elapsed += new System.Timers.ElapsedEventHandler(this.OnTimer);  
timer.Start();

public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)  
{  
    // TODO: Insert activities here.  
}

using Unity;
using Unity.Lifetime;

private static Lazy container;

private static void RegisterTypes(UnityContainer container)
        {
            //Using Lifetime Managers: https://docs.microsoft.com/en-us/previous-versions/msp-n-p/ff647854(v%3dpandp.10)
container.RegisterType<IRepositoryAsync<Author>, AuthorRepository>(new PerRequestLifetimeManager());
container.RegisterType<IService<Author>, Service<Author>> (new PerRequestLifetimeManager());
container.RegisterType<IAuthorService, AuthorService>(new PerRequestLifetimeManager());
   }

        /// 
        /// Configured Unity Container.
        /// 
        public static IUnityContainer Unitycontainer => container.Value;

public void OnTimer(object sender, System.Timers.ElapsedEventArgs args)  
{  
               container =
                  new Lazy<iunitycontainer>(() =>
                  {
                      var container = new UnityContainer();
                      RegisterTypes(container);
                      return container;
                  });
   
            #region Unit of Work pattern with Unity DI
            var _dataContext = new PlutoContext();
            var _unitOfWork = new UnitOfWork(_dataContext);

            Unitycontainer.RegisterInstance<Idatacontext>(_dataContext, new ContainerControlledLifetimeManager());
            Unitycontainer.RegisterInstance<Idatacontextasync>(_dataContext, new ContainerControlledLifetimeManager());

            Unitycontainer.RegisterInstance<Iunitofwork>(_unitOfWork, new ContainerControlledLifetimeManager());
            Unitycontainer.RegisterInstance<Iunitofworkasync>(_unitOfWork, new ContainerControlledLifetimeManager());

            Unitycontainer.Resolve<Idatacontext>();
            Unitycontainer.Resolve<Idatacontextasync>();
            #endregion
   
   
     //Using Unity DI with a Console Application: https://stackoverflow.com/questions/29103508/using-unity-di-with-a-console-application
     //Dependency Injection with Unity: https://msdn.microsoft.com/en-us/library/dn178463(v=pandp.30).aspx#_Lifetime_Management
     ////https://www.tutorialspoint.com/design_pattern/command_pattern.htm
     Unitycontainer.Resolve<Program>().Run();
   
     _unitOfWork.Dispose();
   
     Unitycontainer.Dispose();
   
}

RabbitMQ

RabbitMQ Work Queue

Requisitos

1. ErLang
2. RabbitMQ

Instalação do ErLang

Instalação do RabbitMQ

Configuração e activação de plugins de gestão do broker de mensagens

Consola de Gestão

1. Abrir o endereço http://localhost:15672 no navegador.
2. É apresentada a página de entrada da consola de gestão do RabbitMQ
3. Introduzir o utilizador guest e palavra-chave guest
4. É apresentada a actividade do broker

Separated Presentation

Observer Pattern

Exemplo

Lógica de Negócio

public interface IStateValue
    {
        object Value { get; set; }
        string KeyName { get; set; }
        void SetDefault();
        object this[string KeyName] { get; set; }
    }

 public class CachingEventArgs : EventArgs
    {
        public IStateValue ApplicationStateBase { get; set; }
    }

    public delegate void InitializeStorageContextEventHandler(object sender, IStateValue stateValue);

public interface ICachingEvent
    {
        void OnInitializeStorageContext();
        event InitializeStorageContextEventHandler InitializeStorageContext;
    }

public class Controller
    {
        private IStateValue _stateValue;

        public void InitializeStorage(IStateValue stateValue)
        {
            _stateValue = stateValue;
            CheckValue();
        }

        public void CheckValue()
        {
            var result = _stateValue?.Value;
            
            if (result == null)
            {
                _stateValue.SetDefault();
            }

        }

    }

public class Logic
    {
        readonly Controller _controller;
        ICachingEvent _caching;
        
        public Logic(ICachingEvent caching)
        {
            _controller = new Controller();

            _caching = caching;

            _caching.InitializeStorageContext += InitializeStorage;

        }

        private void InitializeStorage(object sender, IStateValue stateValue)
        {
            _controller.InitializeStorage(stateValue);
        }
    }

Apresentação

public class StateValue<T> : IStateValue where T : class
    {
        private string _keyName;
        private HttpSessionState _sessionState;
        private T _value;

        #region IStateValue Members

        public StateValue() { StateStorage = HttpContext.Current.Session; }

        public StateValue(string keyName) : this()
        {
            Add(keyName);
        }

        public HttpSessionState StateStorage
        {
            get { return _sessionState; }
            set { _sessionState = value; }
        }

        #endregion

        #region IStateValue Implementation

        public object this[string KeyName]
        {
            get { return _sessionState[KeyName]; }
            set { _sessionState[KeyName] = (T) value; }
        }

        public object Value
        {
            get
            {
                if (StateStorage == null || StateStorage[_keyName] == null)
                {
                    return _value;
                }

                return StateStorage[_keyName];
            }

            set
            {
                _value = (T) value;

                if (StateStorage != null)
                {
                    StateStorage[_keyName] = (T) value;
                }
            }
        }

        public string KeyName
        {
            get { return _keyName; }
            set { _keyName = value; }
        }

        public void SetDefault()
        {
            _value = default(T);
        }

        #endregion

        public void Add(string keyName)
        {
            Add(keyName, default(T));
        }

        public void Add(string keyName, T value)
        {
            if (StateStorage[keyName] == null)
            {
                _sessionState.Add(keyName, value);
                _value = value;
            }

            _keyName = keyName;
        }

        public void ClearAll()
        {
            _sessionState.Clear();
        }

        public void Clear(string keyName)
        {
            StateStorage[keyName] = null;
        }
    }

<div>
 <asp:Button ID="Button1" runat="server" Text="Button" OnClick="Button1_Click" />
 <br />
 <asp:Label ID="Label1" runat="server" Text=""></asp:Label>
</div>

public partial class StateValueForm : System.Web.UI.Page, ICachingEvent
{
 Logic logic;

 IStateValue stateValue;

 public event InitializeStorageContextEventHandler InitializeStorageContext;

 protected override void OnPreInit(EventArgs e)
 {
  logic = new Logic(this);

  base.OnPreInit(e);
 }

 protected void Page_Load(object sender, EventArgs e)
 {
  stateValue = new StateValue<string>("FirstKey");
 }

 protected void Button1_Click(object sender, EventArgs e)
 {
  stateValue.Value = Guid.NewGuid().ToString();

  OnInitializeStorageContext();

  Label1.Text = (string)stateValue.Value;

 }

 public void OnInitializeStorageContext()
 {
  if (InitializeStorageContext != null)
  {
   InitializeStorageContext(this, stateValue);
  }
 }
}

Criação da solução

• Pasta Application
• Pasta Domain
• Pasta Infrastructure

Criação dos projectos Domain-Driven

Geração de POCO e DbContext

PM> install-package EntityFramework

  <connectionStrings>
    <add name="PlutoContext" connectionString="data source=(localdb)\MSSQLLocalDB;initial catalog=Pluto_Queries;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>

using UnitOfWorkRepository.Framework.Core.Model;

Integração com a URF Framework

Integração do DbContext

namespace UnitOfWorkRepository.Framework.EntityFramework
{
    using System.Linq;
    using UnitOfWorkRepository.Framework.Core.Model;
    using Repository.Pattern.Ef6;

    [System.CodeDom.Compiler.GeneratedCode("EF.Reverse.POCO.Generator", "2.32.0.0")]
    public partial class PlutoContext : DataContext, IPlutoContext
    {
        public System.Data.Entity.DbSet<Author> Authors { get; set; } // Authors
        public System.Data.Entity.DbSet<Course> Courses { get; set; } // Courses

        static PlutoContext()
        {
            System.Data.Entity.Database.SetInitializer<PlutoContext>(null);
        }

        public PlutoContext()
            : base("Name=PlutoContext")
        {
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
        }

       [...]

     }
}

Integração do Model

namespace UnitOfWorkRepository.Framework.Core.Model
{     
  using Repository.Pattern.Ef6;     

  // Authors
  [System.CodeDom.Compiler.GeneratedCode("EF.Reverse.POCO.Generator", "2.32.0.0")]
  public partial class Author: Entity
  {
   [...]
  }
}

Integração das Interfaces

using UnitOfWorkRepository.Framework.Core.Model;
using Repository.Pattern.Repositories;

namespace UnitOfWorkRepository.Framework.Core.Interfaces
{
   public interface IAuthorRepository: IRepositoryAsync<Author>
   {
     Author GetAuthorWithCourses(int id);
   }
}

Integração dos Repositórios

using Repository.Pattern.DataContext;
using Repository.Pattern.Ef6;
using Repository.Pattern.UnitOfWork;
using System.Linq;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using UnitOfWorkRepository.Framework.Core.Model;

namespace UnitOfWorkRepository.Framework.EntityFramework.Repositories
{
  public class AuthorRepository: Repository <Author>, IAuthorRepository 
  {
    public AuthorRepository(IDataContextAsync dataContext, IUnitOfWorkAsync unitOfWork)
 : base(dataContext, unitOfWork){}
 
    public Author GetAuthorWithCourses(int id) 
    {
      var authorWithCourses = base.Query().Include(a => a.Course).Select().AsQueryable();
   
      return authorWithCourses.FirstOrDefault();
    }
  }
}

Introdução da lógica de negócio

using System.Collections.Generic;
using UnitOfWorkRepository.Framework.Core.Model;
using Service.Pattern;

namespace UnitOfWorkRepository.Framework.Core.Interfaces
{
  public interface IAuthorService: IService<Author>
  {
    IEnumerable<Author> GetAllAuthors();
    Author GetAuthor(int Id);
    Author GetAuthorWithCourses(int id);
  }
}

using System.Collections.Generic;
using UnitOfWorkRepository.Framework.Core.Model;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using Service.Pattern;
using Repository.Pattern.Repositories;

namespace UnitOfWorkRepository.Framework.Application
{
    public class AuthorService : Service<Author>, IAuthorService
    {
        private IAuthorRepository _repository;

        public AuthorService(IRepositoryAsync<Author> repository)
            :base(repository)
        {
            _repository = repository as IAuthorRepository;
        }

        public IEnumerable<Author> GetAllAuthors()
        {
            return base.Query().Select();
        }

        public Author GetAuthor(int Id)
        {
            return base.Find(Id);
        }

        public Author GetAuthorWithCourses(int id)
        {
            return _repository.GetAuthorWithCourses(id);
        }

        public override void Insert(Author author)
        {
            // TODO: lógica de negócio
            base.Insert(author);
        }

        public override void Delete(Author author)
        {
            // TODO: lógica de negócio
            base.Delete(author);
        }

        public override void Update(Author author)
        {
            // TODO: lógica de negócio
            base.Update(author);
        }
    }
}

Consumo por framework de apresentação

using UnitOfWorkRepository.Framework.Application;
using Repository.Pattern.Repositories;
using UnitOfWorkRepository.Framework.Core.Model;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using Repository.Pattern.UnitOfWork;
using Repository.Pattern.Ef6;
using Repository.Pattern.DataContext;
using UnitOfWorkRepository.Framework.EntityFramework;
using UnitOfWorkRepository.Framework.EntityFramework.Repositories;
using Service.Pattern;

container.RegisterType<IUnitOfWork, UnitOfWork>(new PerRequestLifetimeManager());
container.RegisterType<IUnitOfWorkAsync, UnitOfWork>(new PerRequestLifetimeManager());
container.RegisterType<IDataContext, PlutoContext>(new PerRequestLifetimeManager());
container.RegisterType<IDataContextAsync, PlutoContext>(new PerRequestLifetimeManager());
container.RegisterType<IRepositoryAsync<Author>, AuthorRepository>(new PerRequestLifetimeManager());
container.RegisterType<IService<Author>, Service<Author >> (new PerRequestLifetimeManager());
container.RegisterType<IAuthorService, AuthorService>(new PerRequestLifetimeManager());

Microsoft.Web.Infrastructure.DynamicModuleHelper.DynamicModuleUtility.RegisterModule(typeof(UnityPerRequestHttpModule));

using Repository.Pattern.Infrastructure;
using Repository.Pattern.UnitOfWork;
using System.Web.Mvc;
using UnitOfWorkRepository.Framework.Core.Interfaces;
using UnitOfWorkRepository.Framework.Core.Model;

namespace UnitOfWorkRepository.Framework.WebApplication.MVC.Controllers
{
    public class AuthorsController : Controller
    {
        private IAuthorService _authorService;
        private IUnitOfWork _unitOfWork;

        public AuthorsController(IAuthorService authorService, IUnitOfWork unitOfWork)
        {
            _authorService = authorService;
            _unitOfWork = unitOfWork;
        }

        // GET: Authors
        public ActionResult Index()
        {
            return View(_authorService.GetAllAuthors());
        }

        // GET: Authors/Details/5
        public ActionResult Details(int id)
        {
            Author author = _authorService.GetAuthor(id);
            if (author == null)
            {
                return HttpNotFound();
            }

            return View(author);
        }

        // GET: Authors/Create
        public ActionResult Create()
        {
            return View();
        }

        // POST: Authors/Create
        // Para se proteger de mais ataques, ative as propriedades específicas a que você quer se conectar. Para 
        // obter mais detalhes, consulte https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create([Bind(Include = "Id,Name")] Author author)
        {
            if (ModelState.IsValid)
            {
                _authorService.Insert(author);
                _unitOfWork.SaveChanges();
                
                return RedirectToAction("Index");
            }

            return View(author);
        }

        // GET: Authors/Edit/5
        public ActionResult Edit(int id)
        {
            Author author = _authorService.GetAuthor(id);

            if (author == null)
            {
                return HttpNotFound();
            }
            return View(author);
        }

        // POST: Authors/Edit/5
        // Para se proteger de mais ataques, ative as propriedades específicas a que você quer se conectar. Para 
        // obter mais detalhes, consulte https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "Id,Name")] Author author)
        {
            if (ModelState.IsValid)
            {
                author.ObjectState = ObjectState.Modified;
                _authorService.Update(author);
                _unitOfWork.SaveChanges();
                return RedirectToAction("Index");
            }
            return View(author);
        }

        // GET: Authors/Delete/5
        public ActionResult Delete(int id)
        {
            Author author = _authorService.GetAuthor(id);
            if (author == null)
            {
                return HttpNotFound();
            }
            return View(author);
        }

        // POST: Authors/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public ActionResult DeleteConfirmed(int id)
        {
            Author author = _authorService.GetAuthor(id);
            _authorService.Delete(author);
            _unitOfWork.SaveChanges();
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _unitOfWork.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}

<url base>/Authors

public sealed class EventAggregator : IEventAggregator
    {
        private readonly IDictionary<Type, IList> _subscriptions = new Dictionary<Type, IList>();

        #region Singleton - not quite as lazy, but thread-safe without using locks

        private static readonly EventAggregator instance = new EventAggregator();

        // Explicit static constructor to tell C# compiler
        // not to mark type as beforefieldinit
        static EventAggregator()
        {
        }

        private EventAggregator()
        {
        }

        public static EventAggregator Instance
        {
            get
            {
                return instance;
            }
        }

        #endregion

        public void Publish<TMessage>(TMessage message) where TMessage : IMessage
        {
            if (message == null) throw new ArgumentNullException("no message");

            Type messageType = typeof(TMessage);

            if (_subscriptions.ContainsKey(messageType))
            {
                var subscriptionList = new List<ISubscription<TMessage>>(
                    _subscriptions[messageType].Cast<ISubscription<TMessage>>());

                foreach (var subscription in subscriptionList)
                {
                    subscription.Action(message);
                }
            }
        }

        public void UnSubscribe<TMessage>(ISubscription<TMessage> subscription) where TMessage : IMessage
        {
            Type messageType = typeof(TMessage);

            if (_subscriptions.ContainsKey(messageType))
            {
                _subscriptions[messageType].Remove(subscription);
            }
        }

        public ISubscription<TMessage> Subscribe<TMessage>(Action<TMessage> action) where TMessage : IMessage
        {
            Type messageType = typeof(TMessage);
            var subscription = new Subscription<TMessage>(this, action);

            if (_subscriptions.ContainsKey(messageType))
            {
                _subscriptions[messageType].Add(subscription);
            }
            else
            {
                _subscriptions.Add(messageType, new List<ISubscription<TMessage>> { subscription });
            }

            return subscription;
        }

        public void ClearAllSubscriptions()
        {
            ClearAllSubscriptions(null);
        }

        public void ClearAllSubscriptions(Type[] exceptMessages)
        {
            foreach (var messageSubscriptions in new Dictionary<Type, IList>(_subscriptions))
            {
                bool canDelete = true;
                if (exceptMessages != null)
                {
                    canDelete = !exceptMessages.Contains(messageSubscriptions.Key);
                }

                if (canDelete)
                {
                    _subscriptions.Remove(messageSubscriptions);
                }
            }
        }
        
    }

public class Subscription<TMessage> : ISubscription<TMessage> where TMessage : IMessage
    {
        public Action<TMessage> Action { get; private set; }
        public IEventAggregator EventAggregator { get; private set; }

        public Subscription(IEventAggregator eventAggregator, Action<TMessage> action)
        {
            if (eventAggregator == null) throw new ArgumentNullException("no eventAggregator");
            if (action == null) throw new ArgumentNullException("no action");

            EventAggregator = eventAggregator;
            Action = action;
        }


        #region IDisposable Support
        private bool disposedValue = false; // To detect redundant calls

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    EventAggregator.UnSubscribe(this);
                }

                disposedValue = true;
            }
                
        }

        // This code added to correctly implement the disposable pattern.
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }

public static class Messages
    {

        public static IEventAggregator Hub
        {
            get
            {
                return Service.EventAggregator.Instance;
            }

        }

    }

private void ShowItemName(IEventAggregator messageHub)
        {
            messageHub.Subscribe<Item>(item => { /* ... */; });
        }

private static void SetItemName(IEventAggregator messageHub, TextBox textBox)
        {
           messageHub.Publish(new Item { /* ... */ });
        }

[...]

ShowItemName(Messages.Hub);

SetItemName(Messages.Hub, (TextBox)sender);

• Easy Event Aggregator por Nima Ara
• Asynchronous Event Aggregator por Timothy Makarov

Codificação da solução

PM> Install-Package WebFormsMVP -Version 1.4.5

• Model
• Presenter
• View

PM> Install-Package WebFormsMVP -Version 1.4.5

public class HelloWorldModel
    {
        public string HelloWorld { get; set; }
    }

using WebFormsMvp;
[...]
public class HelloWorldPresenter : Presenter<IView<HelloWorldModel>>
    {
        public HelloWorldPresenter(IView<HelloWorldModel> view) : base(view)
        {

            View.Load += View_Load;
        }

        private void View_Load(object sender, EventArgs e)
        {
            View.Model.HelloWorld = "Olá Mundo :)";
        }

    }

using WebFormsMvp;
using WebFormsMvp.Web;
using ASPNET.WebForms.MVP.Logic.Model;
using ASPNET.WebForms.MVP.Logic.Presenter;

<br />
    <h3><%= Model.HelloWorld %></h3>
    <br />

[PresenterBinding(typeof(HelloWorldPresenter), ViewType = typeof(IView<HelloWorldModel>))]
    public partial class HelloWorld : MvpPage<HelloWorldModel>
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            
        }
    }

Framework Web Forms MVP em acção

Criar a solução

1. Pasta Application
2. Pasta Domain
3. Pasta Infrastructure

Code-First Migrations

Modelo e BD Iniciais

• Pasta Repositories

PM> install-package EntityFramework

• Pasta Model

public class Author
    {
        public int Id { get; set; }
        public string  Name { get; set; }
        public virtual ICollection<Course> Courses { get; set; }
    }

public class Course
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Description { get; set; }
        public int Level { get; set; }
        public float FullPrice { get; set; }
        public bool IsBeginnerCourse
        {
            get { return Level == 1; }
        }
        public int AuthorId { get; set; }
        public virtual Author Author { get; set; }
    }

using System.Data.Entity;
using UnitOfWorkRepositoryPattern.PoC.Core.Model;

namespace UnitOfWorkRepositoryPattern.PoC.EntityFramework
{
    public class PlutoContext: DbContext
    {
        public PlutoContext()
            : base("name=PlutoContext")
        {
            this.Configuration.LazyLoadingEnabled = false;
        }

        public virtual DbSet<author> Authors { get; set; }
        public virtual DbSet<course> Courses { get; set; }
       
        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
        }

    }
}

  <connectionStrings>
    <add name="PlutoContext" connectionString="data source=(localdb)\MSSQLLocalDB;initial catalog=Pluto_Queries;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework" providerName="System.Data.SqlClient" />
  </connectionStrings>

Activação das Code-First Migrations

PM> enable-migrations

Geração e Execução das Code-First Migrations

PM> add-migration <designação>

PM> update-database –verbose

Repository Pattern

• Add(object)
• Remove(object)
• Get(id)
• GetAll()
• Find(predicate)

public interface IRepository<TEntity> where TEntity : class
    {
        void Add(TEntity entitity);
        void Remove(TEntity entity);
        TEntity Get(int id);
        IEnumerable<TEntity> GetAll();
        IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);
    }

public interface IAuthorRepository: IRepository<Author>
    {
        Author GetAuthorWithCourses(int id);
    }

public interface ICourseRepository: IRepository<Course>
    {
        IEnumerable<Course> GetTopSellingCourses(int count);
        IEnumerable<Course> GetCoursesWithAuthors(int pageIndex, int pageSize);
    }

 public class RepositoryBase<TEntity> : IRepository<TEntity> where TEntity : class
    {
        protected readonly DbContext Context;

        public RepositoryBase(DbContext dbContext)
        {
            Context = dbContext;
        }

        public void Add(TEntity entitity)
        {
            Context.Set<TEntity>().Add(entitity);
        }

        public IEnumerable<TEntity> Find(Expression<Func<TEntity, bool>> predicate)
        {
            return Context.Set<TEntity>().Where(predicate);
        }

        public TEntity Get(int id)
        {
            return Context.Set<TEntity>().Find(id);
        }

        public IEnumerable<TEntity> GetAll()
        {
            return Context.Set<TEntity>().ToList();
        }

        public void Remove(TEntity entity)
        {
            Context.Set<TEntity>().Remove(entity);
        }
    }

public class AuthorRepository : RepositoryBase<Author>, IAuthorRepository
    {
        public PlutoContext PlutoContext
        {
            get { return Context as PlutoContext; } 
        }

        public AuthorRepository(PlutoContext plutoContext) : base(plutoContext){ }

        public Author GetAuthorWithCourses(int id)
        {
            return PlutoContext.Authors.Include(a => a.Courses).SingleOrDefault(a => a.Id == id);
        }
    }

Unit Of Work

mantém uma lista de objectos afectados por uma transacção e coordena a escrita de mudanças e trata possíveis problemas de concorrência

A classe ObjectContext no Entity Framework é exemplo de uma Unidade de Trabalho

public interface IUnitOfWork: IDisposable
    {
        IAuthorRepository Authors { get; }
        ICourseRepository Courses { get; }
        int Complete();
    }

public class UnitOfWork : IUnitOfWork
    {
        protected readonly PlutoContext _plutoContext;

        public UnitOfWork(PlutoContext plutoContext)
        {
            _plutoContext = plutoContext;

            Authors = new AuthorRepository(_plutoContext);
            Courses = new CourseRepository(_plutoContext);
        }

        public IAuthorRepository Authors { get; private set; }

        public ICourseRepository Courses { get; private set; }

        public int Complete()
        {
            return _plutoContext.SaveChanges();
        }

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

Utilização

PM> install-package EntityFramework

using UnitOfWorkRepositoryPattern.PoC.Core;
using UnitOfWorkRepositoryPattern.PoC.Core.Model;
using UnitOfWorkRepositoryPattern.PoC.EntityFramework;

IUnitOfWork unitOfWork = new UnitOfWork(new PlutoContext());

            unitOfWork.Authors.Add(
                new Author {
                    Id = 1,
                    Name = "Silvia Pinhao Lopes",
                    Courses = new List<Course>
                    {
                        new Course
                        {
                            AuthorId = 1,
                            Description = "First Course",
                            FullPrice = 12,
                            Id = 1,
                            Level = 1,
                            Name = "1st Course"
                        }
                    }
                });

            unitOfWork.Complete();

            var allAuthors = unitOfWork.Authors.GetAll();

            foreach (var author in allAuthors)
            {
                System.Console.WriteLine(author.Name);
                unitOfWork.Authors.Remove(author);
            }
            unitOfWork.Complete();

            unitOfWork.Dispose();

            System.Console.Read();

• Apresentação
• Serviço
• Lógica de Negócio/Núcleo da aplicação
• Acesso a dados/Persistência

Camada de apresentação

Camada de Serviço

app.service('MyService', function () {
  this.getDataList = function () {
    //...
   $.ajax({
       type : 'POST',
   //...
  };
});

Camada da lógica de negócio

//...
// Save file
var uploadsPath = Path.Combine(host.WebRoot, "uploads");
if (!Directory.Exists(uploadsPath))
    Directory.CreateDirectory(uploadsPath);
 
var fileName = Guid.NewGuid().ToString() + Path.GetExtension(file.FileName);
var filePath = Path.Combine(uploadsPath, fileName);
 
using (var stream = new FileStream(filePath, FileMode.Create))
{  
    file.Copyto(stream);
}
 
// Add a record to the repository
var photo = new Photo { FileName = fileName };
photoRepository.Add(photo);
unitOfWork.Complete(); 

Camada de acesso a dados