Como está a preocupação do ASPNET 5(Core) em relação a desempenho?

No vídeo abaixo, com data de 4 de novembro de 2015, Damian Edwards fala sobre o desempenho do ASP.NET. Tanto em relação o quão era ruim o ASP.NET 4.6 e inferiores e o quanto poderá ser bom o ASP.NET 5.

Talvez a motivação para essa preocupação seja o que foi citado no vídeo: o trabalho publicado no site https://www.techempower.com/benchmarks/ . A ideia do trabalho é :

"This is a performance comparison of many web application frameworks executing fundamental tasks such as JSON serialization, database access, and server-side template composition. Each framework is operating in a realistic production configuration. Results are captured on Amazon EC2 and on physical hardware. The test implementations are largely community-contributed and all source is available at the GitHub repository."

"Isto é fazer comparação de desempenho de várias frameworks de aplicação web executando tarefas fundamentais como serialização de JSON, acesso a base de dados, e composição para server-side template. Cada framework está operando numa configuração de produção realista. Resultados são capturados no Amazon EC2 e num hardware físico. As implementações de testes são amplamente contribuídas pela comunidade e todos os códigos estão disponívels no repositório GitHub."
(Tradução livre do autor)

No vídeo o Damian ainda cita todos os pontos que podem impactar no desempenho da aplicação:

