Arquivo de maio, 2015

ASP NET – RAZOR Templates – MVC – C#

Publicado: 27 de maio de 2015 em C#

O Framework ASP.NET MVC possibilita que você economize muito tempo no desenvolvimento de suas aplicações simplesmente utilizando os templates do Razor. O Razor possui uma gama de templates que permite que você crie de um modo simples todas as operações comuns no acesso a dados de sua aplicação conhecidas popularmente como CRUD. Utilizando seus próprios modelos, o Razor cria vários templates, como os de lista, onde você pode visualizar todos os dados de uma maneira geral, como também já lhe proporciona todos os links para as Views onde você pode utilizar os templates também para criar, editar, apagar e mostrar detalhes de um registro em especial.

Usando os templates do Razor

1 – Crie uma aplicação ASP.NET MVC. Crie um novo controlador com as ações de leitura e escrita chamado CursosController. Note que os dados ainda não são acessados do banco de dados e sim estão escritos estaticamente na aplicação apenas para este exemplo:

MVC - Controller

MVC – Controller

2 – Crie um novo modelo chamado CursosModelo:

MVC - Modelo

MVC – Modelo

3 – Adicione uma nova View para o controlador chamada Index e no seu assistente de criação, preencha o template como LIST e adicione o seu modelo. A View irá criar todo o código básico e você pode customiza-lo como desejar:

MVC - View

MVC – View

4 – Use os códigos abaixo pra completar o seu código gerado automaticamente e rode sua aplicação. Você deverá receber o seguinte resultado:

MVC - Razor Template

MVC – Razor Template

Exemplo:

Neste exemplo utilizamos o template de lista da visão do Razor para exibir dados na página da aplicação. Você pode ver que todos os links são funcionais entretanto ainda não criamos uma visão para cada um deles.

C#

Modelo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace WebApplication1.Models
{
    public class CursosModelo
    {
        // Propriedades
        public int Id { get; set; }
        public string Curso { get; set; }
        public string Linguagem { get; set; }
        public string Dia { get; set; }
        public string hora { get; set; }

    }
}

Visão

@model IEnumerable<WebApplication1.Models.CursosModelo>

@{
    ViewBag.Title = "Desenvolvimento Aberto - Cursos";
}

<h1>Desenvolvimento Aberto</h1>
<h2>Cursos</h2>

<p>
    @Html.ActionLink("Create New", "Create")
</p>
<table class="table">
    <tr>
        <th>
            @Html.DisplayNameFor(model => model.Curso)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.Linguagem)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.Dia)
        </th>
        <th>
            @Html.DisplayNameFor(model => model.hora)
        </th>
        <th></th>
    </tr>

@foreach (var item in Model) {
    <tr>
        <td>
            @Html.DisplayFor(modelItem => item.Curso)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.Linguagem)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.Dia)
        </td>
        <td>
            @Html.DisplayFor(modelItem => item.hora)
        </td>
        <td>
            @Html.ActionLink("Edit", "Edit", new { id=item.Id }) |
            @Html.ActionLink("Details", "Details", new { id=item.Id }) |
            @Html.ActionLink("Delete", "Delete", new { id=item.Id })
        </td>
    </tr>
}

</table>

Controlador

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using WebApplication1.Models;

namespace WebApplication1.Controllers
{
    public class CursosController : Controller
    {
        // GET: Cursos
        public ActionResult Index()
        {
            var modelo =
                from r in _cursos
                orderby r.Id
                select r;

            return View(modelo);
        }

        // GET: Cursos/Details/5
        public ActionResult Details(int id)
        {
            return View();
        }

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

