Arquivo de junho, 2015

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
}