A URF, Unit-of-Work & Repository Framework, é uma framework que tem por objectivo juntar as Patterns Repository e Unit of Work sobre tecnologia O/RM ao Domain-Driven Design. Documentação desta framework aqui.

O exercício seguinte consiste em aplicar a URF Framework à solução desenhada aqui, com dependency injection.

Criação da solução

Criar a nova solução UnitOfWorkRepository.Framework com:

• Pasta Application
• Pasta Domain
• Pasta Infrastructure

Criação dos projectos Domain-Driven

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

Mais detalhes aqui.

Geração de POCO e DbContext

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

PM> install-package EntityFramework

Uma vez instalada a última versão da Entity Framework, procede-se ao reverse engineering para a geração do DbContext, classes POCO e Configuração POCO a partir da BD SQL Server Pluto_Queries. É usado para o efeito o módulo EntityFramework Reverse POCO Generator, disponível aqui, que integra com o Visual Studio 2017. Artigo dedicado, aqui, pela Microsoft MVP Julie Nerman.

Connection string PlutoContext usada aqui:

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

Mover as classes POCO Author e Course, geradas automaticamente pelo EF.Reverse.POCO.Generator para a pasta Model do Core e a bilbioteca EntityFramework tem de passar a referenciá-lo.

using UnitOfWorkRepository.Framework.Core.Model;

Compilar a solução para verificação.

Integração com a URF Framework

Usar a gestão de pacotes NuGet através da UI da ferramenta no VS para instalar o pacote Urf.Repository.Pattern.EF6 nos projectos Application, Core e EntityFramework.

Integração do DbContext

Para integrar o DbContext com a URF Framework, o DbContext tem de herdar do DataContext:

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

Para integrar as entidades de domínio com esta framework de persistência, estas classes têm de herdar da classe base Entity.cls:

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
  {
   [...]
  }
}

Compilar a solução para verificação.

Integração das Interfaces

À biblioteca Core, adiciona-se a pasta Interfaces. Esta pasta comporta as interfaces intrínsecas aos repositórios e estendem a interface de repositório da URF Framework. Exemplo, IAuthorRepository:

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

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

Compilar a solução para verificação.

Integração dos Repositórios

Depois de adicionada a pasta Repositories à biblioteca EntityFramework, juntam-se as classes que implementam as interfaces definidas no Domain e que herdam do repositório base da URF Framework. Exemplo, AuthorRepository:

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

Usar a gestão de pacotes NuGet através da UI da ferramenta no VS para instalar o pacote Urf.Service.Pattern nos projectos Application e Core.

A biblioteca Application vai ter os serviços que implementam a lógica de negócio, enquanto a pasta Interfaces da biblioteca Core vai ter as interfaces intrínsecas a estes serviços. Exemplo, IAuthorService e AuthorService:

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

É usado para exemplo o controller AuthorsController.cs da framework .NET MVC 5.

I. Criar o projecto do tipo ASP.NET MVC Web Application no Visual Studio 2017 com a template de fábrica.

II. Usar a gestão de pacotes NuGet através da UI da ferramenta no VS para instalar neste projecto o pacote mais recente do Unity.Mvc (unity bootstrapper para asp.net mvc), pela Microsoft.

III. Adicionar o seguinte código ao App_Start\UnityConfig.cs

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

IV. Descomentar a seguinte linha de código do método Start da App_Start\UnityMvcActivator.cs

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

V. Gerar o AuthorsController com scaffolding com modos de exibição usando a Entity Framework


VI.Substituir o código do AuthorsController.cs por

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

Depurar no navegador pré-definido.

<url base>/Authors

Relacionado: Unit of Work in Repository Pattern, Arquitectura por camadas em aplicações ASP.NET Core



(artigo editado)







Referências: Introduction to EntityFramework Reverse POCO Generator for Visual Studio, EntityFramework Reverse POCO Generator, URF (Unit of Work & Repository Framework) in ASP.NET MVC 5 with Entity Framework 6 & Unity 3 - v2

De acordo com Sandra Santos, Human Resources leader na Nielsen Portugal, a geração Y ou millennials tem uma perspectiva radicalmente diferente da sua vida profissional, pelo que as empresas têm cada vez mais a necessidade de adaptar o seu estilo de gestão e branding às necessidades dos novos colaboradores.

Na verdade, é a forma como as empresas gerem os talentos desta geração e os prepara para papéis de liderança que vai determinar o sucesso dos seus negócios.

Sandra Santos defende os seguintes aspectos como fundamentais para tornar a cultura de uma empresa atractiva para esta geração:

Feedback contínuo e reconhecimento

Os sistemas de avaliação anual de desempenho estão ultrapassados, sendo necessário algo mais reiterado e consistente. Programas de intercâmbio de talentos, de mentoring e de formação em geral são aspectos que devem ser capitalizados e dinamizados.

Work-life balance

Este grupo procura a sua realização muito além da carreira, pelo que valorizam a preocupação da empresa pelo seu bem-estar pessoal e para que lhes sejam proporcionadas as condições necessárias para manter o equilíbrio entre a vida profissional e laboral.

Uma cultura de trabalho positiva e inclusiva

Com o princípio de que o conceito de sucesso vai muito além da componente profissional, esta geração valoriza a preocupação da empresa por factores que não estejam directamente ligados ao negócio, mas sim centrados no bem-estar dos colaboradores e da comunidade em geral. Diversidade e inclusão e a responsabilidade social e ambiental são exemplos.