        // POST: Cursos/Create
        [HttpPost]
        public ActionResult Create(FormCollection collection)
        {
            try
            {
                // TODO: Add insert logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        // GET: Cursos/Edit/5
        public ActionResult Edit(int id)
        {
            return View();
        }

        // POST: Cursos/Edit/5
        [HttpPost]
        public ActionResult Edit(int id, FormCollection collection)
        {
            try
            {
                // TODO: Add update logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        // GET: Cursos/Delete/5
        public ActionResult Delete(int id)
        {
            return View();
        }

        // POST: Cursos/Delete/5
        [HttpPost]
        public ActionResult Delete(int id, FormCollection collection)
        {
            try
            {
                // TODO: Add delete logic here

                return RedirectToAction("Index");
            }
            catch
            {
                return View();
            }
        }

        // Lista estatica enquanto ainda não utilizamos banco de dados
        // Lista alimenta os dados para nossa pagina

        static List<CursosModelo> _cursos = new List<CursosModelo>
        {
            new CursosModelo {
                Id =1,
                Curso = "ASP.NET MVC",
                Linguagem = "C#",
                Dia = "Segunda",
                hora = "8:00"
            },

            new CursosModelo {
                Id =2,
                Curso = "Web Dynpro MVC",
                Linguagem = "ABAP",
                Dia = "Terça",
                hora = "8:00"
            },

            new CursosModelo {
                Id =3,
                Curso = "Ruby on Rail",
                Linguagem = "Ruby",
                Dia = "Quarta",
                hora = "8:00"
            },

            new CursosModelo {
                Id =4,
                Curso = "Django",
                Linguagem = "Python",
                Dia = "Quinta",
                hora = "8:00"
            },

            new CursosModelo {
                Id =1,
                Curso = "Java EE MVC",
                Linguagem = "Java",
                Dia = "Sexta",
                hora = "8:00"
            }
        };

    }
}

 

Anúncios

ASP NET – Action Filters – MVC – C#

Publicado: 23 de maio de 2015 em C#

Na grande maioria das vezes é útil utilizar filtros em nossas aplicações para que possamos especificar determinados tipos de regras para acesso as nossas páginas ASP.NET. Os filtros em ASP.NET se encontram em vários lugares diferentes como por exemplo o filtro que manipula erros que pode ser localizado na pasta App_Start na classe FilterConfig, este é um lugar para se configurar os filtros globais para toda a aplicação. Por outro lado as vezes necessitamos de filtros mais específicos como filtros que podem ser aplicados em um controlador inteiro ou somente em determinadas ações de um controlador. Para isto o ASP.NET MVC nos proporciona alguns atributos que nos permitem filtrar determinadas ações sobre os controladores, eles são:

  • OutputCacheRepresenta um atributo que é usado para marcar um método de ação cuja produção será armazenada em cache.
  • ValidadeInputRepresenta um atributo que é usado para marcar os métodos de ação, cuja entrada deve ser validada.
  • AuthorizeEspecifica que o acesso a um método de controlador ou ação é restrita a usuários que atendem ao requisito de autorização.
  • ValidateAntiForgeryTokenRepresenta um atributo que é utilizado para prevenir a falsificação de um pedido.
  • HandleErrorRepresenta um atributo que é usado para tratar uma exceção que é lançada por um método de ação.

Ao longo dos posts vamos utilizar vários filtros de ações, por enquanto para entender sua funcionalidade, vamos apenas utilizar o filtro de autorização em sua forma mais básica.

Authorize: https://msdn.microsoft.com/en-us/library/system.web.mvc.authorizeattribute(v=vs.118).aspx

Usando Filtros de Ação

1 – Crie uma aplicação ASP.NET MVC usando o Template padrão. Crie um novo controlador e uma nova rota usando os códigos abaixo e rode sua aplicação:

ASP.NET MVC - Home

ASP.NET MVC – Home

2 – Use ou comente o atributo de autorização no controlador e na ação para ver seu resultado. O atributo de autorização sem nenhum tipo de parâmetro necessita que o usuário esteja autorizado através de um login na aplicação. Como ainda não utilizamos a tela de login do Template você será redirecionado a esta tela assim que tentar acessar o seu controlador ou ação. Digite o nome do seu controlador (Programas) na URL manualmente para tentar acessa-lo:

MVC - Autorização

MVC – Autorização

Exemplo:

Neste exemplo criamos um controlador e uma rota. Utilizamos um filtro de ação para que o usuário seja obrigado a estar autorizado a usar o controlador ou ação para acessar seu conteúdo.

C#

Rota

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MeuMVC
{
    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Cria uma nova rota para o controlador

            // Define controlador e parâmetros
            routes.MapRoute("Programas", "programas/{linguagem}",
                new { controller = "Programas", action = "Indice", 
                    
                    // Parâmetro opcional
                    linguagem =  UrlParameter.Optional
                     
                });

            routes.MapRoute(
                name: "Default", 
                
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }
}

Controlador

using MeuMVC.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MeuMVC.Controllers
{
    // Você pode utilizar um filtro de ação no nivel do controlador
    // ou de qualquer ação de um controlador

    // Comente ou não o código abaixo para mudar a restrição para o nivel do controlador
    // [Authorize]
    public class ProgramasController : Controller
    {
        // Utiliza parâmetro diretamente na ação definida na rota.
        // A autorização faz com que o acesso seja restringido a certos usuários ou regras.

        // Comente ou não o código abaixo para mudar a restrição para o nivel da ação
        [Authorize]
        public ActionResult Indice(string linguagem)
        {
            // Exibe Mensagem
            var mensagem = "Linguagem: " + Server.HtmlEncode(linguagem);                          
            
            return Content(mensagem);
        }   
       
    }
}

 

A maioria das linguagens de programação possuem o recurso de sobrecarregar métodos conhecido como Overrride. Uma sobrecarga nada mais é do que possuir o mesmo método com parâmetros diferentes, esta técnica é muito útil e amplamente utilizada por vários frameworks escritos em varias linguagens diferentes. Em C# podemos sobrecarregar métodos a qualquer momento, sempre quando necessário, no entanto o framework ASP.NET MVC cria algumas regras básicas para sobrecarregar ações em seus controladores. Estás regras serão amplamente utilizadas em toda sua aplicação, principalmente na manipulação de dados. Para sobrecarregar ActionResults em seus controladores você precisa especificar o método HTTP e utilizar um atributo especifico que necessita ser diferente para cada método sobrecarregado, por exemplo, podemos ter uma ação para o método POST e uma ação do mesmo nome para o método GET, assim como outros métodos HTTP.

HttpGetAttribute: https://msdn.microsoft.com/en-us/library/system.web.mvc.httpgetattribute(v=vs.118).aspx HttpPostAttribute: https://msdn.microsoft.com/en-us/library/system.web.mvc.httppostattribute(v=vs.118).aspx

Usando Atributos para Sobrecarregar Ações de Resultados

1 – Crie uma aplicação ASP.NET MVC usando o Template padrão, crie um novo controlador e uma nova rota para o controlador, utilize os códigos abaixo para referencia:

MVC - Controlador e Rota

MVC – Controlador e Rota

2 – Na a página inicial utilize a URL e o parâmetro criado na rota manualmente para acessar o método GET e assim a sua ação de resultados correspondente:

MVC - Atributo GET

MVC – Atributo GET

Você pode criar uma chamada utilizando o método POST na pagina principal para testar a sua ação sobrecarregada. Exemplo: Neste exemplo criamos um controlar e sua respectiva rota. Sobrecarregamos o método da ação de resultado para que seja executado somente para o tipo de método HTTP no qual necessitamos.

C#

Rotas

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MeuMVC
{
    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Cria uma nova rota para o controlador

            // Define controlador e parâmetros
            routes.MapRoute("Programas", "programas/{linguagem}",
                new { controller = "Programas", action = "Indice", 
                    
                    // Parâmetro opcional
                    linguagem =  UrlParameter.Optional
                     
                });

            routes.MapRoute(
                name: "Default", 
                
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }
}

Controlador

using MeuMVC.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MeuMVC.Controllers
{
    public class ProgramasController : Controller
    {
        // Utiliza parâmetro diretamente na ação definida na rota.
        
        // Sobrecarga de métodos de ação de resultado
        // O Atributo HTTP é necessario para a sobrecarga

        
        [HttpGet]
        public ActionResult Indice(string linguagem)
        {
            // Exibe Mensagem
            var mensagem = "Linguagem: " + Server.HtmlEncode(linguagem);                          
            
            return Content(mensagem);
        }

        [HttpPost]
        public ActionResult Indice()
        {
            // Exibe Mensagem           
            return Content("Este resultado utiliza o método POST");
        }
       
    }
}                        

No ASP.NET tradicional nós podemos utilizar a instrução chamada QueryString para obter uma coleção de variáveis de string de consulta HTTP. Nas variáveis de cadeia de consulta enviada pelo cliente, as chaves e valores são descodificados na URL. Isto quer dizer que QueryString retorna os valores dos clássicos parâmetros usados na URL que utilizamos para consultas HTTP.  No ASP.NET MVC não precisamos utilizar a instrução QueryString para obter os valores dos parâmetros em uma pesquisa, podemos defini-los diretamente na rota da URL e utiliza-los diretamente na ação do controlador.

Você utiliza o MapRoute para mapear suas rotas, esse membro é um membro sobrecarregado. Para obter informações completas sobre esse membro, incluindo sintaxe, uso e exemplos, clique em um nome na lista de sobrecarga encontrada no link abaixo.

MapRoute: Mapeamento de Rotas

Utilizando Parâmetros nas Rotas

1 – Crie um novo projeto ASP.NET MVC utilizando o Template padrão e rode sua aplicação. Volte para o Visual Studio e no arquivo de rotas crie uma nova rota, e defina o parâmetro chamado linguagem,  defina o controlador  e sua ação de resultado. Crie um novo controlador chamado ProgramasController.cs e preencha sua ação, utilize o código abaixo em seus respectivos arquivos.

ASP.NET MVC - Home

ASP.NET MVC – Home

2 – Você pode digitar o nome do seu controlador para acionar a rota e exibir a mensagem ao usuário:

MVC  - Rota - Programas

MVC – Rota – Programas

3 – Você pode adicionar um parâmetro na URL no qual criamos anteriormente, a ação executara a QueryString automaticamente, e reconhecerá o parâmetros utilizado e o retornará para que seja exibido na página.

MVC - QueryString

MVC – QueryString

Exemplo:

Neste exemplo utilizamos o parâmetro da rota e o recuperamos na ação de resultado do controlador.

C#

RouteConfig.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;

namespace MeuMVC
{
    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Cria uma nova rota para o controlador

            // Define controlador e parâmetros
            routes.MapRoute("Programas", "programas/{linguagem}",
                new { controller = "Programas", action = "Indice", 
                    
                    // Parâmetro opcional
                    linguagem =  UrlParameter.Optional
                     
                });

            routes.MapRoute(
                name: "Default", 
                
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
            );
        }
    }
}

ProgramasController.cs

using MeuMVC.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MeuMVC.Controllers
{
    public class ProgramasController : Controller
    {
        // Utiliza parâmetro diretamente na ação definida na rota.
        public ActionResult Indice(string linguagem)
        {
            // Exibe Mensagem
            var mensagem = "Linguagem: " + Server.HtmlEncode(linguagem);                          
            
            return Content(mensagem);
        }
       
    }
}

O MongoDB é um banco de dados open-source de documentos projetado para facilidade de desenvolvimento e de escalabilidade, isto significa que o MongoDB fornece alto desempenho, alta disponibilidade e escala automática. Um registro em MongoDB é um documento, que é uma estrutura de dados composta de pares de campo e valor. Documentos MongoDB são semelhantes aos objetos JSON. Os valores dos campos podem incluir outros documentos, matrizes e matrizes de documentos.

MongoDB fornece persistência de dados de alto desempenho, pois o suporte para modelos de dados incorporados reduz a atividade de E/S no sistema de banco de dados e seus índices suportam consultas mais rápidas e podem incluir chaves de documentos e matrizes embutidos. Para proporcionar alta disponibilidade, facilidade de replicação, o MongoDB conta com um recurso chamado conjuntos de réplicas, um conjunto de réplicas é um grupo de servidores MongoDB que mantêm o mesmo conjunto de dados, proporcionando redundância para aumentar a disponibilidade de dados. MongoDB oferece escalabilidade horizontal, como parte de sua funcionalidade principal, que conta com a partilha automática de dados distribuídos em um cluster de máquinas. O conjuntos de réplicas também pode fornecer, eventualmente, leitura consistente para implementações de alto rendimento de baixa latência.

A instância MongoDB armazena seus arquivos de dados em \data\db\ é necessário criar este diretório.

MongoDB: https://www.mongodb.org/

Instalando o MongoDB no Windows

1 – Após baixar o instalador clique em executar:

MongoDB - Bem vindo

MongoDB – Bem vindo

2 – Aceite a licença e clique em próximo:

MongoDB - Licença

MongoDB – Licença

3 – Escolha instalação completa clicando no botão Complete:

MongoDB - Completa

MongoDB – Completa

4 – clique em instalar:

MongoDB - Instalar

MongoDB – Instalar

5 – Aguarde o andamento da instalação:

MongoDB - Andamento

MongoDB – Andamento

6 – Ao termino da instalação clique em finalizar:

MongoDB - Finalizar

MongoDB – Finalizar

7 – Para iniciar o MongoDB você precisa configurar o diretório de dados chamado \data\db e depois inicializar o servidor, use a figura abaixo como referencia:

MongoDB - Inicia Servidor

MongoDB – Inicia Servidor

 

Se tudo correu bem, você deve obter uma mensagem dizendo que o  banco foi iniciado e está ouvindo na porta default 27017.

O MongoDB é um banco de dados open-source de documentos projetado para facilidade de desenvolvimento e de escalabilidade, isto significa que o MongoDB fornece alto desempenho, alta disponibilidade e escala automática. Um registro em MongoDB é um documento, que é uma estrutura de dados composta de pares de campo e valor. Documentos MongoDB são semelhantes aos objetos JSON. Os valores dos campos podem incluir outros documentos, matrizes e matrizes de documentos.

MongoDB fornece persistência de dados de alto desempenho, pois o suporte para modelos de dados incorporados reduz a atividade de E/S no sistema de banco de dados e seus índices suportam consultas mais rápidas e podem incluir chaves de documentos e matrizes embutidos. Para proporcionar alta disponibilidade, facilidade de replicação, o MongoDB conta com um recurso chamado conjuntos de réplicas, um conjunto de réplicas é um grupo de servidores MongoDB que mantêm o mesmo conjunto de dados, proporcionando redundância para aumentar a disponibilidade de dados. MongoDB oferece escalabilidade horizontal, como parte de sua funcionalidade principal, que conta com a partilha automática de dados distribuídos em um cluster de máquinas. O conjuntos de réplicas também pode fornecer, eventualmente, leitura consistente para implementações de alto rendimento de baixa latência.

A instância MongoDB armazena seus arquivos de dados em /var/lib/ mongo e seus arquivos de log em /var/log/ mongodb por padrão, e é executado usando a conta de usuário mongod. Você pode especificar log e arquivos de dados em diretórios alternativos /etc/mongod.conf.

MongoDB: https://www.mongodb.org/

Instalando o MongoDB no SLEs ou openSuse

1 – Instalar o MongoDB é rápido e fácil, abra o terminal e digite o seguinte comando para adicionar os pacotes ao repositório:

sudo zypper addrepo --no-gpgcheck http://repo.mongodb.org/zypper/suse/11/mongodb-org/3.0/x86_64/ mongodb
MongoDB - Repositorio

MongoDB – Repositório

2 – Use o comando abaixo para instalar o MongoDB:

sudo zypper install mongodb-org
MongoDB - Instalar

MongoDB – Instalar

3 – Para iniciar o MongoDB você precisa de direitos do super usuário, digite as instruções abaixo para iniciar o banco de dados:

su
service mongod start
MongoDB - inicia banco de dados

MongoDB – inicia banco de dados

4 – Para confirmar se o banco de dados foi iniciado corretamente digite o seguinte comando para ver seu log, você deve obter uma mensagem dizendo que o  banco foi iniciado e está ouvindo na porta default 27017:

cat /var/log/mongodb/mongod.log
MongoDB - log

MongoDB – log

5 – Para garantir que o MongoDB iria iniciar automaticamente a cada reinicialização use o comando abaixo, ainda como um super usuário:

chkconfig mongod on
MongoDB - Configuração

MongoDB – Configuração

Para parar e reiniciar o serviço do MongoDB você pode utilizar sudo service mongod stop ou sudo service mongod restart.

ASP NET – Razor – View Engine – MVC – C#

Publicado: 16 de maio de 2015 em C#

O Razor é uma sintaxe de programação ASP.NET usado para criar páginas web dinâmicas com  C# e algumas das linguagens de programação .NET. O Razor nada mais é do que um mecanismo de exibição de sintaxe simples que foi lançado como parte da ASP.NET MVC 3 e do conjunto de ferramentas Microsoft WebMatrix e é o padrão para Views no MVC 5.  A sintaxe do Razor é uma sintaxe de marcação de modelo, com base na linguagem de programação C#, permite que o programador use o fluxo de trabalho de construção do HTML.

Em vez de usar a sintaxe de marcação ASP.NET .ASPX com os símbolos <% =%> para indicar blocos de código, a sintaxe do Razor começa blocos de código com um caractere @ e não requer fechamento explícito do bloco de código. A idéia por trás do Razor é fornecer uma sintaxe otimizada para a geração de HTML usando uma abordagem de modelagem com foco no código, com a transição mínima entre o código e o HTML. Páginas da Web que contenham conteúdo Razor tem uma extensão de arquivo especial (.cshtml ou .vbhtml). O servidor reconhece essas extensões, executa o código que está marcado com a sintaxe Razor, e, em seguida, envia a página resultante para o navegador.

Usando a Sintaxe do Razor

1 – Crie uma aplicação ASP.NET MVC utilizando o template padrão, caso você esteja utilizando uma versão do MVC menor ou igual a 4, você precisa escolher o Engine Razor na criação da solução. Abra a View About do projeto e a modifique de acordo com o código abaixo.

Se você não esta seguindo os exemplos anteriores MVC ignore certas partes do código abaixo:

Razor - Sintaxe

Razor – Sintaxe

2 – Rode sua aplicação para obter os seguintes resultados:

Razor - View

Razor – View

Exemplo:

Neste exemplo exibimos algumas das sintaxes do motor de Views chamado Razor.

C#

View


@{
    //*********************************************************
    //*********************************************************
    //***                                                   *** 
    //*** Caso não esteja utilizando os exemplos anteriores ***
    //*** IGNORE as partes refententes ao Modelo nesta View ***
    //***                                                   *** 
    //*********************************************************
    //*********************************************************
}
@model MeuMVC.Models.DevAbertoModel
@{
    ViewBag.Title = "Sobre";
}
<h1>Rota: @ViewBag.rota</h1>

<h2>@Model.Nome</h2>
<h3>@Model.Apresenta</h3>

<p>@Model.Mensagem</p>

<h2>Razor Views - C#</h2>
@{
    //  *** Use @ {} pra utilizar a sintaxe do razor
    //  ***
    //  *** Razor possui uma sintaxe que permite usar código C# inline em uma página
    
    
    // Usando variáveis no Razor

    var texto  = "Bem-vindo ao Razor";
    var data   = DateTime.Now;
    var numero = 12345;
    var caminho = @"C:\DesenvolvimentoAberto\";
}

<p> @texto </p>
<p> Data: @data </p>
<p> Numero @numero</p>
<p> Caminho: @caminho</p>

<h2></h2>
<table border="1">
    <tr>
        <td>Solicitação da URL</td>
        <td>Caminho Relativo</td>
        <td>Caminho Completo</td>
        <td>Tipo de solicitação HTTP</td>
    </tr>
    <tr>
        <td>@Request.Url</td>
        <td>@Request.FilePath</td>
        <td>@Request.MapPath(Request.FilePath)</td>
        <td>@Request.RequestType</td>
    </tr>
</table>

ASP NET – Rotas – MVC – C#

Publicado: 14 de maio de 2015 em C#

No Design Pattern MVC assim com outros padrões semelhantes trabalham utilizando rotas para executar URLs, mapeando o controlador e sua ação a sua visão. As rotas são muito similares em varias outras linguagens de programação, em ASP.NET MVC as classes que são usadas com o roteamento de URL, permitem que você use URLs que não são mapeadas para um arquivo físico.

O conceito de rota é muito simples, no entanto também proporciona uma manipulação mais complexa e avançada das rotas de sua aplicação. No básico as rotas são compostas de três itens, eles são, o controlador, a visão e um identificador da rota.

Rotas: https://msdn.microsoft.com/en-us/library/system.web.routing.route(v=vs.110).aspx

Usando Rotas – ASP.NET MVC

1 – Usando o Template padrão para um projeto ASP.NET MVC vamos alterar seu arquivo compartilhado de layout para inserir um novo link no menu para nossa visão. Este arquivo se encontra na pasta View/Shared e se chama _layout.cshtml. O altere de acordo com o código abaixo:

MVC - View de Layout

MVC – View de Layout

2 – Para você ver as configurações de rotas abra o arquivo chamado RouteConfig.cs na pasta App_Start. Você pode ver que a rota é composta de três elementos, o controlador, a ação e um id. Você pode mapear quantas rotas você desejar. Neste primeiro momento não vamos utilizar este arquivo, mas vale a pena conhece-lo:

MVC - RouteConfig

MVC – RouteConfig

3 – Crie um novo modelo com três propriedades, você pode utilizar o código abaixo:

MVC - Modelo

MVC – Modelo

4 – Crie uma nova visão para exibir os dados do modelo, use o código abaixo:

MVC - Visão

MVC – Visão

5 – Abra o seu controlador e crie um novo método de ação para sua visão:

MVC - Controlador

MVC – Controlador

6 – Compile sua aplicação e clique no novo botão do menu:

MVC - Aplicação - Home

MVC – Aplicação – Home

7 – Ao clicar no botão a rota é executa, capturada e exibida na visão que também exibe os dados do modelo:

MVC - Rota - Visão

MVC – Rota – Visão

Exemplo:

Neste exemplo criamos um novo botão no menu da visão compartilhada e criamos um novo modelo e uma nova visão, capturamos a rota executada e a exibimos.

C#

_Layout.cshtml

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>@ViewBag.Title - My ASP.NET Application</title>
    @Styles.Render("~/Content/css")
    @Scripts.Render("~/bundles/modernizr")

</head>
<body>
    <div class="navbar navbar-inverse navbar-fixed-top">
        <div class="container">
            <div class="navbar-header">
                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                    <span class="icon-bar"></span>
                </button>
                @Html.ActionLink("Application name", "Index", "Home", null, new { @class = "navbar-brand" })
            </div>
            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li>@Html.ActionLink("Home", "Index", "Home")</li>
                    <li>@Html.ActionLink("Desenvolvimento Aberto", "DevAberto", "Home")</li>
                    <li>@Html.ActionLink("About", "About", "Home")</li>
                    <li>@Html.ActionLink("Contact", "Contact", "Home")</li>
                </ul>
                @Html.Partial("_LoginPartial")
            </div>
        </div>
    </div>
    <div class="container body-content">
        @RenderBody()
        <hr />
        <footer>
            <p>&copy; @DateTime.Now.Year - My ASP.NET Application</p>
        </footer>
    </div>

