Engenho &amp; Engenhocas

Agile Framework Imagem Projecto

Critérios para detalhar User Stories

Para ler

Carreira

Queimar até à exaustão - Saúde Segurança e Higiene no trabalho

Para ler

Azure Cloud Desenvolvimento Imagem

Azure API Gateway

Para ler

Um sistema Azure que fornece APIs a aplicações externas deve usar uma Gateway para essas APIs, a Azure API Gateway. A API Gateway permite organizar e publicar as APIs do sistema, públicas ou protegidas, disponibilizando-as a programadores, parceiros, clientes e mesmo clientes internos se for caso disso. A API Gateway tem a infra-estrutura e monitorização necessárias à disponibilização de uma API mediante pagamento.

A Gateway deve ser pensada como proxy ou nível de indirecção entre os clientes e as operações de todas as APIs.

A Gateway tem um portal que pode ser usado para publicar, gerir e monitorizar as APIs do sistema, e um outro portal para os clientes se autenticarem, criarem as suas chaves de acesso, reportar incidentes ou problemas e ler a documentação das APIs.

Pré-requisitos

Pressupõe-se a criação de Azure Function do tipo HTTP Trigger com o nível de autorização configurado com o valor Function.
No exemplo, GetName.

public static class GetName
    {
        [FunctionName("GetName")]
        public static async Task<HttpResponseMessage> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)]HttpRequestMessage req, TraceWriter log)
        {
            log.Info("C# HTTP trigger function processed a request.");

            // parse query parameter
            string name = req.GetQueryNameValuePairs()
                .FirstOrDefault(q => string.Compare(q.Key, "name", true) == 0)
                .Value;

            // Get request body
            dynamic data = await req.Content.ReadAsAsync<object>();

            // Set name to query string or body data
            name = name ?? data?.name;

            return name == null
                ? req.CreateResponse(HttpStatusCode.BadRequest, "Please pass a name on the query string or in the request body")
                : req.CreateResponse(HttpStatusCode.OK, "Hello " + name + ", you are great!");
        }
    }

Pressupõe-se a criação de uma instância de API Management do Azure. Para exemplo, testingapisclopes.

Criação da definição OpenAPI (Swagger)

Depois de testar a função, seleccionar a opção Integrate da nova função e indicar os verbos HTTP permitidos.
Na Function App desta nova função, seleccionar Platform Features e API Definition. É apresentada a página para definição da API (Swagger) idêntica à seguinte. Na API Definition, seleccionar o valor Function.

Seleccionar Generate API definition template > Save.

O Azure varre a Function App à procura das funções do tipo HTTP Trigger e usa a informação do functions.json para gerar a definição OpenAPI.
Uma vez gerada a template da definição, completa-se com os metadados das operações e das estruturas de dados e grava-se.

Testar a OpenAPI

Na opção Manage da nova função, copiar a chave definida por omissão (default key) para as chaves do host (Host Keys).
Voltar à página de Definição da API (Function App Name > Platform features > API definition) e no painel da direita seleccionar change authentication, colar a chave definida por omissão e seleccionar authenticate.
Testar a operação através da acção Try this operation e verificar o output.

Importação da API para o API Management

Como a Function App está protegida por uma chave, há que criar uma entrada do tipo Named Value e aplicar a política set-query-parameter policy para que a chave seja adicionada automaticamente quando a Function App é invocada a partir do APIM. A Gestão de APIs distingue as APIs pelo respectivo sufixo. Por exemplo, functionappapi.

Testar a nova API APIM no portal do Azure

Seleccionar a API recém criada, escolher o separador Test e seleccionar o método a testar. GetName, por exemplo. A página apresenta os campos para os parâmetros de consulta, como por exemplo name. A página também apresenta os campos para os cabeçalhos. Um dos campos de cabeçalho é "Ocp-Apim-Subscription-Key", para a chave de subscrição do produto que está associado esta API. Quem cria a instância APIM é administrador por omissão, pelo que a chave é automaticamente preenchida.
Uma vez conferidos os campos, seleccionar Send.
O Back-end responde com 200 OK e o corpo da resposta.

