Arquivo da categoria ‘C#’

Quando utilizamos um mapeamento objeto relacional para usar duas tabelas do banco de dados que estão ligadas entre si através de um identificador comum nos deparamos com algumas diferenças de conceitos do tradicional método de usar o banco de dados relacional no qual estamos acostumados. O que podemos fazer simplesmente com a linguagem SQL como declarar uma instrução Join se torna um pouco mais complicado no mundo ORM, está diferença é chamada de impedância objeto-relacional.

Existem vários métodos para que se possa lidar com esta diferença de conceitos no qual os bancos de dados ainda não estão preparados para lidar, pois os maiores banco de dados do mercado ainda são os relacionais. Podemos utilizar um método chamado Bind que apesar de simples não é muito usual devido a sua sintaxe ser um pouco diferente do padrão do qual estamos acostumado no C#.

No seu uso mais simples, o Bind nos permite utilizar entre outros um prefixo para trazer o identificador do modelo de uma visão para que possamos utiliza-lo em outra visão para filtra dados.

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

Deste modo podemos facilmente escrever aplicações que usam dados relacionais e manipula-los através do framework MVC. Você pode manualmente criar modelos e identificadores entre eles e liga-los utilizando bind, apesar de não muito usual está estratégia permite mais controle sobre o SQL que seu framework ORM irá utilizar para manipulação do seu banco de dados.

Relacionado dados entre modelos

1 – Crie uma aplicação C# – MVC Razor, utilize o exemplo anterior para criar os modelos, visões e Scaffold para que você obtenha um CRUD totalmente funcional sem que tenha que escrever linhas de código.

CRUD ASP.NET MVC – Entity Framework

2 – Altere a visão de apresentação chama Index do controlador de cadastro e substitua o link detalhes pelo link horários e alimente os dados que desejar.

Cadastro - Cursos

Cadastro – Cursos

3 – Crie um novo Scaffold para o modelo grade e alimente os dados utilizando os identificadores do cadastro anterior, visto que neste momento você ainda não pode vê-los, pois não são exibidos na View. Os identificadores são sequenciais, você pode utilizar a instrução Select no SQL Studio para visualiza-los ou pode exibi-los na sua View de cadastro adicionando mais um campo para ser exibido se desejar.

Horários - Grade

Horários – Grade

4 – Altere o controlador da grade de horários como no código abaixo:

Grade - Bind

Grade – Bind

Exemplo:

Neste exemplo criamos dois modelos e utilizamos um Scaffold de escrita e leitura para criar toda funcionalidade para nossa aplicação. Relacionamos os modelos manualmente através do atributo Bind.

Nesta aplicação o item JAVA EE possui o identificador 6, no qual somente o item relacionado será mostrado caso tenha um horário na tabela grade no banco de dados.

C#
Cadastro
Index.cshtml

@model IEnumerable<WebApplication1.Models.CursosModelo>

@{
    ViewBag.Title = "Index";
}


<h2>Index</h2>




    @Html.ActionLink("Create New", "Create")



<table class="table">

<tr>

<th>
            @Html.DisplayNameFor(model => model.Curso)
        </th>


<th>
            @Html.DisplayNameFor(model => model.Linguagem)
        </th>


<th>
            @Html.DisplayNameFor(model => model.Descr)
        </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.Descr)
        </td>


<td>
            @Html.ActionLink("Edit", "Edit", new { id=item.Id }) |

            
            @*Altere os detalhes para que você chamar a visão de horarios*@ 
            @Html.ActionLink("Horarios", "Index", "GradeModeloes", new { id=item.Id }, null) |
            @Html.ActionLink("Delete", "Delete", new { id=item.Id })
        </td>

    </tr>

}

</table>


Controlador
GradeModeloesController

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Net;
using System.Web;
using System.Web.Mvc;
using WebApplication1.Models;

namespace WebApplication1.Controllers
{
    public class GradeModeloesController : Controller
    {
        private MinhaAppMeuDB db = new MinhaAppMeuDB();

        

        // GET: GradeModeloes
        // Use o Bind para relacionar os dados exibidos entre as visões
        public ActionResult Index([Bind (Prefix ="id")]int CursosId)
        {
            var MeuCurso = from m in db.Grades
                           where m.IdCursoModelo.Equals(CursosId)
                           select m;
            
            if (MeuCurso != null)
            {
                return View(MeuCurso);
            }

            return HttpNotFound();
        }

        // GET: GradeModeloes/Details/5
        public ActionResult Details(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            GradeModelo gradeModelo = db.Grades.Find(id);
            if (gradeModelo == null)
            {
                return HttpNotFound();
            }
            return View(gradeModelo);
        }

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

        // POST: GradeModeloes/Create
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for 
        // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Create([Bind(Include = "Id,Dia,hora,IdCursoModelo")] GradeModelo gradeModelo)
        {
            if (ModelState.IsValid)
            {
                db.Grades.Add(gradeModelo);
                db.SaveChanges();
                return RedirectToAction("Index");
            }

            return View(gradeModelo);
        }

        // GET: GradeModeloes/Edit/5
        public ActionResult Edit(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            GradeModelo gradeModelo = db.Grades.Find(id);
            if (gradeModelo == null)
            {
                return HttpNotFound();
            }
            return View(gradeModelo);
        }