    @Scripts.Render("~/bundles/jquery")
    @Scripts.Render("~/bundles/bootstrap")
    @RenderSection("scripts", required: false)
</body>
</html>

Modelo
DevAbertoModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MeuMVC.Models
{
    public class DevAbertoModel
    {
        // Cria propriedades
        public string Nome { get; set; }
        public string Apresenta { get; set; }
        public string Mensagem { get; set; }
    }
}

Visão

@model MeuMVC.Models.DevAbertoModel
@{
    ViewBag.Title = "Sobre";
}
<h1>Rota: @ViewBag.rota</h1>

<h2>@Model.Nome</h2>
<h3>@Model.Apresenta</h3>

<p>@Model.Mensagem</p>

Controlador

using MeuMVC.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MeuMVC.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }

        public ActionResult About()
        {
            // **** IMPORTANTE ****
            // Caso use este código sem seguir os exemplos anteriores
            // Igonore os codigos deste método.
            
            // Cria instancia do modelo
           AboutModel modelo = new AboutModel();

            // Alimenta dados ao modelo
            modelo.Site = "Desenvolvimento Aberto";
            modelo.Linguagem = "ASP.NET MVC- C#";
            modelo.Mensagem = "Rê, Você é a página mais linda que o destino escreveu na minha vida.";

            // adiciona modelo a visão
            return View(modelo);
        }
        