Testar a nova API APIM no portal do Programador

Seleccionar a API a testar e o método a testar. A página também apresenta os campos para os cabeçalhos. Um dos campos de cabeçalho é "Ocp-Apim-Subscription-Key", para a chave de subscrição do produto que está associado esta API. Quem cria a instância APIM é administrador por omissão, pelo que a chave é automaticamente preenchida.
Depois de conferidos os campos, seleccionar Try It.
Uma vez invocada a operação, o portal do programador apresenta o status da resposta, os cabeçalhos da resposta e o corpo ou conteúdo da resposta.

Exemplo de pedido HTTP

GET https://testingapisclopes.azure-api.net/functionappapi/api/GetName?name=48 HTTP/1.1
Host: testingapisclopes.azure-api.net
Ocp-Apim-Subscription-Key: fc1767dcf0b448ce9c9d6d3cfcea5739

Referências: Import an API from a Function App now available in the APIs blade, Create an OpenAPI definition for a function, Importar e publicar a sua primeira API

ASP.NET Desenvolvimento Framework Web

Desabilitar caixa de selecção em ASP.NET Web Forms

Para ler

A framework ASP.NET Web Forms está orientada para a programação declarativa e baseada em controlos, à semelhança das WinForms e WPF/XAML/Silverlight.

Os controlos renderizam o HTML automaticamente e podem ser personalizados ou customizados através da configuração de propriedades e estilos.

O controlo nativo <asp:checkbox runat="server"></asp:checkbox> renderiza o HTML <input type="checkbox" />.

Problema

Apresentar a caixa de selecção apenas para leitura poderia ser conseguido através da propriedade readonly do controlo, assim

<asp:checkbox id="CheckBox1" readonly="true" runat="server"></asp:checkbox>

no entanto, resulta no seguinte HTML

<span readonly="true"><input id="CheckBox1" name="CheckBox1" type="checkbox" /></span>

que não desabilita a caixa de selecção.

Solução

Juntar ao controlo a propriedade enabled com o valor false.

<asp:checkbox enabled="false" id="CheckBox1" runat="server"></asp:checkbox>

renderiza o seguinte HTML

<span disabled="disabled"><input disabled="disabled" id="CheckBox1" name="CheckBox1" type="checkbox" /></span>

Teste

Referências: ASP.NET Overview, HTML <input /> Tag

Engenhocas Estratégia

Nova estrutura de silício abre portões aos computadores quânticos

Para ler

Carreira Transformação Digital

Trabalhadores desenvolvem competências digitais pelos próprios meios

Para ler

ASP.NET Backbone.js Framework Imagem Web

Backbone.js sem espinhas em ASP.NET Web Forms

Para ler

Backbone.js - A espinha dorsal de aplicações web from Henrique Gogó

Backbone.js é uma biblioteca MV* de JavaScript com uma interface JSON RESTful e permite preparar as aplicações JS com uma espinha dorsal de Models, Views, Collections e Events resolvendo vários problemas do código esparguete ou spaghetti code.

Exemplo de uma lista de Hellos

index.html


<!DOCTYPE HTML>
<html>
<head>
    <title>Hello World Part 2</title>
    <meta charset="UTF-8">
</head>

<body>
    <div class="wrapper">

        <h1>Greetings</h1>

        <div id="otherDiv"></div>

        <ul id="helloListWithTemplate">
            <script type="text/template" id="hello-template">
                Hello, {{name}}
            </script>
        </ul>
       
    </div>

    <!-- JQuery Backbone.js -->
    <script src="Scripts/jquery-3.2.1.min.js"></script>
    <script src="Scripts/libs/underscore-1.8.3.min.js"></script>
    <script src="Scripts/libs/backbone-1.3.3.min.js"></script>
    <script src="Scripts/grettings.js"></script>

</body>
</html>

grettings.js (dados locais em memória)