        // POST: GradeModeloes/Edit/5
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for 
        // more details see http://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public ActionResult Edit([Bind(Include = "Id,Dia,hora,IdCursoModelo")] GradeModelo gradeModelo)
        {
            if (ModelState.IsValid)
            {
                db.Entry(gradeModelo).State = EntityState.Modified;
                db.SaveChanges();
                return RedirectToAction("Index");
            }
            return View(gradeModelo);
        }

        // GET: GradeModeloes/Delete/5
        public ActionResult Delete(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            GradeModelo gradeModelo = db.Grades.Find(id);
            if (gradeModelo == null)
            {
                return HttpNotFound();
            }
            return View(gradeModelo);
        }

        // POST: GradeModeloes/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public ActionResult DeleteConfirmed(int id)
        {
            GradeModelo gradeModelo = db.Grades.Find(id);
            db.Grades.Remove(gradeModelo);
            db.SaveChanges();
            return RedirectToAction("Index");
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}

 

 

Anúncios

CRUD acrónimo de Create, Read, Update e Delete, utiliza as quatro operações básicas  para criação, consulta, atualização e exclusão de dados. Outros acrónimos podem ser usados para definir as mesmas operações:

  •  ABCD: Add, Browse, Change e Delete
  • BREAD: Browse, Read, Edit, Add e Delete
  • VADE(R): View, Add, Delete, Edit (e Restore, para sistemas com processos transacionais)
  • VEIA: Visualizar, Excluir, Inserir, Alterar

A abreviação CRUD também pode ser mapeada para o padrão ISO/SQL:

  • Create INSERT
  • Read (Retrieve) SELECT
  • Update UPDATE
  • Delete (Destroy) DELETE

As operações CRUD também são relevantes em interfaces para utilizadores de vários níveis. Por exemplo, num programa de Catálogo de Endereços, uma entrada de um contato individual pode ser considerada a unidade básica de persistência. As operações mínimas para este tipo de programa são:

  • Create Criar ou adicionar novas entradas
  • Read (Retrieve) Ler, recuperar ou ver entradas existentes
  • Update Atualizar ou editar entradas existentes
  • Delete (Destroy) Remover entradas existentes

As operações CRUD são facilmente programadas em aplicações que utilizam o padrão MVC, pois estes possuem o recurso de Scaffold que como já vimos em posts anteriores, criam todo o código necessário para estas operações.

Scaffolding é uma técnica apoiada por alguns frameworks MVC, nos quais o programador pode especificar a forma como o banco de dados de aplicativo pode ser usado. O compilador ou estrutura usa essa especificação, em conjunto com modelos de código pré-definido, para gerar o código final que o aplicativo podem usar para criar, ler, atualizar e excluir entradas de banco de dados, tratar eficazmente os modelos como um “Scaffolding” sobre o qual construir uma aplicação mais poderosa.

Criando CRUD em uma aplicação ASP NET MVC – Razor

1 – Crie uma aplicação web padrão MVC ou utilize o exemplo anterior que já possui todas as classes e modelos para realizarmos as operações CRUD. Na pagina de layout de sua aplicação insira um novo link para o controlador de cadastros:

MVC - _Layout.cshtml

MVC – _Layout.cshtml

2 – Crie um novo controlador chamado cadastro, nome no qual você utilizou no link do passo anterior. Escolha o tipo de Scaffold como Controller with Views using entity framework:

MVC - Controlador

MVC – Controlador

3 – Nas configurações do controlador, escolha seu modelo de dados, sua classe de contexto de dados e o nome do seu controlador:

MVC - Dados do Controlador

MVC – Dados do Controlador

4 – Pronto! Todo código será gerado automaticamente criando todas as funções CRUD que você precisa para alimentar os dados nesta tabela. Você tem uma aplicação com um cadastro totalmente funcional. Como já tínhamos dados na tabela devido ao exemplo anterior, recebemos a função READ como na figura abaixo:

MVC - READ

MVC – READ

5 – Clique em Create New para criar um novo registro em sua aplicação:

MVC - CREATE

MVC – CREATE

6 – Você pode editar os dados criados clicando em Edit no registro desejado:

MVC - UPDATE

MVC – UPDATE

7 – Você pode excluir o registro desejado usando a opção Delete:

MVC - DELETE

MVC – DELETE

Exemplo:

Neste exemplo usamos um contexto de dados e um modelo para criar as ações básicas de uma aplicação que utiliza banco de dados e nos permite criar, ler, alterar e excluir registros de uma tabela.

  • Todo o código gerado automaticamente pelo Scaffold não será exibido abaixo.

C#

Modelos:

Db Context

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

namespace WebApplication1.Models
{
    public class MinhaAppMeuDB : DbContext
    {
        // Define string de conexão  de sua aplicação
        public MinhaAppMeuDB() : base("name=DefaultConnection")
        { }

       public DbSet<CursosModelo> Cursos { get; set; }
       public DbSet<GradeModelo>  Grades { get; set; }

    }
}

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 Descr { get; set; }

        // Aponta para o Grade
        public ICollection<GradeModelo> Cursos { get; set; }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

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

        // Cria relacionamento
        public int IdCursoModelo { get; set; }
    }
}