        public ActionResult DevAberto()
        {
            // Lê rotas
            var controller = RouteData.Values["controller"];
            var action = RouteData.Values["action"];
            var id = RouteData.Values["id"];

            // Cria propriedade dinamica
            ViewBag.rota = String.Format("{0}::{1} {2}", controller, action, id);

            // Cria instancia do modelo
            DevAbertoModel modelo = new DevAbertoModel();

            // Alimenta modelo
            modelo.Nome = "Desenvolvimento Aberto";
            modelo.Apresenta = "ABAP, Java, C#, C++, Python, Ruby e SQL";
            modelo.Mensagem = "Rê, Eu sem você é como você sem mim.";

            // Retorna modelo
            return View(modelo);

        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";

            return View();
        }
    }
}

ASP NET – Modelo (Model) – MVC – C#

Publicado: 14 de maio de 2015 em C#

Um modelo (Model) notifica suas visões e controladores associados quando há uma mudança em seu estado. Esta notificação permite que as visões produzam saídas atualizadas e que os controladores alterem o conjunto de comandos disponíveis. Uma implementação passiva do MVC monta estas notificações, devido a aplicação não necessitar delas ou a plataforma de software não suportá-las. Geralmente as classes que representam suas entidades e as que te ajudam a armazenar e buscar os dados são chamadas de Modelo (Model), o modelo que tem acesso a toda e qualquer informação sendo essa vinda de um banco de dados ou qualquer outra fonte que você defina.

 Criando Modelos