// Backbone.js
$(document).ready(function () {

    ///
    ///Model Class Area
    ///
    var Hello = Backbone.Model.extend({

        idAttribute: 'id',

        defaults: function () {
            return {
                id: "",
                name: "default"
            };
        }

    });


    ///
    ///Collection Class Area
    ///
    var HelloList = Backbone.Collection.extend({
        model: Hello,

    });



    ///
    ///View Class Area
    ///

    var HelloViewUsingTemplate = Backbone.View.extend({

        tagName: 'li',

        model: Hello,

        templateSettings: _.templateSettings = {
                      interpolate : /\{\{(.+?)\}\}/g
                      evaluate : /\{(.+?)\}/g; 
                     };

        //template: _.template($('#hello-template').html()),

        template: $("#hello-template").html(),

        render: function () {

            //$(this.el).html(this.template(this.model.attributes));

            var local_template = _.template(this.template);
            this.$el.html(local_template(this.model.attributes));

            return this;
        }

    });

    var HelloListViewUsingTemplate = Backbone.View.extend({

        el: '#helloListWithTemplate',

        initialize: function () {

            this.render();

        },

        render: function () {
            this.$el.html();

            this.collection.each(function (helloModel) {

                var helloViewUsingTemplate = new HelloViewUsingTemplate({
                    model: helloModel
                });

                this.$el.append(helloViewUsingTemplate.render().el);

            }.bind(this));

            return this;

        }

    });



    ///
    ///Model instances Area
    ///

    var helloCollection = new HelloList([{ "id": 1, "name": "Local value 1" }, { "id": 2, "name": "Local value 2" }, { "id": 3, "name": "Local value 3" }], { model: Hello });

    //create a new hello collection view instance
    var hellolistviewusingtemplate = new HelloListViewUsingTemplate({
        collection: helloCollection
    });


    //JQuery
    $('#otherDiv').html('This line does nothing.
');

});

Relacionado: Backbone.js sem espinhas

Referência: Introduction to Backbone.js, Using Underscore.js with ASP.NET

Engenhocas Estratégia Imagem

Linux on Galaxy

Para ler

ASP.NET Backbone.js Framework Imagem Web

Backbone.js sem espinhas

Para ler

Exemplo de uma lista de Hellos

index.html


<!DOCTYPE HTML>
<html>
<head>
    <title>Hello World Part 2</title>
    <meta charset="UTF-8">
</head>

<body>
    <div class="wrapper">

        <h1>Greetings</h1>

        <div id="otherDiv"></div>

        <ul id="helloListWithTemplate">
            <script type="text/template" id="hello-template">
                Hello, <%= name %>
            </script>
        </ul>
       
    </div>

    <!-- JQuery Backbone.js -->
    <script src="Scripts/jquery-3.2.1.min.js"></script>
    <script src="Scripts/libs/underscore-1.8.3.min.js"></script>
    <script src="Scripts/libs/backbone-1.3.3.min.js"></script>
    <script src="Scripts/grettings.js"></script>

</body>
</html>

grettings.js (dados locais em memória)


// Backbone.js
$(document).ready(function () {

    ///
    ///Model Class Area
    ///
    var Hello = Backbone.Model.extend({

        idAttribute: 'id',

        defaults: function () {
            return {
                id: "",
                name: "default"
            };
        }

    });


    ///
    ///Collection Class Area
    ///
    var HelloList = Backbone.Collection.extend({
        model: Hello,

    });



    ///
    ///View Class Area
    ///

    var HelloViewUsingTemplate = Backbone.View.extend({

        tagName: 'li',

        model: Hello,

        //template: _.template($('#hello-template').html()),

        template: $("#hello-template").html(),

        render: function () {

            //$(this.el).html(this.template(this.model.attributes));

            var local_template = _.template(this.template);
            this.$el.html(local_template(this.model.attributes));

            return this;
        }

    });

    var HelloListViewUsingTemplate = Backbone.View.extend({

        el: '#helloListWithTemplate',

        initialize: function () {

            this.render();

        },

        render: function () {
            this.$el.html();

            this.collection.each(function (helloModel) {

                var helloViewUsingTemplate = new HelloViewUsingTemplate({
                    model: helloModel
                });

                this.$el.append(helloViewUsingTemplate.render().el);

            }.bind(this));

            return this;

        }

    });



    ///
    ///Model instances Area
    ///

    var helloCollection = new HelloList([{ "id": 1, "name": "Local value 1" }, { "id": 2, "name": "Local value 2" }, { "id": 3, "name": "Local value 3" }], { model: Hello });

    //create a new hello collection view instance
    var hellolistviewusingtemplate = new HelloListViewUsingTemplate({
        collection: helloCollection
    });


    //JQuery
    $('#otherDiv').html('This line does nothing.');

});

grettings.js (API RESTful)


// Backbone.js
$(document).ready(function () {

    ///
    ///Model Class Area
    ///

    var Hello = Backbone.Model.extend({

        idAttribute: 'id',

        defaults: function () {
            return {
                id: "",
                name: "default"
            };
        }

    });


    ///
    ///Collection Class Area
    ///
    var HelloList = Backbone.Collection.extend({
        model: Hello,

        url: function () { return '/api/Values'; }
    });



    ///
    ///View Class Area
    ///

    var HelloViewUsingTemplate = Backbone.View.extend({

        tagName: 'li',

        model: Hello,

        //template: _.template($('#hello-template').html()),

        template: $("#hello-template").html(),

        render: function () {

            //$(this.el).html(this.template(this.model.attributes));

            var local_template = _.template(this.template);
            this.$el.html(local_template(this.model.attributes));

            return this;
        }

    });

    var HelloListViewUsingTemplate = Backbone.View.extend({

        el: '#helloListWithTemplate',


        render: function () {
            this.$el.html();

            this.collection.each(function (helloModel) {

                var helloViewUsingTemplate = new HelloViewUsingTemplate({
                    model: helloModel
                });

                this.$el.append(helloViewUsingTemplate.render().el);

            }.bind(this));

            return this;

        }

    });



    ///
    ///Model instances Area
    ///

    var helloCollection = new HelloList(null, { model: Hello });
    helloCollection.reset();

    //create a new hello collection view instance
    var hellolistviewusingtemplate = new HelloListViewUsingTemplate({
        collection: helloCollection
    });


    helloCollection.fetch({

        success: function () {

            hellolistviewusingtemplate.render();

        }

    });


    //JQuery
    $('#otherDiv').html('This line does nothing.');

});

Usando a ASP.NET Web API, juntar ao App_Start\WebApiConfig.cs

config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

Referência: Introduction to Backbone.js

Analítica Estratégia IA

Nova geração de assistentes pessoais virtuais em 2018

Para ler

Carreira Estratégia Vídeo

Manager vs. Leader

Para ler

Azure Caching Cloud Desenvolvimento Ferramenta Framework IDE Visual Studio

Redis Caching

Para ler

Redis é um motor de base de dados em memória com armazenamento baseado em tabelas de hash (key-value).

O cliente .NET StackExchange.Redis é amplamente usado pelas suas características votadas à alta performance e foi desenvolvido pela equipa da Stack Exchange. Documentação completa do cliente StackExchange.Redis aqui.

Instalação dos clientes da cache

Instalação pela consola NuGet

PM> Install-Package StackExchange.Redis

ou para projectos strong-named

PM> Install-Package StackExchange.Redis.StrongName

Ligação à cache

Incluir a bilbioteca StackExchange.Redis

using StackExchange.Redis;

A ligação à Cache do Redis é gerida pela classe ConnectionMultiplexer. Esta classe deve ser partilhada e reutilizada em toda a aplicação cliente e não precisa de ser criada para cada operação.

ConnectionMultiplexer connection = ConnectionMultiplexer.Connect(<connectionstring>);

Exemplo de connection string Azure

<azure redis cache id>.redis.cache.windows.net:6380,password=<pwd>,ssl=True,abortConnect=False

Se não se pretender utilizar o protocolo SSL, definir ssl=false ou omitir o parâmetro ssl.
O abortConnect está definido como falso, o que significa que a chamada terá êxito mesmo se não for estabelecida uma ligação à Cache do Redis do Azure. Uma funcionalidade-chave do ConnectionMultiplexer consiste no restauro automático da conectividade à cache assim que o problema de rede ou outros problemas tiverem sido resolvidos.

Uma abordagem para partilhar uma instância ConnectionMultiplexer consiste em ter uma propriedade estática que devolva uma instância ligada, tal como no exemplo seguinte. Esta abordagem fornece uma forma segura para as threads de modo a inicializar apenas uma única instância ConnectionMultiplexer ligada.

private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
        {
            return ConnectionMultiplexer.Connect(ConfigurationManager.ConnectionStrings["RedisCache"].ConnectionString);
        });

        public static ConnectionMultiplexer Connection
        {
            get
            {
                return lazyConnection.Value;
            }
        }