O Language Integrated Query (LINQ) é um componente do Microsoft .NET que adiciona funcionalidades de consulta em algumas linguagens de programação .NET. O LINQ corresponde a uma sintaxe unificada, inicialmente incorporada às linguagens C# e Visual Basic, para consultas em fontes de dados variadas. A sintaxe de consulta da LINQ foi inspirada na Structured Query Language (SQL), que é uma linguagem padrão para comunicação com bancos de dados relacionais. Assim como na linguagem SQL, as expressões de consulta LINQ permitem a construção de instruções variadas para extração de informações.  Ele define um conjunto de métodos chamados operadores de consulta, expressões lambda e tipos anônimos.

O LINQ é um conjunto de recursos introduzidos no Visual Studio 2008 que amplia os poderosos recursos de consulta para a sintaxe da linguagem C# e Visual Basic. O LINQ proporciona padrões intuitivos para o desenvolvimento queries para consulta e atualização de dados além de poder ser extendida para dar suporte a qualquer tipo de banco de dados. O Visual Studio inclui assemblies provedores de LINQ que permitem o uso do LINQ com coleções do .NET Framework, bancos de dados do SQL Server, conjuntos de dados ADO.NET e documentos XML.

LINQ: https://msdn.microsoft.com/pt-br/library/bb397897.aspx

101 Exemplos LINQ: https://code.msdn.microsoft.com/101-LINQ-Samples-3fb9811b

Usando o LINQ

1 – Você pode criar uma aplicação web MVC usando o template padrão, criar um modelo de dados Code First e alimenta-lo com alguns dados no banco de dados MSSQL ou usar o exemplo anterior clicando aqui. Você deve obter uma página web com uma visão que exibe os seguintes dados:

MVC - Aplicação

MVC – Aplicação

2 – Modifique o controlador e a visão de acordo com os códigos abaixo para criar uma pesquisa e uma busca para sua visão:

LINQ - Seleção e Busca

LINQ – Seleção e Busca

Exemplo:

Neste exemplo utilizamos a aplicação criada anteriormente e utilizamos a linguagem LINQ para exibir os dados exibidos na visão e também para criar uma pesquisa que busca os caracteres iniciais do campo chamado cursos.

C#

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 HomeController : Controller
    {
        // Cria instancia do banco de dados
        MinhaAppMeuDB DB = new MinhaAppMeuDB();

        public ActionResult Index(string busca = null)
        {
            // Usando uma sintaxe simples do LINQ
            // Seleciona todos as propriedades dos cursos
            // Ordena pela propriedade curso
            // e pesquisa por caracteres iniciais do campo curso

            var modelo = from r in DB.Cursos
                         where busca == null || r.Curso.StartsWith(busca)
                         orderby r.Curso
                         select r;
                
            return View(modelo);
        }

        // Cria método override 
        protected override void Dispose(bool disposing)
        {
            // Limpa os recursos

            if (DB != null)
            {
                DB.Dispose();
            }
            base.Dispose(disposing);
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";
            
            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your application description page.";
            
            return View();
        }
    }
}

Visão

@model IEnumerable<WebApplication1.Models.CursosModelo>

@{
    ViewBag.Title = "Home Page";
}

<div class="jumbotron">
    <h1>Desenvolvimento Aberto - ASP.NET</h1>
    <p class="lead">ASP.NET - MVC - Entity Framework - HTML, CSS and JavaScript.</p>    
</div>
<form>
    <input type="search" name="busca" />
    <input type="submit" name="Buscar por nome" />
</form>
<br />
<table style="width:700px">
    <tr>
        <th>Cursos</th>
        <th>Linguagem</th>
        <th>Descrição</th>
    </tr>

    @foreach (var item in Model)
    {
        <tr>
            <td>@item.Curso</td>
            <td>@item.Linguagem</td>
            <td>@item.Descr</td>
        </tr>
            
    }
</table>

 

ASP NET – Migrations – Razor – MVC – C#

Publicado: 4 de julho de 2015 em C#

Quando você desenvolve um novo aplicativo, o seu modelo de dados muda com frequência, e cada vez que o modelo é alterado, ele fica fora de sincronia com o banco de dados. Você pode configurar o Entity Framework para excluir automaticamente e re-criar o banco de dados cada vez que você alterar o modelo de dados. Quando você adiciona, remove ou altera classes de entidade ou alterar a classe DbContext, na próxima vez que você executar o aplicativo ele automaticamente exclui o banco de dados existente, cria um novo que corresponda ao modelo, visto que este tipo de configuração automática é preciso que você utilize ambientes em seu desenvolvimento, como Sandbox, Testes, DEV e etc…

O Migrations permite que você gere atualizações gerenciáveis no seu banco de dados, ou deixar que o próprio Migrations cuide de tudo de forma automática, seu propósito é manter seu banco de dados sempre atualizado com suas classes. O  Migrations é muito utilizado em aplicações com o padrão MVC e se tornou popular no Framework Rails também é utilizado em ASP.NET de forma muito similar.

Utilizando Migrations

1 – Crie uma aplicação ASP.NET MVC usando o template padrão. No arquivo WebConfig crie sua string de conexão padrão, visto que o banco de dados será criado de acordo com o nome que você utilizar, use a figura abaixo para referencia:

MVC - String de conexão