1 – Usando o Template gerado pelo Visual Studio vamos trocar as Viewbags que passam informação entre o controlador e a visão por modelos. Para isto adicione uma classe chamada AboutModel.cs:

Classe - Modelo -AboutModel

Classe – Modelo -AboutModel

2 – Crie três simples propriedades na classe para armazenar os dados para o modelo, lembrando que você pode utilizar algum framework de persistência para gravar os dados em um banco de dados ou outra fonte de dados de acordo como desejar:

Modelo - Propriedades

Modelo – Propriedades

3 – Abra o controlador e crie uma instancia do modelo, vamos alimentar o modelo de um modo estático neste primeiro momento, logo após você só precisa passar o modelo para visão:

Contoller - Controlador/Visão

Contoller – Controlador/Visão

4 – Para acessar o modelo você precisa declara-lo em sua visão então pode acessar qualquer uma de suas propriedades, abra o arquivo de visão e o modifique de acordo com o código abaixo:

View - Utiliza Modelo

View – Utiliza Modelo

5 – Rode sua aplicação e clique no menu About para ver o funcionamento, você pode notar que a visão utiliza os dados do modelo que são manipulados através do controlador.

Visão - MVC

Visão – MVC

Exemplo:

Neste exemplo criamos um modelo básico através de uma classe, alimentamos seus dados manualmente, lembrando que ainda não existe nenhum tipo de persistência para gravar os dados. Este é um simples exemplo do funcionamento do padrão modelo-visão-controlador.

