Engenho &amp; Engenhocas

Estratégia Ferramenta Vídeo

Plataforma Dreamshaper: desenvolvimento de projectos e negócios

Para ler

ASP.NET Desenvolvimento Framework IDE Imagem MVP Software Patterns Visual Studio Web

ASP.NET WebForms MVP: uma framework MVP aplicada a web forms

Para ler

Trata-se da aplicação da separação de conceitos às ASP.NET Web forms de forma simples, rápida e com a aplicação das boas práticas com a framework Web Forms MVP.

É usado aqui um HelloWorld para prova de conceito básica.

Codificação da solução

Criar uma solução Web do tipo Web Forms, neste exemplo tem o nome ASPNET.WebForms.MVP.

Na Consola de Gestão de Pacotes NuGet procede-se à instalação da Framework WebFormsMVP, tendo este projecto como padrão

PM> Install-Package WebFormsMVP -Version 1.4.5

Adicionar à solução um projecto do tipo biblioteca que comporta a lógica com as pastas

Model
Presenter
View

Novamente na Consola de Gestão de Pacotes NuGet procede-se à instalação da Framework WebFormsMVP, tendo este projecto como padrão

PM> Install-Package WebFormsMVP -Version 1.4.5

Ao Model adiciona-se a classe HelloWorldModel.cs

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

Ao Presenter adiciona-se a classe HelloWorldPresenter.cs

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 :)";
        }

    }

A aplicação Web referencia a biblioteca core preparada anteriormente e faz uso dos seus elementos no code behind da página HelloWorld.aspx adicionada:

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

HelloWorld.aspx

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

HelloWorl.aspx.cs

[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

ASP.NET Desenvolvimento Framework IDE Imagem Visual Studio Web

ASP.NET MVC vanity URL's

Para ler

É mais fácil usar os built-in routings, é no entanto, uma boa prática customizar o routing, nomeadamente para mais facilmente ser promovido junto dos motores de pesquisa como o google.com.

Métodos de customização de routings

RouteConfig.cs
AttributeRouting

Adição ao App_Start\RouteConfig.cs

Exemplo:

routes.MapRoute(
                name: "MoviesReleaseByDate",
                url: "Movie/Released/{year}/{month}",
                defaults: new { controller = "Movie", action = "ByReleaseDate"},
                constraints: new { year = @"\d{4}", month = @"\d{2}"}
            );

Construção de AttributeRouting

Esta é a melhor abordagem.

Pré-condição
Adição ao RouteConfig.cs da instrução para activação do route por atributo

routes.MapMvcAttributeRoutes();

Route aplicado como atributo
Adição da template ao atributo Route da action ByReleaseDate do controller MovieController.cs

[Route("Movie/Released/{year}/{month:regex(\\d{2}):range(1, 12)}")]
 public ActionResult ByReleaseDate(int year, int month)
 {
   return Content(string.Format("year={0}&month={1}", year, month));
 }

Routing em acção

Estratégia Ferramenta Imagem Windows

Poderá o Andromeda O.S. fazer do Windows 10 um sistema modular?

Para ler

Engenhocas Estratégia Vídeo

China lança rede de comunicação quântica

Para ler

Desenvolvimento Framework IDE Imagem Software Patterns Visual Studio

Unit of Work in Repository Pattern

Para ler

Prova de conceito das Design Pattern de persistência de dados Unit of Work e Repository com Entity Framework Code-First Migrations no Visual Studio 2017

Criar a solução

Criar nova solução com três camadas orientadas ao domínio:

Pasta Application
Pasta Domain
Pasta Infrastructure

Code-First Migrations

Modelo e BD Iniciais

À Infrastructure adiciona-se o projecto do tipo biblioteca de nome EntityFramework com os repositórios de acesso à Entity Framework

Pasta Repositories

Na Consola de Gestão de Pacotes NuGet procede-se à instalação da Entity Framework, tendo este projecto como padrão

PM> install-package EntityFramework

Uma vez instalada a última versão da Entity Framework, adiciona-se ao projecto o DBContext utilizando uma classe ADO.NET Entity Data Model com Empty Code First Model a que se dá o nome "PlutoContext".
Ao Domain adiciona-se o projecto do tipo biblioteca com o Core:

Pasta Model

O Model comporta as entidades de domínio. Exemplo: , Course

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; }
    }

.

Uma vez criadas as entidades que definem o modelo de domínio e referenciado o projecto Core pela biblioteca de acesso a dados EntityFramework, define-se o contexto EF Code First na PlutoContext.cs:

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);
        }

    }
}

Adiciona-se ao App.config a connectionstring PlutoContext à base de dados Pluto_Queries. Confirma-se o nome do servidor da data source no Server Explorer: o servidor local é .\MSSQLLocalDB.

  <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>

Compila-se a solução e é criada a base de dados a partir do DbContext.

Activação das Code-First Migrations

Na Consola de Gestão de Pacotes NuGet procede-se à activação das migrações, tendo este projecto como padrão

PM> enable-migrations

A execução deste comando dá origem à pasta Migrations com a configuração e a migração inicial.

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

O comando Add-Migration executa o scaffold da próxima migração Code-First. As alterações ao modelo dão origem a nova migração e vão ser registadas na tabela de histórico '__MigrationHistory'.

Devem ser designadas para melhor identificação.

PM> add-migration <designação>

O comando Update-Database aplica a migração à base de dados.

PM> update-database –verbose

Repository Pattern

À biblioteca Core, adiciona-se a pasta Interfaces. Esta pasta comporta as interfaces intrínsecas aos repositórios e estendem uma interface de repositório genérico. Este repositório deve ser tratado como uma System.Collections.Generic com os métodos:

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);
    }

Exemplo de interfaces para os repositórios AuthorRepository e CourseRepository respectivamente:
, ICourseRepository


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

.

À pasta Repositories da biblioteca EntityFramework, juntam-se as classes que implementam as interfaces definidas no Domain, uma por entidade: RepositoryBase e as classes que herdam desta: AuthorRepository e CourseRepository.

A classe base tem um DbContext genérico aplicável a qualquer aplicação:

 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);
        }
    }

Enquanto as classes descendentes desta que implementam a interface definida no Domain têm um PlutoContext. Exemplo:

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

A Unit Of Work é específica para O/RM. De acordo com Martin Fowler, a unidade de trabalho

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

in Unit of work - O padrão de unidade de trabalho (.NET)

À biblioteca Core adiciona-se a interface IUnitOfWork que define o contrato para articulação dos repositórios

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

À biblioteca EntityFramework adiciona-se a classe UnitOfWork, implementação da interface IUnitOfWork sobre os repositórios do PlutoContext.

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

À pasta Application adiciona-se o projecto do tipo Console com o nome "Console.Application".

Na Consola de Gestão de Pacotes NuGet procede-se à instalação da Entity Framework, tendo este projecto como padrão

PM> install-package EntityFramework

Adiciona-se ao App.config a connectionstring definida na biblioteca EntityFramework da Infrastructure.

Referencia-se os projectos Core e EntityFramework.

Adiciona-se ao programa o código de orquestração das entidades de domínio e interfaces dos repositórios para desencadear as operações sobre o PlutoContext através da unidade de trabalho.

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();

Referências: Entity Framework Code First Migrations, Code-based Migration, Repository Pattern with C# and Entity Framework, Done Right