Documentação detalhada da configuração do cliente StackExchange.Redis aqui

Para ser colocado em cache, o objecto .NET tem de ser serializado.

Uma forma simples de serializar objectos passa por utilizar os métodos de serialização JsonConvert da framework Newtonsoft.Json.NET e serializar de e para JSON.
Documentação da framework Json.NET aqui.

Instalação pela consola NuGet

PM> Install-Package Newtonsoft.Json

Incluir a bilbioteca Newtonsoft.Json

using Newtonsoft.Json;

Uma alternativa é usar uma extensão como o StackExchange.Redis.Extender que trata da serialização de e para JSON do StackExchange.Redis. Projecto disponível aqui.

Exemplo de Utilização

Adcionar ao App.config

<connectionStrings>
    <add name="RedisCache" connectionString="<azure redis cache id>.redis.cache.windows.net:6380,password=<pwd>,ssl=True,abortConnect=False"/>
  </connectionStrings>

Obtenção das credenciais

System.Configuration.ConfigurationManager.ConnectionStrings["RedisCache"].ConnectionString);

POCO

 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 int AuthorId { get; set; }
        public bool IsBeginnerCourse
        {
            get { return Level == 1; }
        }
        public virtual Author Author { get; set; }
    }

Método AddAuthor

 static Author AddAuthor()
        {

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

Invocação

static void Main(string[] args)
        {
            IDatabase cache = Connection.GetDatabase();
            IEnumerable authors;

            var cAuthorKey = "authors";

            RedisValue lstAuthors = cache.StringGet(cAuthorKey);

            if (!lstAuthors.HasValue)
            {
                authors = new List<Author> { AddAuthor() };

                cache.StringSet(cAuthorKey, value: JsonConvert.SerializeObject(authors, Formatting.Indented), expiry: TimeSpan.FromMinutes(2));
            }
            else
            {
                Console.WriteLine("Cache hit");
                authors = JsonConvert.DeserializeObject<IEnumerable<Author>>(lstAuthors);
            }

            foreach (var author in authors)
            {
                Console.WriteLine(author.Name);
            }

            Console.Read();

        }

Referências: Como Utilizar a Cache de Redis do Azure, Azure: Redis Cache

Para instalação local do servidor Redis ver artigo Distributed Caching using Redis Server with .NET/C# Client

Desenvolvimento Ferramenta Logging

NLog: logging mais fácil

Para ler

O NLog é uma plataforma de log para .NET, NETSTANDARD, Xamarin e Silverlight. O NLog torna mais fácil a produção e gestão de logs de alta qualidade para qualquer aplicação, independentemente do tamanho ou complexidade.

Características de Destaque

O NLog pode escrever cada mensagem de log dinamicamente para um ou vários destinos em simultâneo. Existem também destinos wrapper que permitem buffering, load balacing, situações de failover e escrita assíncrona.

O NLog pode processar mensagens de diagnóstico em qualquer linguagem .NET, formatadas e enviadas para várias saídas de destino. A lista de destinos está explanada na wiki. Ficheiro, Consola, Base de Dados, E-mail, Log de Eventos e ASP.NET trace são os destinos mais utilizados. Esta plataforma suporta a criação de destinos customizados.

A configuração pode ser feita tanto por ficheiro .config como programaticamente.

Instalação

Instalação com pacote NuGet

PM> Install-Package NLog.Config

Para instalação manual, seguir as instruções aqui.

Exemplo de Utilização

Exemplo de NLog.config

<?xml version="1.0" encoding="utf-8" ?>
<nlog xmlns="http://www.nlog-project.org/schemas/NLog.xsd"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.nlog-project.org/schemas/NLog.xsd NLog.xsd"
      autoReload="true"
      throwExceptions="false"
      internalLogLevel="Off" internalLogFile="c:\temp\nlog-internal.log">

  <variable name="logDirectory" value="${basedir}/logs"/>

  <!--
  See https://github.com/nlog/nlog/wiki/Configuration-file
  for information on customizing logging rules and outputs.
   -->
  <targets>

    <target name="console" xsi:type="ColoredConsole"
      layout="${date:format=HH\:mm\:ss}|${level}|${stacktrace}|${message}" />
      
    <target name="async" xsi:type="AsyncWrapper" queueLimit="5000" overflowAction="Discard">
        <target xsi:type="File" name="f" fileName="${logDirectory}/${shortdate}.log"
            layout="${longdate} ${uppercase:${level}} ${message}" keepFileOpen="false" encoding="UTF-16" />
    </target>
  
  </targets>

  <rules>
    <logger name="*" minlevel="Debug" writeTo="async" />
    <logger name="*" levels="Info,Warn" writeTo="console" />
  </rules>
</nlog>

Exemplo de classe com escrita para log com a biblioteca NLog

using NLog;
using System;

namespace logging.app.NLog
{
    class Program
    {
        //It is advised to create one (private static) Logger per class.
        private static Logger logger = LogManager.GetCurrentClassLogger();

        static void Main(string[] args)
        {

            int k = 42;
            int l = 100;

            logger.Trace("Sample trace message, k={0}, l={1}", k, l);
            logger.Debug("Sample debug message, k={0}, l={1}", k, l);
            logger.Info("Sample informational message, k={0}, l={1}", k, l);
            logger.Warn("Sample warning message, k={0}, l={1}", k, l);
            logger.Error("Sample error message, k={0}, l={1}", k, l);
            logger.Fatal("Sample fatal error message, k={0}, l={1}", k, l);
            logger.Log(LogLevel.Info, "Sample informational message, k={0}, l={1}", k, l);

            Console.ReadLine();
        }
    }
}

Outputs Produzidos

Escrita para consola

Escrita para ficheiro

Referência: Projecto NLog

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

Unit-of-Work & Repository Framework aplicada a DDD

Para ler

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

Carreira Transformação Digital

A empresa atractiva para as novas gerações

Para ler

ASP.NET Desenvolvimento Ferramenta Framework Imagem Projecto REST Visual Studio Web

Gerar especificação de API REST com Swagger

Para ler

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

Analítica Big Data Blockchain Estratégia Vídeo

Prontos para o blockchain?

Para ler

Cloud Estratégia Ferramenta

A Cloud é mais barata?

Para ler

Engenhocas Estratégia Imagem

Boeing compra Aurora Flight Sciences

Para ler

Engenhocas Estratégia Ferramenta Windows

R.I.P. Windows Mobile

Para ler

Azure Cloud Desenvolvimento Formação

.NET Developer on Azure

Para ler

Analítica Cloud Estratégia

Impacto da Densidade Digital no crescimento da economia

Para ler

Azure Cloud Desenvolvimento IDE Imagem Visual Studio

Depurar Azure Functions com VS 2017 Cloud Explorer

Para ler

Azure Cloud Desenvolvimento IDE Imagem

Depurar Azure Functions com Visual Studio Code

Para ler

Este exercício aplica-se a função despoltada por pedido HTTP (HTTP Triggered Function).

Uma função deste tipo pode ser testada usando a extensão REST Client do Visual Studio Code desenvolvida por Huachao Mao e disponível aqui. Esta extensão permite efectuar pedidos HTTP tanto locais como remotos usando o botão direito do rato.

Passos deste exercício:
Instalar o Visual Studio Code

Instalar a extensão REST Client

Criar um novo ficheiro com o nome test-function-locally.http

Adicionar o seguinte código para pedido HTTP a uma função como nome HttpTrigger:

get http://localhost:7071/api/HttpTrigger

get http://localhost:7071/api/HttpTrigger?name=Tyto

Seleccionar a linha de código a testar e com o botão direito do rato seleccionar Send Request.

O painel da direita apresenta a resposta HTTP do servidor, tanto o cabeçalho como o corpo da mensagem.

Relacionado: Desenvolvimento local de Azure Functions

Referência: Create an Azure Functions HTTP trigger with an Azure Cosmos DB input binding

Desenvolvimento IDE Imagem Software Patterns Visual Studio

Using Event Aggregator Pattern, a message hub made simple

Para ler

Tenho usado o Event Aggregator em UI para sincronização e comunicação indirecta entre user controls/views e entre controllers/presenters. Mas pode ser usado em variadas situações.

Ao introduzir um agregador de eventos entre publishers e subscribers, consegue-se baixo acoplamento. O subscriber observa o agregador de eventos em vez do publisher e o publisher por sua vez apenas sabe acerca do agregador de eventos e não sabe nada sobre os subscribers.

Um agregador simples

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

A subscrição

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
    }