C#

Modelo

AboutModel.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

namespace MeuMVC.Models
{
    public class AboutModel
    {
        public string Site { get; set; }
        public String Linguagem { get; set; }
        public string Mensagem { get; set; }

    }
}

Visão

About.cshtml

@model MeuMVC.Models.AboutModel
@{
    ViewBag.Title = "Sobre";
}
<h2>@Model.Site</h2>
<h3>@Model.Linguagem</h3>

<p>@Model.Mensagem</p>

Controlador

HomeController.cx

using MeuMVC.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MeuMVC.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }

        public ActionResult About()
        {
            // Cria instancia do modelo
           AboutModel modelo = new AboutModel();

            // Alimenta dados ao modelo
            modelo.Site = "Desenvolvimento Aberto";
            modelo.Linguagem = "ASP.NET MVC- C#";
            modelo.Mensagem = "Rê, Você é a página mais linda que o destino escreveu na minha vida.";

            // adiciona modelo a visão
            return View(modelo);
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";

            return View();
        }
    }
}

 

ASP NET – Introdução ao framework MVC – C#

Publicado: 14 de maio de 2015 em C#

O ASP.NET MVC oferece uma poderosa maneira baseada em padrões para construir sites dinâmicos que permite uma clara separação de conceitos e que lhe dá controle total sobre a marcação para tornar o desenvolvimento mais agradável e ágil. O ASP.NET MVC inclui muitas características que permitem, desenvolvimento amigável-TDD, é rápido para a criação de aplicações sofisticadas que utilizam os mais recentes padrões da web.