MVC – String de conexão

2 – Crie sua classe de acesso a dados passando a string de conexão que você deseja utilizar:

MVC - Contexto do Banco de Dados

MVC – Contexto do Banco de Dados

3 – Substitua ou crie as classes abaixo de sua aplicação e rode, você vai obter uma pagina vazia, pois o banco de dados acabou de ser criado automaticamente e ainda não possui nenhuma informação:

MVC - Novo Banco

MVC – Novo Banco

4 – Se você desejar pode abrir o estúdio do SQL Server e verificar o banco e as tabelas criadas automaticamente pelo EF, você pode utilizar um diagrama para melhor entendimento do que foi criado, incluindo o seu relacionamento:

SQL - Diagrama

SQL – Diagrama

5 – Assim como no Rails, o ASP.NET MVC nos permite utilizar as migrações através da linha de comando, para isto vamos utilizar a janela chamada Package Manage Console que executa comandos do Windows PowerShell. Para abrir a janela utilize o menu View->Other Windows->Package Manage Console. Atente-se a figura abaixo, você pode perceber que uma nova pasta para as migrações foi criada em sua aplicação.

Digite o comando: Enable-Migrations -ContextTypeName MinhaAppMeuDB

MVC - Migrations

MVC – Migrations

6 – Você pode adicionar dados a serem gravados toda vez que você migrar o banco de dados utilizando o método Seed, preencha a classe de configuração da migração e digite o comando: Update-Database -Verbose

Configuração -Migrations

Configuração -Migrations

7 – Você pode rodar a sua aplicação e desta vez a migração adicionou os dados iniciais ao banco de dados:

MVC - Aplicação

MVC – Aplicação

Exemplo:

Neste exemplo criamos um banco de dados e inserimos dados iniciais de utilizando o Migrations.

C#

Modelos

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

namespace WebApplication1.Models
{
    public class MinhaAppMeuDB : DbContext
    {
        // Define string de conexão  de sua aplicação
        public MinhaAppMeuDB() : base("name=DefaultConnection")
        { }

       public DbSet<CursosModelo> Cursos { get; set; }
       public DbSet<GradeModelo>  Grades { get; set; }

    }
}
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 Descr { get; set; }

        // Aponta para o Grade
        public ICollection<GradeModelo> Cursos { get; set; }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

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

        // Cria relacionamento
        public int IdCursoModelo { get; set; }
    }
}

Visão

@model IEnumerable<WebApplication1.Models.CursosModelo>

@{
    ViewBag.Title = "Home Page";
}

<div class="jumbotron">
    <h1>Desenvolvimento Aberto - ASP.NET</h1>
    <p class="lead">ASP.NET - MVC - Entity Framework - HTML, CSS and JavaScript.</p>
</div>

<table style="width:700px">
    <tr>
        <th>Cursos</th>
        <th>Linguagem</th>
        <th>Descrição</th>
    </tr>

    @foreach (var item in Model)
    {
        <tr>
            <td>@item.Curso</td>
            <td>@item.Linguagem</td>
            <td>@item.Descr</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 HomeController : Controller
    {
        // Cria instancia do banco de dados
        MinhaAppMeuDB DB = new MinhaAppMeuDB();

        public ActionResult Index()
        {
            var modelo = DB.Cursos.ToList();
            return View(modelo);
        }

        // Cria método override
        protected override void Dispose(bool disposing)
        {
            // Limpa os recursos

            if (DB != null)
            {
                DB.Dispose();
            }
            base.Dispose(disposing);
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";

            return View();
        }

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

            return View();
        }
    }
}

Migração

namespace WebApplication1.Migrations
{
    using System;
    using System.Collections.Generic;
    using System.Data.Entity;
    using System.Data.Entity.Migrations;
    using System.Linq;

    internal sealed class Configuration : DbMigrationsConfiguration<WebApplication1.Models.MinhaAppMeuDB>
    {
        public Configuration()
        {
            AutomaticMigrationsEnabled = true;
            ContextKey = "WebApplication1.Models.MinhaAppMeuDB";
        }

        protected override void Seed(WebApplication1.Models.MinhaAppMeuDB context)
        {
            // Cria configuração inicial
            context.Cursos.AddOrUpdate( r=> r.Curso, 

                new Models.CursosModelo { Curso = "ASP.NET MVC", Linguagem = "C#", Descr = "Aplicações para web" },
                new Models.CursosModelo { Curso = "Ruby on Rails", Linguagem = "Ruby", Descr = "Aplicações para web" },
                new Models.CursosModelo { Curso = "Django", Linguagem = "Python", Descr = "Aplicações para web" },

                new Models.CursosModelo { Curso = "Java EE", Linguagem = "Java", Descr = "Aplicações para web",

                 Cursos  =  new List<Models.GradeModelo> {
                            new Models.GradeModelo { Dia = "Quarta", hora = "10:30" }
                   }
                }
            );
        }
    }
}

ASP NET – Entity Framework – ORM – MVC – C#

Publicado: 28 de junho de 2015 em C#