Wrapper do agregador

public static class Messages
    {

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

        }

    }

Exemplo de Invocação

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

Implementações de Event Aggregator:

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

Referências: Simple message-based Event Aggregator, Implementing the Singleton Pattern in C#, Why Use an Event Aggregator?

Azure Cloud Desenvolvimento Ferramenta IDE Imagem Vídeo Visual Studio

Desenvolvimento local de Azure Functions

Para ler

Azure Functions é uma solução "das nuvens" para processamento de dados, integração de sistemas, IoT, APIs e microserviços.

O Portal Azure tem um conjunto de ferramentas para desenvolvimento e testes de Azure Functions, mas as funções podem ser desenvolvidas localmente no Visual Studio 2017.

Instalação das Azure Functions Core Tools

Azure Functions Core Tools é a versão local do runtime da cloud para Azure Functions e equipa o Visual Studio 2017 desde a versão 15.3.

Verificar a extensão:

O caminho para a func.exe da das Azure Functions é idêntico a este

C:\Users\<username>\AppData\Local\Azure.Functions.Cli\1.0.0\func.exe

Instalação do Azure Storage Emulator

O emulador pode ser instalado a partir daqui. Para instalar o emulador são necessários privilégios de administração.

Instalação do Azure Storage Explorer

O Azure Storage Explorer pode ser usado para trabalhar com os recursos do emulador. Depois de iniciado o emulador, a árvore do Storage Explorer apresenta "(Development)" na ramificação de "Storage Accounts".

Criação da Queue myqueue-items

Criação do projecto local

Configuração do ambiente local

No PowerShell mudar para o directório do projecto e executar o comando

func settings add AzureWebJobsStorage UseDevelopmentStorage=true

ou juntar ao local.settings.json a seguinte parametrização

"AzureWebJobsStorage": "UseDevelopmentStorage=true"

O aspecto final da configuração local será idêntico ao seguinte:

{
  "IsEncrypted": false,
  "Values": {
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",
    "AzureWebJobsDashboard": ""
  },
  "ConnectionStrings": {},
  "Host": {
    "LocalHttpPort": 7071,
    "CORS": "*"
  }
}

Execução local das Azure Functions

Iniciar a depuração carregando F5.

Azure Functions em acção

Video YouTube, Azure Functions Visual Studio Tooling

Referências: Getting Started With Azure Functions, Visual Studio 2017 Tools for Azure Functions, Setting up Azure Storage for local develop of timer or queue triggered Azure Functions, Publishing a .NET class library as a Function App