O Design Pattern MVC (Model-view-controller), em português modelo-visão-controlador, é um padrão de arquitetura de software que separa a representação da informação da interação do usuário com ele. O modelo (model) consiste nos dados da aplicação, regras de negócios, lógica e funções. Uma visão (view) pode ser qualquer saída de representação dos dados, como uma tabela ou um diagrama. É possível ter várias visões do mesmo dado, como um gráfico de barras para gerenciamento e uma visão tabular para contadores. O controlador (controller) faz a mediação da entrada, convertendo-a em comandos para o modelo ou visão. As ideias centrais por trás do MVC
são a reusabilidade de código e separação de conceitos.

De fato usar o padrão MVC é muito simples, basicamente você pode ter vários controladores, um para cada assunto, por exemplo um para a pagina inicial, um para login e assim por diante. Geralmente o controlador possui um modelo que consiste nos dados da aplicação ou regras de negocio. O controlador pode manipular varias visões diferentes através de rotas, fazendo o intermédio entre modelo, visão e controlador tornando as aplicações fáceis de desenvolver e de manter. Abaixo vamos ver como isso funciona na pratica.

ASP.NET MVC: http://www.asp.net/mvc

Criando uma aplicação ASP.NET MVC

1 – Crie um novo projeto Web e escolha ASP.NET Web Application, nomeie seu projeto de acordo com a figura abaixo:

Projeto - ASP.NET

Projeto – ASP.NET

2 – Selecione o template como ASP.NET MVC:

Template - MVC

Template – MVC

3 – Seu novo projeto será criado e você será recepcionado com uma página chamada readme.html que consiste na apresentação do Framework MVC e contém vários links para que você comece a aprender sobre ASP.NET MVC:

Bem-Vindo - ASP.NET MVC

Bem-Vindo – ASP.NET MVC

4 – Você pode compilar a aplicação MVC e verá que você possui um site com links totalmente funcionais, use o site por um instante para conhece-lo melhor:

Aplicação - MVC

Aplicação – MVC

5 – Mude o tamanho do seu navegador web e você pode ver que a aplicação é totalmente adaptável ao Device que irá utiliza-la, podendo ser um celular, um tablet ou um computador, esta adaptação automática da aplicação é devido aos frameworks e linguagens adicionais que a Microsoft adotou pra as aplicações ASP.NET.