O Entity Framework é um framework de código aberto (ORM) para ADO.NET que faz parte do .NET Framework. O EF fornece uma experiência de acesso a dados LINQ fortemente tipada nos bancos de dados relacionais incluindo acesso ao SQL Server de uma forma direta e eficiente pois ele elimina a necessidade da maior parte do código de acesso a dados que os desenvolvedores geralmente precisam escrever. A primeira versão do Entity Framework foi incluído com o .NET Framework 3.5 Service Pack 1 e Visual Studio 2008 Service Pack 1, lançado em 11 de agosto de 2008. Esta versão foi amplamente criticada, mesmo atraindo um “voto de confiança” assinado por cerca de mil desenvolvedores, entre varias criticas uma das maiores era que na época não era possível utilizar os bancos de dados lideres de mercado como Oracle e outros, a Oracle lançou posteriormente provedores de acesso e ferramentas para utilizar Oracle com o Entity Framework integrados em seu pacote de acesso a dados chamado ODAC.

A versão 6.0 foi lançada em 17 de outubro de 2013 e é agora um projeto open source licenciado sob Apache License v2. Como ASP.NET MVC Framework, seu código-fonte está hospedado no CodePlex usando Git. Esta versão tem uma série de melhorias para suporte a sua aproximação Code First.

As capacidades avançadas do Entity Framework, funcionam com uma série de servidores de banco de dados, incluindo o Microsoft SQL Server, Oracle e DB2. Incluem um mecanismo sofisticado de mapeamento que pode lidar com esquemas reais de banco de dados e funciona bem com procedimentos armazenados. Fornecem ferramentas integradas do Visual Studio para criar visualmente modelos de entidade e gerar de forma autônoma modelos a partir de um banco de dados existente. Os novos bancos de dados podem ser implantados a partir de um modelo, que também pode ser editado à mão para controle total.

Entity Framework: http://www.asp.net/entity-framework

CodePlex: https://entityframework.codeplex.com/

Abordagens Entity Framework

Schema First – criamos a estrutura de entidade a partir de um banco de dados existente. Usamos todas as outras funcionalidades, tais como o modelo, sincronização de banco de dados e a geração de código, da mesma maneira que usamos na abordagem Model First.

Model First – o modelo de banco de dados é criado pela primeira vez usando o designer ORM no Visual Studio. Uma vez que o modelo que consiste em entidades e relações foi concebido, o banco de dados físico vai ser gerado a partir do modelo.

Code First – criamos as classes primeiro e, em seguida, geramos o banco de dados das classes diretamente. No código em primeiro lugar, não vamos usar o Entity Designer (para editar .edmx arquivos) em tudo.

Usando o Entity Framework

1 – Crie uma nova aplicação MVC usando o template padrão, utilize o código abaixo para criar os modelos e o objeto de entidade de banco de dados:

Model e Entity

Model e Entity

2 – Após utilizar os  códigos abaixo, de um Build na sua aplicação. Você pode abrir a sua instancia MS SQL Server no SQL Management Studio e verificar o banco de dados criado automaticamente com o mesmo nome da sua entidade de banco de dados. Você também pode ver que os modelos geraram tabelas com suas respectivas chaves primarias e relacionamentos sem que você precise fazer nada:

Banco de dados - MSSQL Server

Banco de dados – MSSQL Server

3 – Você também pode manipular o banco de dados diretamente pelo Visual Studio usando a janela chamada Server Explorer:

Server Explorer

Server Explorer

4 – Em Data Connection adicione uma nova conexão e escolha o seu Data Source:

Data Source

Data Source

5 – Aponte para sua instancia do banco de dados e escolha o banco de dados da sua aplicação:

Adicionar Conexão

Adicionar Conexão

6 – Neste ponto você pode manipular seu banco de dados à partir de uma janela do Visual Studio:

VS - Banco de dados

VS – Banco de dados

7 – Abra o conteúdo de sua tabela clicando com o botão direito e escolhendo a opção Show Table Data. Insira os dados manualmente:

Editando Tabelas

Editando Tabelas

8 – Compile sua aplicação para receber o seguinte resultado:

ASP NET - MVC - Entity Framework

ASP NET – MVC – Entity Framework

Exemplo:

Neste exemplo utilizamos o Entity Framework em uma aplicação ASP.NET MVC para criar o banco de dados e suas tabelas e listar os dados contidos em uma tabela usando a abordagem Code First.

C#

Model

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 Descr { get; set; }

        // Modelo Relacional (DB)
        // Aponta para o identificador da grade
        public int GradeID { get; set; }

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

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

        // Aponta para o Curso
        public ICollection<CursosModelo> Cursos { get; set; }

    }
}
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;

namespace WebApplication1.Models
{
    public class MinhaAppMeuDB : DbContext
    {
       public DbSet<CursosModelo> Cursos { get; set; }
       public DbSet<GradeModelo>  Grades { get; set; }

    }
}

View – Home

@model IEnumerable<WebApplication1.Models.CursosModelo>

@{
    ViewBag.Title = "Home Page";
}

<div class="jumbotron">
    <h1>Desenvolvimento Aberto - ASP.NET</h1>
    <p class="lead">ASP.NET - MVC - Entity Framework - HTML, CSS and JavaScript.</p>    
</div>


@foreach (var item in Model)
{
   <div>
       <h4>@item.Curso</h4>
       <div>@item.Linguagem </div>
       <div>@item.Descr</div>
       <hr />

   </div>

}

Controller – Home

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