Alinhamento entre a imagem externa e interna

É importante que os valores promovidos pela empresa sejam os mesmos que o colaborador vê reflectidos na sua experiência. A congruência e a transparência de valores e princípios são muito valorizados.

Progressão de carreira

Os millennials estão habituados a contextos em rápida e permanente mudança, pelo que as empresas e os seus líderes devem estar preparados para apresentar desafios, para abrir portas e para disponibilizar alternativas de progressão de carreira e de crescimento profissional.

Transformação digital

É sem dúvida o futuro e as novas gerações têm vindo a ser preparadas para operar desta forma, valorizando a eficiência, simplificação e rapidez de processos. As novas tecnologias são o ponto de partida desde o processo de recrutamento até à forma de trabalhar e fazer negócio.





fonte: HRPortugal

A especificação OpenAPI Swagger está para os serviços RESTfull assim como a WSDL está para os webservices.

O Visual Studio 2017 tem suporte para a especificação e criação de proxys para API REST com o protocolo Swagger.

Pressupostos

Criação de projecto do tipo ASP.NET MVC Web API no Visual Studio 2017 para .NET Framework 4.6 com a template de fábrica.

Adição de documentação XML ao controller

Na pasta Controllers, é criado o controller ValuesController.cs por omissão. Nesta classe, substituir as acções pelo seguinte código:

private string[] lista
        {
            get
            {
                if (System.Web.HttpContext.Current.Application["lista"] == null)
                {
                    System.Web.HttpContext.Current.Application["lista"] = new string[] { "value1", "value2" };
                }
                return
                    (string[])System.Web.HttpContext.Current.Application["lista"];
            }
        }

        /// <summary>
        /// Retrieves the list of values
        /// </summary>
        /// <returns></returns>
        public IEnumerable<string> Get()
        {
            return lista;
        }
        /// <summary>
        /// Retrieves one value from the list of values
        /// </summary>
        /// <param name="id">The id of the item to be retrieved</param>
        /// <returns></returns>
        public string Get(int id)
        {
            return lista[id];
        }
        /// <summary>
        /// Insert a new value in the list
        /// </summary>
        /// <param name="value">New value to be inserted</param>
        public void Post([FromBody]string value)
        {
        }
        /// <summary>
        /// Change a single value in the list
        /// </summary>
        /// <param name="id">The id of the value to be changed</param>
        /// <param name="value">The new value</param>
        public void Put(int id, [FromBody]string value)
        {
            lista[id] = value;
        }
        /// <summary>
        /// Delete an item from the list
        /// </summary>
        /// <param name="id">id of the item to be deleted</param>
        public void Delete(int id)
        {

        }

Ao executar a aplicação para depuração é apresentada a página inicial no navegador pré-definido.
Na barra de endereços do navegador, escrever o caminho para o controller Values.

<url base>/api/values

A API REST devolve o resultado da lista:

["value1","value2"]

Integração do Swagger no projecto

O protocolo Swagger é agnóstico. Portanto, é necessária uma ferramenta para implementação do protocolo em função da tecnologia. A ferramenta para .NET é o SwashBuckle. Existem duas versões, a Swashbuckle.Net45 para .NET Framework 4.5 e posteriores e outra para as mais antigas.

Na Consola de Gestão de Pacotes NuGet procede-se à instalação da última versão do pacote Swashbuckle.Net45, tendo este projecto da WebApi como padrão

PM> Install-Package Swashbuckle.Net45 -Version 5.2.1

Configuração da documentação XML

O SwashBuckle usa a documentação XML para descrever as acções das APIs. Para isso há que seleccionar as propriedades do projecto e no separador Build indicar o ficheiro de output para documentação XML. Exemplo: \bin\myWebApi.xml

Configuração do SwashBuckle

Procurar o ficheiro SwaggerConfig.cs na pasta App_Start do projecto da WebApi.
Descomentar a seguinte linha de código do método Register

c.IncludeXmlComments(GetXmlCommentsPath());

Gerar o método GetXmlCommentsPath com uma instrução idêntica à do exemplo seguinte

protected static string GetXmlCommentsPath()
          {
              return System.String.Format(@"{0}\bin\myWebApi.xml", 
                  System.AppDomain.CurrentDomain.BaseDirectory);
          }

Visualização da página de documentação Swagger

Voltar a executar a WebApi.
Ao executar a aplicação para depuração é apresentada a página inicial no navegador pré-definido.
Na barra de endereços do navegador, escrever o caminho para a documentação Swagger.

<url base>/Swagger/ui/index

O Swagger usa a documentação XML de cada operação:




Referências: Visual Studio 2017 and Swagger: Building and Documenting Web APIs, GitHub Swashbuckle Project

Video YouTube, Are You Ready For Blockchain?

O blockchain será a maior revolução tecnológica das últimas duas décadas e mudará para sempre a forma como os negócios operam

Tecnologia blockchain em artigo dedicado pela ITInsight aqui.

Ficarão os serviços da Cloud mais baratos do que um data center local?

Para calcular a diferença entre os custos de um data center local e os custos dos serviços da Cloud, estão disponíveis duas calculadoras em linha:

• Azure TCO Calculator
• Total Cost of Ownership Calculator
• Understand how cloud licensing works

Referência: 7 Concrete Ways the Cloud is Cheaper – With Examples, 5 mitos da nuvem segundo a Gartner