Aplicação - Adaptável

Aplicação – Adaptável

6 – Clique com o botão direito do mouse na pagina e exiba seu código fonte e o analise, você pode ver que o código é totalmente legível e que por padrão a Microsoft utiliza alguns frameworks e linguagens como Javascript, o Bootstrap que é responsável pelo Design responsivo, o JQuery que manipula paginas web no lado cliente, também utiliza o JQuery UI que cria componentes web modernos e bonitos, além de vários outros frameworks:

MVC - Código HTML

MVC – Código HTML

7 – O MVC é um padrão antigo e muito usado na Web, o ASP.NET foi um dos últimos frameworks a implementa-lo e segue bem a linha do Ruby on Rails, se você está familiarizado com esta linguagem ou outras que utilizam o Design Pattern MVC você não terá dificuldades de utilizar o ASP.NET MVC.

O ASP.NET MVC é um padrão e também um framework de código aberto que possibilita a utilização do padrão de um modo simples. A Microsoft adotou alguns marcos na criação que possibilita melhor utilização do MVC:

  • Embrace the Web – Abraçando varias tecnologias de código aberto para tornar o ASP.NET competitivo e difundido, além de permitir que ele cruze as mais diversas plataformas.
  • Run on ASP.NET – Permite que as aplicações rodem no núcleo do ASP.NET que hoje é um framework maduro com mais de 10 anos, estável, seguro e optimizado para performance.
  • Extensible – Permite que você adicione novas funcionalidades ao framework para atender as suas necessidades.
  • Testable – Permite que você execute testes unitários em sua aplicação através de frameworks de testes.
MVC - Design Pattern

MVC – Design Pattern

8 – Vamos ver como é isso na pratica, no Solution Explorer abra a pasta Controller do seu projeto e abra o controlador chamado HomeController.cs, o analise e o modifique de acordo com o código abaixo:

Controlador

Controlador

9 – Abra na pasta View/Home e abra a visão chamada about.cshtml e altere de acordo com o código abaixo. Como você pode ver o controlador chama a visão e passa valores para ela dinamicamente. O controlador chama a visão através de rotas no qual veremos mais tarde.

ViewBag – A propriedade ViewBag permite compartilhar dinamicamente valores a partir do controlador para a visão. É um objeto dinâmico, que significa que não tem propriedades pré-definidas. Você define as propriedades que deseja para a ViewBag  simplesmente adicionando-as. No modo de exibição, você pode recuperar esses valores usando o mesmo nome da propriedade.

https://msdn.microsoft.com/en-us/library/system.web.mvc.controllerbase.viewbag(v=vs.118).aspx

MVC - View

MVC – View

10 – Após utilizar o código abaixo compile sua aplicação:

Aplicação MVC

Aplicação MVC

11 – Clique no menu About para ver as alterações:

MVC - View - Viewbag

MVC – View – Viewbag

Exemplo:

Neste exemplo utilizamos uma aplicação padrão MVC,  a estudamos e a modificamos para entender os conceitos de controlador e visão. Você pode criar mais propriedades para que seja passado do controlador/visão.

C#

Controlador

HomeController.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace MeuMVC.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            return View();
        }

        public ActionResult About()
        {
            ViewBag.Message = "Desenvolvimento Aberto - MVC.";

            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your contact page.";

            return View();
        }
    }
}

Visão

index.cshtml

@{
    ViewBag.Title = " - Desenvolvimento Aberto - Home Page";
}

<div class="jumbotron">
    <h1>Desenvolvimento Aberto - ASP.NET</h1>
    <p class="lead">ASP.NET is a free web framework for building great Web sites and Web applications using HTML, CSS and JavaScript.</p>
    <p><a href="http://asp.net" class="btn btn-primary btn-large">Learn more &raquo;</a></p>
</div>

<div class="row">
    <div class="col-md-4">
        <h2>Getting started</h2>
        <p>
            ASP.NET MVC gives you a powerful, patterns-based way to build dynamic websites that
            enables a clean separation of concerns and gives you full control over markup
            for enjoyable, agile development.
        </p>
        <p><a class="btn btn-default" href="http://go.microsoft.com/fwlink/?LinkId=301865">Learn more &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Get more libraries</h2>
        <p>NuGet is a free Visual Studio extension that makes it easy to add, remove, and update libraries and tools in Visual Studio projects.</p>
        <p><a class="btn btn-default" href="http://go.microsoft.com/fwlink/?LinkId=301866">Learn more &raquo;</a></p>
    </div>
    <div class="col-md-4">
        <h2>Web Hosting</h2>
        <p>You can easily find a web hosting company that offers the right mix of features and price for your applications.</p>
        <p><a class="btn btn-default" href="http://go.microsoft.com/fwlink/?LinkId=301867">Learn more &raquo;</a></p>
    </div>
</div>

about.cshtml

@{
    ViewBag.Title = "Sobre";
}
<h2>@ViewBag.Title.</h2>
<h3>@ViewBag.Message</h3>

<p>Rê, Você é a página mais linda que o destino escreveu na minha vida.</p>