namespace WebApplication1.Controllers
{
    public class HomeController : Controller
    {
        // Cria instancia do banco de dados
        MinhaAppMeuDB DB = new MinhaAppMeuDB();

        public ActionResult Index()
        {
            var modelo = DB.Cursos.ToList();
            return View(modelo);
        }

        // Cria método override 
        protected override void Dispose(bool disposing)
        {
            // Limpa os recursos

            if (DB != null)
            {
                DB.Dispose();
            }
            base.Dispose(disposing);
        }

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";
            
            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Your application description page.";
            
            return View();
        }
    }
}

ASP NET – Partial Views – Razor – MVC – C#

Publicado: 4 de junho de 2015 em C#

Algumas vezes você vai se deparar com a necessidade de reutilizar códigos de suas visões em suas aplicações ASP.NET MVC, um conceito muito utilizado nestas situações são as visões parciais, com este recurso você pode quebrar sua visão em vários pedaços, como por exemplo utilizando uma visão parcial para o cabeçalho, outra para o rodapé e qualquer parte de sua aplicação conforme a sua necessidade. Entretanto você também pode utilizar as visões parciais para reutilizar código de um modo mais avançado, como por exemplo reutilizar o código de um iterador utilizando apenas a parte a ser iterada, separando o iterando do resultado mostrado.

Podemos dizer que uma visão parcial permite definir uma exibição que será processada dentro de uma visão pai. As visões parciais são implementadas como controles de usuário ASP.NET (.ascx) framework Web Forms.

Partial: https://msdn.microsoft.com/en-us/library/system.web.mvc.html.partialextensions.partial(v=vs.118).aspx

 Usando Visões Parciais

1 – Crie uma nova aplicação MVC usando o template padrão ou utilize o exemplo anterior que já contem os códigos necessários para esta aplicação. Crie um controlador e uma visão utilizando o scaffold de lista para o seu modelo de dados, utilize os códigos abaixo para isto. Crie uma visão parcial vazia para nosso controlador chamada _Cursos, marque-a como uma visão parcial e adicione o modelo utilizado, lembre-se de começar as visões parciais com o caractere underline:

MVC Parcial View

MVC Parcial View

2 – Na visão de índice de lista você tem o código completo do iterador que foi gerado automaticamente, recorte o código de dentro do for each e cole em sua visão parcial. Lembre de na visão parcial trocar o item do iterador pelo modelo, pois o item só existe no escopo do iterador do qual a visão parcial não faz parte, no entanto o passaremos com parâmetro para a visão parcial:

MVC - Código Reutilizado

MVC – Código Reutilizado

3 – Rode sua aplicação e chame seu controlador, você pode perceber que a visão índice e a visão parcial formam um único resultado com o mesmo efeito que possuímos antes:

MVC - Partial View

MVC – Partial View

Exemplos:

Neste exemplo desmembramos a visão de índice em duas utilizando uma visão parcial para separar o código a ser iterado.

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) {
   
    <!--
         Os itens serão exibidos por uma visão parcial
         Você precisa enviar como parâmetro a visão e o item para o modelo
        -->
    @Html.Partial("_Cursos", item)
}

</table>

Visão Parcial

@model WebApplication1.Models.CursosModelo

<!--
      Visaão Parcial 
      Para que o modelo funcione no iterador da visão mãe    
      você precisa trocar o item pelo Model como você pode ver abaixo
    --> 
<tr>
    <td>
        @Html.DisplayFor(modelItem => Model.Curso)
    </td>
    <td>
        @Html.DisplayFor(modelItem => Model.Linguagem)
    </td>
    <td>
        @Html.DisplayFor(modelItem => Model.Dia)
    </td>
    <td>
        @Html.DisplayFor(modelItem => Model.hora)
    </td>
    <td>
        @Html.ActionLink("Edit", "Edit", new { id = Model.Id }) |
        @Html.ActionLink("Details", "Details", new { id = Model.Id }) |
        @Html.ActionLink("Delete", "Delete", new { id = Model.Id })
    </td>
</tr>

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

            // Recebe identificador do item da coleção
            var modelo = _cursos.Single(r => r.Id == id);

            // Adiciona modelo à visão
            return View(modelo);
        }

        // POST: Cursos/Edit/5
        [HttpPost]
        public ActionResult Edit(int id, FormCollection collection)
        {
            // Recebe identificador do item da coleção
            var modelo = _cursos.Single(r => r.Id == id);

            // Ainda não estamos utilizando um banco de dados
            // Então apenas vamos alterar o item da coleção
            if (TryUpdateModel(modelo))
            {
                // Caso bem sucedido redireciona para a lista
                return RedirectToAction("Index");
            }

            // retorna modelo
            return View(modelo);

        }

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

    }
}

 

ASP NET – HTML Helper – Razor – MVC – C#

Publicado: 3 de junho de 2015 em C#

Assim como o famoso framework Rails o framework ASP.NET MVC utiliza Helpers para criar elementos. Os auxiliares HTML são usados para modificar HTML. Sobretudo auxiliares HTML são mais leves. Ao contrário dos controles de formulário (Web Forms), um auxiliar HTML não tem um modelo de evento. O MVC inclui helpers padrão para os tipos mais comuns de elementos HTML, como links em HTML e elementos de formulário HTML. Também como o Rails o ASP.NET MVC possibilita que você use Scaffolding para criar automaticamente seus HTML Helpers.

Scaffolding é uma técnica apoiada por alguns frameworks MVC, nos quais o programador pode especificar a forma como o banco de dados de aplicativo pode ser usado. O compilador ou estrutura usa essa especificação, em conjunto com modelos de código pré-definido, para gerar o código final que o aplicativo podem usar para criar, ler, atualizar e excluir entradas de banco de dados, tratar eficazmente os modelos como um “Scaffolding” sobre o qual construir uma aplicação mais poderosa.

Scaffolding é uma evolução de geradores de código de banco de dados de ambientes de desenvolvimento anteriores, como CASE Gerador da Oracle, e muitos outros produtos de desenvolvimento de software 4GL cliente-servidor.

O Scaffolding se tornou popular pelo framework Ruby on Rails. Foi adaptado para outras estruturas de software, incluindo a Plataforma  OutSystems Platform, Express Framework, Play! Framework, Django, MonoRail, Symfony, Laravel, CodeIgniter, Yii, CakePHP, Model-Glue, PRADO, Grails, Catalyst, Seam Framework, Spring Roo, ASP.NET Dynamic Data e ASP.NET MVC Framework’s Metadata Template Helpers.

Os HTML Helpers pertencem a classe HtmlHelper e suporta a renderização de controles HTML em uma exibição.

HtmlHelper: https://msdn.microsoft.com/pt-br/library/system.web.mvc.htmlhelper(v=vs.118).aspx

Usando HTML Helper através de Scaffolding

1 – Crie um projeto ASP.NET MVC utilizando o template padrão. Crie um novo controlador, um modelo e uma View de acordo com os exemplos anteriores, caso não os tenha utilizado acesse o link a seguir:

Controlador, modelo e visão base do exemplo: Razor Templates

MVC - Razor Template

MVC – Razor Template

2 – Após utilizar com sucesso o exemplo acima, você pode ver que o Scaffolding de lista nos retornou um controlador pronto, para as operações básicas de um banco de dados. No entanto precisamos criar as visões para que possamos utilizar cada operação. Clique com o botão direito na ação de edição e adicione uma nova visão:

MVC - Adicionar Visão

MVC – Adicionar Visão

3 – Preencha os dados para o modelo, o Scaffolding de edição e a classe de contexto de dados:

MVC - Cria visão

MVC – Cria visão

4 – Como você pode ver o código com os HTML Helpers foram criados automaticamente para você, os Helpers criaram os elementos de edição para os registros guardados dentro de nossa lista e o botão para que possamos utilizar a ação de alteração dos dados:

MVC - HTML Helpers - Edição

MVC – HTML Helpers – Edição

5 – Agora você precisa preencher o código em suas ações de edição no controlador. Você pode perceber que existem dois métodos de edição no controlador. O primeiro utiliza o método GET que é responsável por ler os dados e alimenta-los nos elementos HTML. O segundo utiliza o método POST e é responsável por enviar os dados para que sejam alterados:

MVC - Helpers - GET

MVC – Helpers – GET

6 – Para acionar o método de edição de dados POST, você pode alterar os dados e envia-los:

MVC - Helpers - POST

MVC – Helpers – POST

7 – Assim que você postar os dados para alteração você pode ver que eles foram alterados em nossa coleção e exibidos na visão de lista:

MVC - Edição - Sucesso

MVC – Edição – Sucesso

Exemplo:

Neste exemplo utilizamos o template padrão MVC e criamos um controlador, um modelo, uma visão de lista e uma visão de edição utilizando elementos HTML através de HTML Helpers.

C#

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

            // Recebe identificador do item da coleção
            var modelo = _cursos.Single(r => r.Id == id);

            // Adiciona modelo à visão
            return View(modelo);
        }

        // POST: Cursos/Edit/5
        [HttpPost]
        public ActionResult Edit(int id, FormCollection collection)
        {
            // Recebe identificador do item da coleção
            var modelo = _cursos.Single(r => r.Id == id);

            // Ainda não estamos utilizando um banco de dados
            // Então apenas vamos alterar o item da coleção
            if (TryUpdateModel(modelo))
            {
                // Caso bem sucedido redireciona para a lista
                return RedirectToAction("Index");
            }

            // retorna modelo
            return View(modelo);

        }

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

    }
}

Visão

@model WebApplication1.Models.CursosModelo

@{
    ViewBag.Title = "Edit";
}

<h2>Edit</h2>

@using (Html.BeginForm())
{
    @Html.AntiForgeryToken()

    <div class="form-horizontal">
        <h4>CursosModelo</h4>
        <hr />
        @Html.ValidationSummary(true, "", new { @class = "text-danger" })
        @Html.HiddenFor(model => model.Id)

        <div class="form-group">
            @Html.LabelFor(model => model.Curso, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Curso, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Curso, "", new { @class = "text-danger" })
            </div>
        </div>

        <div class="form-group">
            @Html.LabelFor(model => model.Linguagem, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Linguagem, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Linguagem, "", new { @class = "text-danger" })
            </div>
        </div>

        <div class="form-group">
            @Html.LabelFor(model => model.Dia, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.Dia, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.Dia, "", new { @class = "text-danger" })
            </div>
        </div>

        <div class="form-group">
            @Html.LabelFor(model => model.hora, htmlAttributes: new { @class = "control-label col-md-2" })
            <div class="col-md-10">
                @Html.EditorFor(model => model.hora, new { htmlAttributes = new { @class = "form-control" } })
                @Html.ValidationMessageFor(model => model.hora, "", new { @class = "text-danger" })
            </div>
        </div>

        <div class="form-group">
            <div class="col-md-offset-2 col-md-10">
                <input type="submit" value="Save" class="btn btn-default" />
            </div>
        </div>
    </div>
}

<div>
    @Html.ActionLink("Back to List", "Index")
</div>

@section Scripts {
    @Scripts.Render("~/bundles/jqueryval")
}

ASP NET – Razor Layouts – MVC – C#

Publicado: 2 de junho de 2015 em C#

Para criar layouts melhores, mais fáceis e mais simples para as aplicações ASP.NET a Microsoft substituiu o conceito da clássica pagina Master do seu framework Webforms para um conceito de layouts utilizando Razor em seu framework ASP.NET MVC. Para simplificar a criação de layouts, na raiz de suas visões por padrão existe um arquivo chamado _ViewStart.cshtm e este arquivo é responsável por todo o layout de sua aplicação, definindo qual arquivo de visão criará o layout a ser utilizado pela suas paginas.

O arquivo de visão chamado _Layout.cshtm que está localizado na pasta Shared de suas visões é o arquivo de layout padrão e qualquer modificação neste arquivo implicará uma modificação em toda sua aplicação, no entanto também é possível que cada visão tenha um layout próprio. Ressaltando que arquivos de visão que começam com o caractere (_) underline não é uma visão navegável e na maioria de suas vezes é um arquivo de configuração ou layout.

Utilizando Layouts Razor

No template ASP.NET MVC o arquivo de layout é responsável por executar os estilos, os scripts e definir seu corpo ou as sessão que serão substituídas em cada pagina de visão carregada por um controlador.

1 – Crie uma aplicação ASP.NET MVC padrão e a rode. Você pode perceber que ela está toda escrita em inglês. No Solution Explorer abra a pasta de visão e a pasta Shared, copie e renomeie o arquivo _Layout.cshtml para _Layout2.cshtml:

MVC - Layout

MVC – Layout

2 – Altere o arquivo de layout 2 traduzindo o menu da aplicação e insira as seções dentro do layout, altere também  a visão de contato de acordo com os códigos abaixo. rode sua aplicação. Você constatara que a página inicial está em inglês normalmente pois ela ainda está usando o layout padrão:

ASP.NET MVC - Home

ASP.NET MVC – Home

3 – Assim que você clicar no menu Contact a visão irá ler o layout numero dois, modificado assim a inteira visão de nossa aplicação nos mostrando a página inteiramente traduzida para português:

MVC - Layout 2

MVC – Layout 2

Exemplo:

Neste exemplo utilizamos os padrões ASP.NET MVC de layouts e os trocamos dinamicamente. Você pode fazer mais alterações no template padrão MVC para se familiarizar com os Layouts Razor.

C#

Controlador

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

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

        public ActionResult About()
        {
            ViewBag.Message = "Your application description page.";
            
            return View();
        }

        public ActionResult Contact()
        {
            ViewBag.Message = "Páginas de contato.";

            // Cria texto para a sessão de layout
            ViewBag.Sessao1 = "Está é a minha sessão 1.";
            ViewBag.Sessao2 = "Está é a minha sessão 2.";
            
            return View();
        }
    }
}

Layout 2

<!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>
                </button>
                @Html.ActionLink("Desenvolvimento Aberto", "Index", "Home", new { area = "" }, new { @class = "navbar-brand" })
            </div>
            <div class="navbar-collapse collapse">
                <ul class="nav navbar-nav">
                    <li>@Html.ActionLink("Inicio", "Index", "Home")</li>
                    <li>@Html.ActionLink("Sobre", "About", "Home")</li>
                    <li>@Html.ActionLink("Contato", "Contact", "Home")</li>
                </ul>
                @Html.Partial("_LoginPartial")
            </div>
        </div>
    </div>
    <div class="container body-content">
      
        @RenderBody()

        @RenderSection("sessao1", required: true);
        <hr />
        <footer>
            <p>&copy; @DateTime.Now.Year - My ASP.NET Application</p>
            @RenderSection("sessao2", required: true);
        </footer>
    </div>

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

Visão

@{
    ViewBag.Title = "Contato";
}

@{
    // Define Layout da View
    Layout = "~/Views/Shared/_Layout2.cshtml";
}
<h2>@ViewBag.Title.</h2>
<h3>@ViewBag.Message</h3>

@section sessao1 {

    @ViewBag.Sessao1

}


<address>
    Desenvolvimento Aberto<br />
    São Paulo, Centro<br />
    <abbr title="Telefone">tel:</abbr>
    425.555.0100
</address>

<address>
    <strong>Suporte:</strong>   <a href="mailto:desenvolvimento.aberto@live.com">desenvolvimento.aberto@live.com</a><br />    
</address>

@section sessao2 {

    @ViewBag.Sessao2
}


 

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

    }
}

 

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