• Startup Time (Tempo para carregar a aplicação
• Troughput (Quantas requisições minha aplicação por atender)
• Latency/Response Time (Afeta a experiência do usuário, quando você envia algo e espera o retorno do servidor)
• Scale (Concorrência)
• Working set (Sobrecarga de memória)

O Damian vem publicando resultados do trabalho no Github:
https://github.com/aspnet/benchmarks

Armazenando JSON no SQL Server

Evoluções no Microsoft SQL Server 2016

Bancos de dados NoSQL são alternativas que geram sentimentos muito além das análises técnicas. Aos defensores dos benefícios do banco de dados relacional, como o SQL Server, o sentimento é de aversão. Aos desenvolvedores de aplicações mobile, e qualquer outra que usa dados em JSON, podem ver o banco de dados NoSQL, como o MongoDb, como uma excelente alternativa.

Fato é que hoje há espaço para ambas opções e a escolha entre um ou outro pode variar de acordo com o tipo de projeto e demanda – a ideia deste post não é explorar os pontos fortes e fracos de cada um.

Ao navegar na internet buscando alguns artigos técnicos, achei este link, sobre a iniciativa da Microsoft de adicionar suporte ao JSON no SQL Server 2016:

http://blogs.msdn.com/b/jocapc/archive/2015/05/16/json-support-in-sql-server-2016.aspx

As palavras do Jovan Popovic é que suporte ao JSON no Sql Server é a demanda mais votada no Microsoft Connect Site:

“JSON support in SQL server is one of the most highly ranked requests with more than 1000 votes on the Microsoft connect site”

O suporte no armazenamento, a princípio, não terá evoluções, utilizando o tipo NVARCHAR. De toda forma há evoluções funcionalidades:

“our choice to start with FOR JSON and OPENJSON is the fact that these functionalities are requested in JSON connect item and probably only things that cannot be easily implemented with CLR”

Outras referências:

http://www.databasejournal.com/features/mssql/10-new-features-worth-exploring-in-sql-server-2016.html

http://www.infoq.com/news/2015/05/SQL-Server-JSON

Desenvolvedores armazenando JSON

Alguns desenvolvedores já estão buscando algumas soluções para armazenar JSON no Sql Server, com algumas soluções criativas, como estas:

http://www.reddnet.net/entity-framework-json-column/

http://stackoverflow.com/q/28307367/3424212

Automatizando teste de telas com o Selenium

Instalando o Selenium IDE no Firefox

Faça o download do selenium ide para firefox:

http://www.seleniumhq.org/download/

Selecione a última versão do plugin (XPI), em 30/9 é a 2.9.0. Ao clicar no link, pode ser exibida uma informação de segurança, clique em permitir, já que confiamos nessa publicação

O Selenium estará disponível para execução através do menu

Utilizando o Selenium IDE para gravação

Abra o Selenium IDE.

Defina a URL Base, do site que irá testar

Garanta que está em modo de gravação, vendo o botão de gravação.

Navegue normalmente no site, utilizando o Firefox, para gerar as ações que deseja automatizar.

Ao terminar, para interromper, clique no mesmo botão de gravação.

Verificações da página (selenese)

É possível fazer uma série de comandos no Selenium (Que são chamados selenese)

Como exemplos:

“In selenese, one can test the existence of UI elements based on their HTML tags, test for specific content, test for broken links, input fields, selection list options, submitting forms, and table data among other things. In addition Selenium commands support testing of window size, mouse position, alerts, Ajax functionality, pop up windows, event handling, and many other web-application features. ”

Tradução:

“In selenese, pode testar a existência de elementos de UI(Interface de Usuário) baseado nas suas tags HTML, testar por conteúdos específicos, testar por links quebrados, campos de entrada (input field), opções no controle de lista de seleção, enviar formulários, e tabela de dados entrou outras coisas. Em adição, comundos Selenium suportam teste de tamanho da janela, posição do mouse, alertas, funcionalidades Ajax, aqbertura de janelas, manipulação de eventos e vários outras funcionalidades de aplicações web. ”

Para utilizar visualmente, clique com o botão direito em qualquer conteúdo da página Web e selecione as opções ao fim do menu de contexto. Há uma opção sugerida e o “Exibir todos os comandos disponíveis”.

Na imagem abaixo foi verificar a existência de um texto em específico em um elemento. É possível localizar elementos de várias maneiras:

• Localizar por identificador
  Localiza pelo atributo Id, se não achar, busca peloa Name
• Localizar por id
  Localiza pelo atributo Id
• Localizar por Nome
  Localiza pelo atributo Name
• Localizar por DOM (Document Object Model)
  Referência: http://www.w3schools.com/js/js_htmldom.asp
• Localizar por Xpath
  Referência: http://www.w3schools.com/xsl/xpath_intro.asp
   Alguns complementos do Firefox para ajudar nessa geração:XPath Checker - sugere XPath e pode ser usado para testar resultados de XPath.
  Firebug – sugestões XPath dentre várias outras funcionalidades, como já citado neste post: http://aplicacoesweb.blogspot.com.br/search?q=firebug

• Localizar por Link e Teste

O Selenium IDE sugere uma localização do elemento, conforme imabem abaixo

 No xpath abaixo, se houver uma mudança do valor, haveria problema no teste.

 

Para isso, iremos fazer o comando ser apenas de seleção, garantindo que ache o elemento. É possível ver uma listagem com todos os comandos disponíveis

Para esse exemplo, iremos utilizar o comando verifyElementPresent com o xpath abaixo e limpar o campo “Valor”, garantindo que o elemento exista, já que o valor nesse caso muda com o tempo.

//div[@class="tile blue"]

É possível fazer teste buscando elementos não visuais, por exemplo, que o arquivo CSS está utilizando uma referência CDN(https://pt.wikipedia.org/wiki/Content_Delivery_Network) na página conforme abaixo:

Referência:

http://www.seleniumhq.org/docs/02_selenium_ide.jsp#selenium-commands-selenese

http://release.seleniumhq.org/selenium-core/1.0.1/reference.html

Salvando e Executando o teste

É possível salvar o teste é possível configurar a velocidade (Para reduzir a velocidade para acompanhar a execução a olhando), conforme imagem abaixo:

O resultado é mostrado na barra inferior e com a contagem de sucessos e erros

12 Dicas para otimizar desempenho de uma aplicação ASP.NET

Veja um artigo interessante com 13 dicas para melhorar o desempenho de aplicações ASP.NET. O Artigo fala que são 12 dicas, mas repete o número 6 para no começo do segundo post.

Os 13 tópicos são:

1. Kernel Mode Cache
2. Pipeline Mode (Opação do Clássico e Integrado) 
3. Remover Módulos não utilizados
4. runAllManagedModulesForAllRequests 
5. Não escrever nada no diretório c:\inetpub\wwwroot
6. Remover Motores de View e Linguagens não utilizadas
7. Fazer a página ser assincrono (No segundo artigo, as dicas começam repetindo a 6ª dica)
8. Suspensão do Pool de Aplicação
9. Remover métodos do Global.asax
10. Não usar o SqlDataSource
11. Usar o HTTP Keep Alive
12. Remover o ETag
13. Diversas outras configuração

Link Parte 1:
http://www.infragistics.com/community/blogs/devtoolsguy/archive/2015/08/07/12-tips-to-increase-the-performance-of-asp-net-application-drastically-part-1.aspx
Link Parte 2:
http://www.infragistics.com/community/blogs/brijmishra/archive/2015/08/21/12-tips-to-increase-the-performance-of-asp-net-application-drastically-part-2.aspx

Problemas de referências com o ASP.Net 5 Beta (CTP)

Não é difícil começar a ter problemas de referência ao utilizar o ASP.NET 5 Beta. Basta criar um projeto de class library para começar a ter erros como os abaixo. Se tiver erros como:
Error    CS0246    The type or namespace name 'List' could not be found (are you missing a using directive or an assembly reference?)
Deve resolver as dependências de projeto no project.json. No caso acima é possível resolver adicionando a seguinte dependência:

 "aspnetcore50": {  
      "dependencies": {  
           "System.Runtime": "4.0.20-beta-22523",  
           "System.Collections": ""  
      }  
 }  

Para estes erros, tive dificuldade em adicionar depedência ao MSCorLib:
Error    CS0115    'Classe.ToString()': no suitable method found to override
Error    CS0246    The type or namespace name 'ICloneable' could not be found (are you missing a using directive or an assembly reference?)
Seguindo esta dica do stacktrace (asp-net-core-5-0-error-cs0012-the-type-object-is-defined-in-assembly-mscorli), resolvi retirando toda definição da framework aspnetcore50. Segue como ficou o project.json final:

 {  
      "version": "1.0.0-*",  
      "dependencies": {  
      },  
      "frameworks": {  
           "aspnet50": {  
                "dependencies": {  
                },  
                "frameworkAssemblies": {  
                }  
           }  
      }  
 }  

Análise do Vídeo Web Api Advanced Design

Segue um post com anotações do vídeo abaixo que dá boas dicas avançadas de Web Api do Channel 9.

Parameter Binding (Vinculo de Parâmetros)

Parametros simples são passados pelaURI (Ou Querystring)

Parâmetros complexos são passados pelo corpo da requisição

É possível mudar esse comportamento definindo FromBody e FromURI nos parâmetros dos métodos de requisição, conforme exemplo:

 public IHttpActionResult PostIt([FromBody]string name, [FromUri]DemoVector vector)  
 {  

Fonte : https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/06%20-%20Advanced%20Design/06aParameterBinding/Controllers/VectorsController.cs

Typer Converters (Conversor de tipo)

Quando existe, trata tipos como simples

É possível criar um convertor explícito

https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/06%20-%20Advanced%20Design/06bTypeConverters/Models/DemoVectorConverter.cs

É possível decorar a classe com o tipo de conversor

Se você não tiver acesso a classe de conversão para decora-la, ainda é possível conforme abaixo:

 public static void Register(HttpConfiguration config)  
 {  
 ...  
   TypeDescriptor.AddAttributes(typeof (DemoVector),   
     new TypeConverterAttribute(typeof (DemoVectorConverter)));  
 }  

Fonte: https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/06%20-%20Advanced%20Design/06bTypeConverters/App_Start/WebApiConfig.cs

Model Binding (Vinculação de Modelo)

Solução mais específica que a conversão de tipo, que permite acesso ao HttpContext

 public IHttpActionResult ModelBinder([ModelBinder(typeof(DemoVectorModelBinder))]DemoVector vector)  

Fonte : https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/06%20-%20Advanced%20Design/06cModelBinders/Controllers/VectorsController.cs

Versioning (Versionamento)

Interessante fazer mesmo se a API é consumida internamente

Não há padrão, mas há várias formas de fazer:

· Colocar a versão como parte do caminho. Exemplo: /api/v1

· Colocar como parâmetro. Exemplo: /api/versions?version=v1

· Definir no parâmetro de cabeçalho “Accept”. Exemplo: application/v1+json

· Definir no cabeçalho de requisição. Exemplo: version 1.0

 [Route("api/things")]  
 [Route("api/v2/things")]  
 public IHttpActionResult GetV2()  
 {  
   return Request.GetVersion().Equals("v1", StringComparison.InvariantCultureIgnoreCase) ?   
     GetV1() : Ok(ThingRepository.Current.GetNew());  
 }  
 [HttpGet]  
 [Route("api/v1/things")]  
 public IHttpActionResult GetV1()  

Fonte: https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/06%20-%20Advanced%20Design/06dVersioning/Controllers/ThingController.cs

No exemplo acima, toda definição de qual método a ser utilizado está ficando definido em cada método. Ainda é possível herdar do DefaultHttpControllerSelector e fazer um versionamento de todo projeto.

Fonte: https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/06%20-%20Advanced%20Design/06dVersioning/Version/VersionControllerSelector.cs

Azure API Services

Prover uma plataforms de gerencimento do Web Api exposto

Referência para mais informações:

http://azure.microsoft.com/en-us/services/api-management/

Análise do Vídeo Web Api Security

Segue um post com anotações do vídeo abaixo que dá boas dicas para segurança de Web Api do Channel 9.

Authentication in the Host

Diferença entre Autenticação e Autorização

Authentication (Autenticação) para definir quem é você
Authorization (Autorização) para saber quais acessos você tem
A autenticação do Web Api é compartilhada com o MVC.
Referência com mais informações:
http://www.asp.net/web-api/overview/security/authentication-and-authorization-in-aspnet-web-api
Referência para os diferentes tipos de autenticações e formas de configurações:
http://www.asp.net/web-api/overview/security/individual-accounts-in-web-api

Authentication using Message Handlers

Exemplo de autenticação somente didática (que não deve ser usado em produção) utilizando o DelegatingHandler:
https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/05%20-%20Security/05bMessageHandlerAuthentication/Handlers/NaiveAuthHandler.cs

Token-based Authentication

Neste modelo:
· Autorização gera um Token
· Token dá acesso ao serviço
· Protege a senha que só é utilizada por uma parte terceira (Facebook, Google, Microsoft, Twitter etc)

• Token é passado no cabeçalho das requisições

Authorization Filters

Custom Authorization Filters (Filtro de autorização customizado)

Exemplo de filtro de Autorização somente didática (que não deve ser usado em produção)
https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/05%20-%20Security/05dAuthorizationFilter/Filters/NaiveAuthorizationFilter.cs

Role-based Authorization (Autorização baseada em perfil)

Definição da role baseada no que foi passado como usuário. Exemplo somente didático (que não deve ser usado em produção)
https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/05%20-%20Security/05eRoleBasedAuthorization/Filters/NaiveAuthorizationFilter.cs
Utilização do Metadadados Authorize especificando quais perfis - separados por vírgula “,” - tem permissão aos métodos do Controller
https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/05%20-%20Security/05eRoleBasedAuthorization/Controllers/WidgetsController.cs

Preventing Cross-Site Request Forgery

Cross-Site Request Forgery

Ataque Malicioso
Envio para o seu site através de sites terceiros
Tirar vantagem dos cookies gerados para os usuários
Para prevenir, utilizar anti-forgery token (tokan contra a falsificação)
Especialmente importante se vocês habilitar CORS (Cross origin resource sharing)

Mais informações sobre o assunto:
http://www.asp.net/web-api/overview/security/preventing-cross-site-request-forgery-%28csrf%29-attacks 
http://www.codeproject.com/Articles/793384/ASP-NET-Anti-Forgery-Tokens-internals

Implementação de verificação de Anti Forgery através do Handler:
https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/05%20-%20Security/05fAntiForgery/Handlers/AntiForgeryHandler.cs

Análise do Vídeo Web Api Validation and Error Handling

Segue um post com anotações do vídeo abaixo que dá boas dicas para validação e manipulação de erro de Web Api do Channel 9.

Status Code (Código de Status)

Forma padrão de comunicação do HTTP.

200 – OK

201 – Created

404 – Not Found

Lista com todos os status:

http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html

http://www.w3schools.com/tags/ref_httpmessages.asp

Model Validation

Data Annotations

Adicionando em propriedades para ajudar na validação

· Tipos primitivos validados por padrão

• Range
  Exemplo de validação utilizando Range para limitar a idade de 1 até 120:
  https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/04%20-%20Validation%20and%20Error%20Handling/04aModelValidation/Models/User.cs
• Required
• CreditCard
• E-mail
• Todas as opções disponíveis:
  https://msdn.microsoft.com/en-us/library/system.componentmodel.dataannotations%28v=vs.110%29.aspx

Validações Customizadas

Exemplo de validação customizada utilizando o ModelState.AddModelError() e ModelState.IsValid
https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/04%20-%20Validation%20and%20Error%20Handling/04aModelValidation/Controllers/UsersController.cs

Built-in Helpers

Na classe anscestral ApiController há metodos para ajudar no retorno do HTTP, já definindo o HttpStatusCode (Código de status da requisição HTTP)

Alguns exemplos citados:

• Conflict
• Created
• CreatedAtRoute
• InternalServerError
• NotFound
• Ok

Nesta página há todos disponíveis:

https://msdn.microsoft.com/en-us/library/system.web.http.apicontroller_methods%28v=vs.118%29.aspx

E nesta página do GitHub vários exemplos de funcionamento:

https://github.com/MicrosoftLearning/WebAPIDesign/blob/master/04%20-%20Validation%20and%20Error%20Handling/04aModelValidation/Controllers/HelpersController.cs

Exception Filters

Artigo sobre a manipulação de erro através do Exception Filters:

http://www.asp.net/web-api/overview/error-handling/exception-handling

Global Exception Logger and Handling (Manipulação e registro de exceções globais)

Artigo sobre Manipulação e registro de exceções globais:

http://www.asp.net/web-api/overview/error-handling/web-api-global-error-handling

Análise do Vídeo Web Api Configuration

Segue um post com anotações do vídeo abaixo que dá boas dicas para configuração de Web Api do Channel 9.

Media Formatter (Formatador de Mídia)

• Media type = MIME type

• text/html, application/xml, application/json

• Cabeçalhos
• Accept = o que o cliente quer
• Content-Type = o que o server retorn

• Formatos padrões : XML, JSON, BSON(JSON binários), form-encoded
• É possível criar formatos customizados e foi mostrado um exemplo de um que retornava um csv (comman separated value) que pode ser aberto em excel
• SerializerSettings pode definir várias configurações como ContractResolver (para definir o CamelCase)

Routes and Actions

· Citada a forma de definar a rota, parecida com a do MVC
· Possibilidade de definir os parâmetros e valores esperados
· Mostrado o esquema abaixo e resolução de controller e action

Attributes Actions

A forma de roteamento anterior leva em consideração o tipo de actions e parâmetros para escolher o método correto do controller para executar. Isso pode ser confuso.
Para dar mais controle do que é executado é possível utilizar o Attribute Action, que permite marcar qual o roteamento esperado pelo controller e pelo método.
Os dois fontes dessa pasta mostram as diferenças de utilização:
https://github.com/MicrosoftLearning/WebAPIDesign/tree/master/03%20-%20Configuration/03bRoutingActions/Controllers

Análise de vídeo Web Api Basic Design

Segue um post com anotações do vídeo abaixo que dá boas dicas para Design de Web Api do Channel 9.

Abaixo segue alguns pontos importantes que anotei ao ver o vídeo:
São mostrados exemplos de Design da disponibilização de Web Api como recursos, citando o Twitter, Azure e Github.

São citados os principais métodos do HTTP para utilização no RestFul:

1. Get: retorno de informações
2. Put: atualizações de registros
3. Post: inserções de registros
4. Delete: exclusão de registros

Abaixo métodos que estão disponíveis no Rest Easy

Citou a importância de permitir transações que devem ser feitas atomicamente por chamada ao servidor (obviamente, o servidor deve ser stateless, ou sem estado). Num exemplo de transferência bancária, não pode ser feito com duas chamadas de subtração de uma conta e adição em outra – já que o cliente pode cair deixando a equação inconsistente. Dessa forma, deve ser pensado num único serviço a ser chamado no Web api que internamente faz as duas operações dentro de uma transação.

Outro conceito interessante compartilhado foi para a comunicação ser "Chunky" e não “Chatty”. A ideia de ser Chunky ou robusto, é retornar toda a informação necessária numa única requisição ao servidor. A ideia de ser Chatty ou conversador é retornar um mínimo de informação que demanda nova chamada ao servidor – mas em aplicação multicamada, este custo pode ser demasiado.
https://depts.washington.edu/ontheroa/?p=343

Negociação de conteúdo
Um bom servidor Restful deve estar preparado para diferentes saídas e adaptá-la conforme requisição do cliente.

Repare que o retorno do servidor de Wep Api está variando conforme cabeçalho accept enviado.

Ferramentas para ajudar em testes

Microsoft ASP.NET Web API Help Page
Para gerar documentação de todas as Web Apis dinamicamente. Em 13/4/2015 não dá suporte ao MVC 6.

Fiddler
Um proxy depurador web para qualquer navegador.
Mostrou a funcionalidade Composer, que pode fazer requisições HTTML e a facilidade de repetir requisições feitas com possibilidade de modificar alguns valores, conforme prints abaixo

 Clicar com o botão direito / Replay / Reissue from composer:

Fonte de toda série: https://github.com/MicrosoftLearning/WebAPIDesign

Introdução ao Web API no ASP.NET 5 (vNext) MVC 6

Neste artigo irei explorar o Web API, seguindo dicas de diversos artigos citados nas referências
Inicie o Visual Studio 2015

Neste post estou utilizando a versão:
Microsoft Visual Studio Ultimate 2015 Preview
Version 14.0.22310.1 DP
Microsoft .NET Framework
Version 4.5.53349

Caso não tem o Visual Studio 2015, baixe aqui.

Inicie um novo projeto “ASP.NET 5 Starter Web” conforme prints abaixo:

Entendendo o projeto ASP.NET 5 Starter Web

O projeto inclui os seguintes arquivos de configuração já devidamente:

• global.json : contém configurações da solução e permite referências entre projetos
• project.json : contém configurações do projeto
• packages.json: contém configurações para os pacotes NPM
• Startup.cs : contém código de inicialização e configurações que detalharei abaixo

Project.json

O Project.json tem as seguintes definições [2]:

• Dependencies (Dependências): que são definidos por nome e versão e no Visual Studio tem ajuda do intellisense conforme prints abaixo
 

 

• Configurations (Configurações): são grupos de configurações para compilações do projeto. Há 2 por padrão (Debug, Release), mas outros podem ser criados
• Frameworks: definições de versão da framework a ser utilizada
• Sources (Fontes): Define quais arquivos devem ser incluídos e compilados

o Há várias chaves para esta seção, como exclude, packExclude

• WebRoot (Raiz web): Define qual o diretório raiz da aplicação que é público na web
• Commands: comandos que podem ser executados através da linha de comando (No caso do Windows o cmd.exe) e que precisam de prévia instalação do KVM (K Version Manager) [3]

Startup

A classe Startup definida no arquivo startup.cs contém a definição de pipeline de requisição do ASP.NET. Ela substitui o Global.asa e Global.asax existentes em versões anteriores, conforme Shawn Wildermuth [4].
No construtor Startup são carregadas as informações de configurações do config.json e de ambiente. O config.json também substitui o antigo web.config.
Há dois outros métodos:

• ConfigureServices: configura as injeções de dependências
• Configure: configura a aplicação, inclusive entre os diferentes ambientes

Entendendo a configuração do Web Api

Para usar o Web API é necessário adicionar a dependência do AspNet.MVC 6. Neste exemplo há disponível a versão "6.0.0-beta1".

Depois no Startup.cs é necessário adicionar o seguinte using:

 using Microsoft.Framework.DependencyInjection;  

Depois configure o MVC conforme abaixo:

 public void ConfigureServices(IServiceCollection services)  
 {  
   // Add MVC services to the services container.  
   services.AddMvc();  

E configure o uso do MVC conforme abaixo:

 public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerfactory)  
 {  
   app.UseMvc(routes =>  
   {  
     routes.MapRoute(  
       name: "default",  
       template: "{controller}/{action}/{id?}",  
       defaults: new { controller = "Home", action = "Index" });  
   });  

Adicionando o Web Api

Iremos criar um Web Api expondo uma lista de tarefa. Para isso, precisamos criar a classe modelo TodoItem
https://github.com/mqueirozcorreia/MVC6WebApi01Sample/blob/master/src/MVC6WebApi01/Models/TodoItem.cs
Depois vamos criar a interface ITodoRepository do repositório de Todo.
https://github.com/mqueirozcorreia/MVC6WebApi01Sample/blob/master/src/MVC6WebApi01/Models/ITodoRepository.cs
Depois vamos implementar o repositório.
https://github.com/mqueirozcorreia/MVC6WebApi01Sample/blob/master/src/MVC6WebApi01/Models/TodoRepository.cs
Finalmente, vamos implementar o TodosController
https://github.com/mqueirozcorreia/MVC6WebApi01Sample/blob/master/src/MVC6WebApi01/Controllers/TodosController.cs 
 
Repare que o Controller criado utiliza a injeção de dependência pelo construtor, conforme abaixo:

 private readonly ITodoRepository _repository;  
 public TodosController(ITodoRepository repository)  
 {  
   _repository = repository;  
 }  

Para que essa injeção de dependência funcione, precisamos antes configura-la no Startup.ConfigureServices, conforme abaixo:

   // Injeções de dependência da aplicação  
   services.AddSingleton<ITodoRepository, TodoRepository>();  
 }  

Visualizando o Web Api

Feitas todas as configurações e codificações, execute a aplicação

Um navegador será aberto e adicione ao fim da Url o caminho do serviço do TodosController:
http://localhost:59304/api/todos
A porta (59304), pode variar conforme configurações do seu projeto.
A requisição da url acima vai acionar o método TodosController. GetAll e mostrar o resultado abaixo em formato XML:

Há vários plug-ins para ajudar a testar serviços Rest como o Rest Easy do Firefox e o Postman do Chrome. Com ele é possível configurar por exemplo o cabeçalho “Accept” para informar que aceita “application/json” e ver que o Web Api faz o retorno adaptado para JSON, se fazer nenhuma alteração no código da aplicação:

Veja o fonte final:

https://github.com/mqueirozcorreia/MVC6WebApi01Sample

Referências

1. http://www.asp.net/vnext/overview/aspnet-vnext/create-a-web-api-with-mvc-6
2. https://github.com/aspnet/Home/wiki/Project.json-file
3. http://www.asp.net/vnext/overview/aspnet-vnext/vc#cnp
4. http://wildermuth.com/2015/03/02/A_Look_at_ASP_NET_5_Part_2_-_Startup

O ASP.NET Boilerplate

Vale a pena conhecer o projeto ASP.NET Boilerplate que se diz projetado para ajudar no desenvolvimento de aplicações usando melhores práticas e sem nos repetir (Don’t Repeat Yourself – DRY).
O ASP.NET Boilerplate foi projetado e desenvolvido pelo Halil İbrahim Kalkan que também conta com alguns contribuintes, na página do projeto do GitHub é possível reparar que há uma boa dedicação através dos commits:

O projeto tem os princípios [3] de:
1. Ser modularizado através de pacotes que possam ser facilmente compartilhados preferencialmente através do Nuget
2. Seguir melhores práticas para ter código mais entendível e extensível
3. Código Base Escalável mantendo um código fácil de ser mantido, principalmente utilizando camadas e modularização
4. Combinar e usar bibliotecas e frameworks para realizar tarefas bem conhecidas, evitando reinventar as horas
5. Assuntos transversais como autorização, validação, manipulação de erros, fazer log e fazer cache são tarefas comuns para todas aplicações
6. Mais automação no que for possível como migração de banco de dados, testes unitários e distribuição
7. Convenção de configuração para facilitar definições padrões e especificar diferenças
8. Inicialização de novos projetos fácil e rápida
Para aprender detalhes sobre o projeto o Kalkan criou vários artigos no CodeProject passando mais informações [4] [5] [6] e uma boa documentação [7]

NLayer (Multicamadas)

Fonte : http://aspnetboilerplate.com/Pages/Documents/NLayer-Architecture acesso em 4/4/2015
1. Infrastructure Layer
a. Entity Framework ou NHibernate
b. Repositório para abstrair a dependência do Entity Framework
2. Domain Layer
a. Entities (Entidades)
classe base para toda entidade de domínio e que há heranças e interfaces para implementação de auditoria de criação, alteração
b. Repositories (Repositórios)
"Intermediação entre a camada de domínio e de mapeamento de dados, usando uma interface do tipo de coleção para acessar objetos de domínio" (Martin Folwer) Tradução livre do autor deste artigo
O ASP.NET Boilerplate implementa interfaces e classes bases para diminuir, ainda assim é possível criar repositórios customizados.
As conexões a dados e as transações são controladas por UnitOfWork (Unidades de trabalho) [8]
c. Unit of Work (Unidade de Trabalho)
Automatismos para controle de conexão, transação. Há ainda a opção de programar eventos da unidade de trabalho para Completed, Failed e Disposed.
d. Domain Events & EventBus(Eventos de Domínio)
Num desenvolvimento winforms é possível criar eventos em classes e utiliza-los durante a instância da class na aplicação. No desenvolvimento web como os objetos tem pequena duração, já que é durante apenas a requisição, a programação de eventos é feita através do EventBus, que é um objeto singleton e compartilhado entre todas outras classes.
3. Application Layer
a. Serviços de Aplicação (Application Services)
Utilizado para expor lógica de domínio para a camada de apresentação. Utiliza a injeção de dependência e Unidade de Trabalho para apoiar nos serviços a serem expostos. Todo serviço da aplicação, diferentemente do repositório, deve ser explicitamente criado herdando da interface IApplicationService .
b. Data Transfer Objects (Objetos de transferência de dados)
Utilizados para transferir dados da camada de aplicação para a camada de apresentação. A documentação [9] sobre DTO ainda explica os benefícios de não expor diretamente o domínio na camada de aplicação, como facilidade de refatoração. Ainda é mostrado a utilização do AutoMapper
c. Validação de DTO
Há várias validações para o InputDTO (Objeto de Transferência de dados de entrada), utilizado como entrada de métodos de serviço de aplicação, por DataAnnotations (System.ComponentModel.DataAnnotations namespace). Ainda é possível implementar a interface ICustomValidate para uma validação mais complexa. Há também a interface IShouldNormalize para normalizar o InputDTO antes da utilização nos métodos.
4. Web
5. Presentation Layer
a. Dynamic Web API Layer
O ASP.NET Boilerplate pode criar dinamicamente serviços web api baseados nos serviços de aplicação. Também é criado proxies javascript dinamicamente para acesso aos serviços. [10]
b. Javascript API
O ASPNET Boilerplate utiliza várias APIs para facilitar o desenvolvimento de javascripts:

1. Ajax
2. Notification
3. Message
4. UI Block / Busy
5. Logging

c. Localization
d. Navigation
O ASP.NET Boilerplate permite a criação de menu nos módulos de servidores e são reutilizados no cliente com a criação de API javascript dinamicamente [11]
e. Handling exceptions
f. Embedded resource files

Injeção de dependências (Dependency Injection)

O ASP.NET Boilerplate implementa a injeção de dependências através do Castle Windsor, e há na documentação [12] uma explicação dos benefícios de se utilizar através da injeção por construtor (quando a dependência é obrigatória na utilização de toda a classe) ou injeção por propriedade (quando a dependência é opcional e pode ser desabilitada por padrão, nos exemplos de logs). A Injeção de dependência ainda facilita a aplicação de testes unitários.

Log

O ASP.NET Boilerplace utiliza a injeção de dependência e a interface ILogger do Castle. Por padrão é utilizado o Log4Net.

ASP.NET Boilerplate e o Nuget

O ASP.NET Boilerplace é distribuído através do nuget. Além da Framework, há o Module Zero(para autorização, usuários, perfis e o Test Base (para criar testes unitários e de integração)

Criando a aplicação de um modelo

Esta parte do artigo é uma versão otimizada e baseada nos artigos do Kalkan [4] [5]
Para iniciar a aplicação visite a página de modelos. A primeira opção é entre SPA (Single Page Application, Aplicação de página única com AngularJS ou Durandal) e MPA (Multiple Page Application, aplicação de páginas múltiplas com o MVC).
Após isso é possível escolher o ORM entre Entity Framework ou NHibernate.
Escolha um nome para a aplicação, como AplicacoesWeb e clique em “Create My Project”.

O arquivo baixado está em formato Zip e ao baixa-lo e descompacta-lo ele terá a seguinte estrutura:

Crie a base de dados “AplicacoesWeb” num SQL Server 2008 ou posterior em instância padrão, ou modifique a conexão padrão no web.config.
Abra o projeto no Visual Studio 2013 e aperte F5. A aplicação será iniciada e um navegador será aberto.
Se acontecer o erro abaixo (A project with an Output Type of Class Library cannot be started)

Selecione o projeto “AplicacoesWeb.Web” e o defina como projeto de inicialização (Set as StartUp Project)

Criando as entidades

No projeto AplicacoesWeb.Core crie as classes de Domínio Task (Tarefa), Person (Pessoa) e o enumerado TaskState (Estado da tarefa).

Criando os repositórios

O ASP.NET Bolierplate já implementa repositórios padrões para toda entidade, mas adicionaremos um repositório padrão para cada entidade

Camada de Infraestrutura

ASP.NET Boilerplate template criou um DbContext com o nome AplicacoesWebDbContext para nos ajudar. Basta agora adicionar os IDbSets para Task e Person.

Migração (No caso, a criação da base de dados inicial)

Vamos utilizar o método Configuration.Seed para adicionar alguns registros para a tabela People.
Para criar a migração atualizando a base de dados conforme classes dos nossos domínios, abra o Package Manager Console, configure o projeto padrão como AplicacoesWeb.EntityFramework e execute o comando “add-migration InitialCreate” conforme print abaixo:

Uma classe é criada na pasta Migrations e para persistir as alterações na base de dados, basta executar o comando “update-database”, adicione o parâmetro opcional –verbose caso queira ver os comandos que estão sendo executados (O que é muito útil para identificar problemas):

 Ao executar o comando anterior com sucesso, as tabelas foram criadas na base de dados:

Implementação de Repositórios

Devemos implementar a interface ITaskRepository, e para isso criamos a classe TaskRepository, descendendo de no projeto AplicacoesWeb.EntityFramework e na pasta EntityFramework/Repositories.

Camada de Aplicação

A camada de aplicação deve implementar todos os serviços que serão expostos para a camada de apresentação. Para isso, crie todas estas classes e interfaces:

• CreateTaskInput
• GetAllPeopleOutput
• GetTasksInput
• GetTasksOutput
• IPersonAppService
• ITaskAppService
• PersonAppService
• PersonDto
• TaskAppService
• TaskDto
• UpdateTaskInput

WebApi Controller Dinâmicos

Os serviços de aplicativos são consumidos pela camada de apresentação. Em um aplicativo de página única (SPA – Single Page Application), todas os dados são enviados e recebidas usando AJAX entre javascript e o servidor. ABP simplifica a chamada a um método de serviço de aplicação criando o WebApi Controller dinamicamente e o proxy javascript na aplicação
Com esse código é o serviço de Task e de Person está exposto:
DynamicApiControllerBuilder .ForAll<IApplicationService>(typeof(AplicacoesWebApplicationModule).Assembly, "app").Build();.

Camada de Apresentação

Criar a pasta:
AplicacoesWeb.Web\App\Main\views\task\
Adicionar os arquivos
task\list.cshtml
task\list.js
task\new.cshtml
task\new.js
Adicionar o menu no método AplicacoesWebNavigationProvider. SetNavigation as chamadas para o novo menu.
Adicionar as novas localizações para os novos menus no “AplicacoesWeb.xml”

Fonte final:

Veja o fonte final:
https://github.com/mqueirozcorreia/aspnetboilerplatePTSample/

Referências

1. http://blogs.msdn.com/b/webdev/archive/2014/05/13/asp-net-vnext-the-future-of-net-on-the-server.aspx
2. https://www.devbridge.com/articles/entity-framework-6-vs-nhibernate-4/
3. http://aspnetboilerplate.com/About
4. http://www.codeproject.com/Articles/768664/Introduction-to-ASP-NET-Boilerplate
5. http://www.codeproject.com/Articles/791740/Using-AngularJs-ASP-NET-MVC-Web-API-and-EntityFram
6. http://www.codeproject.com/Articles/871786/Unit-testing-in-Csharp-using-xUnit-Entity-Framewor
7. http://aspnetboilerplate.com/Pages/Documents
8. http://aspnetboilerplate.com/Pages/Documents/Unit-Of-Work
9. http://aspnetboilerplate.com/Pages/Documents/Data-Transfer-Objects
10. http://aspnetboilerplate.com/Pages/Documents/Dynamic-Web-API
11. http://aspnetboilerplate.com/Pages/Documents/Navigation
12. http://aspnetboilerplate.com/Pages/Documents/Dependency-Injection
13. http://aspnetboilerplate.com/

Reutilização na Microsoft através de pacotes

Reutilização na Microsoft através de Pacotes

O desenvolvimento web evolui num ritmo que a própria Microsoft cria várias formas de liberar novidades e evoluções do ASP.NET sem depender exclusivamente de novas Frameworks, ou mesmo exclusivamente de seus pacotes. Para citar dois exemplos de como a Microsoft tem repensado isso:
1.    O Nuget, que é um gerenciador para a produção e utilização de pacotes. Com ele é possível buscar, instalar e atualizar pacotes facilmente
2.    O vNext vem para criar uma dependência mínima da Framework (O MVC 6 não terá dependência do System.Web [1]) não t, tanto para otimizar requisições ao site, quanto para permitir buscar evoluções de pacotes, por exemplo via nuget, num ritmo mais rápido do que são liberadas as Frameworks
Se havia uma grande diferença para o desenvolvimento Java e .Net, uma vez que ambas têm em comum serem ótimas opções e com muitos conceitos parecidos, era que a Microsoft muitas vezes direcionava suas escolhes. Precisava de acesso a dados? ADO.Net. Precisa de um ORM? Pense no EntityFramework (Claro que o NHibernate já tinha e tem seu espaço).
A mudança da Microsoft de pensar em pacotes reutilizáveis, vai começar a fazer seus desenvolvedores a pensarem nas diversas opções existentes. Uma consulta no Nuget em 1/4/2014 é possível encontrar 34.496 pacotes únicos (Verdadeiramente um grande menu de opções)

Com tantas opções, qual devo escolher? 

Várias são as perguntas ao se pensar em criar um novo projeto Web.
1.    Lado Server
a.    Qual a framework Web?
b.    Qual a framework para mapeamento objeto-relacional (Object Relational Mapper – ORM)?
c.    Como será disponibilizado os serviços HTTP? Será Restful?
d.    Será usada algum framework de injeção?
e.    Qual o facilitador para logs?
f.    Qual o facilitador para mapeamento de objetos?
2.    Lado Cliente
a.    Qual a Framework HTML/CSS?
b.    Qual o manipulador de DOM?
c.    Qual biblioteca e utilitário para interface do usuário?
Várias são as perguntas e as opções. Pensando que a opção escolhida para Framework Web seja o ASP.NET, há duas principais opções para o ORM: EntityFramework e o NHibernate.
Mesmo querendo avaliar somente duas opções há vários pontos a serem analisados. Há diversos artigos sobre o tema ao se pesquisar no Google e outro complicador: mesmo uma análise completa, como a do Darius Kucinskas[2] em janeiro de 2014, está sujeita a ficar desatualizada pela rápida evolução dos projetos.
Outra forma útil é analisar a popularidade através do Google Trends. Não quer dizer que a escolha mais popular é a melhor, mas é mais um dos pontos a avaliar, até mesmo uma possível tendência. Veja abaixo um comparativo do Google Trends sobre Entity Framework x NHibernate em 01/04/2014:

 Veja abaixo um comparativo do Google Trends sobre AngularJS, KnockoutJS e Durandal em 01/04/2014: