Arquivo da categoria ‘C#’

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

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

Usando Atributos para Sobrecarregar Ações de Resultados

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

MVC - Controlador e Rota

MVC – Controlador e Rota

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

MVC - Atributo GET

MVC – Atributo GET

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

C#

Rotas

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

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

            // Cria uma nova rota para o controlador

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

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

Controlador

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

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

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

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

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

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

MapRoute: Mapeamento de Rotas

Utilizando Parâmetros nas Rotas

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

ASP.NET MVC - Home

ASP.NET MVC – Home

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

MVC  - Rota - Programas

MVC – Rota – Programas

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

MVC - QueryString

MVC – QueryString

Exemplo:

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

C#

RouteConfig.cs

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

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

            // Cria uma nova rota para o controlador

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

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

ProgramasController.cs

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

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

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

Publicado: 16 de maio de 2015 em C#

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

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

Usando a Sintaxe do Razor

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

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

Razor - Sintaxe

Razor – Sintaxe

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

Razor - View

Razor – View

Exemplo:

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

C#

View


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

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

<p>@Model.Mensagem</p>

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

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

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

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

ASP NET – Rotas – MVC – C#

Publicado: 14 de maio de 2015 em C#

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

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

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

Usando Rotas – ASP.NET MVC

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

MVC - View de Layout

MVC – View de Layout

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

MVC - RouteConfig

MVC – RouteConfig

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

MVC - Modelo

MVC – Modelo

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

MVC - Visão

MVC – Visão

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

MVC - Controlador

MVC – Controlador

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

MVC - Aplicação - Home

MVC – Aplicação – Home

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

MVC - Rota - Visão

MVC – Rota – Visão

Exemplo:

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

C#

_Layout.cshtml

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

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

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

Modelo
DevAbertoModel.cs

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

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

Visão

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

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

<p>@Model.Mensagem</p>

Controlador

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

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

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

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

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

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

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

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

            // Retorna modelo
            return View(modelo);

        }

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

            return View();
        }
    }
}

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

Publicado: 14 de maio de 2015 em C#

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

 Criando Modelos

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

Classe - Modelo -AboutModel

Classe – Modelo -AboutModel

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

Modelo - Propriedades

Modelo – Propriedades

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

Contoller - Controlador/Visão

Contoller – Controlador/Visão

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

View - Utiliza Modelo

View – Utiliza Modelo

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

Visão - MVC

Visão – MVC

Exemplo:

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

C#

Modelo

AboutModel.cs

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

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

    }
}

Visão

About.cshtml

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

<p>@Model.Mensagem</p>

Controlador

HomeController.cx

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

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

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

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

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

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

            return View();
        }
    }
}

 

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

Publicado: 14 de maio de 2015 em C#

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

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

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

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

Criando uma aplicação ASP.NET MVC

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

Projeto - ASP.NET

Projeto – ASP.NET

2 – Selecione o template como ASP.NET MVC:

Template - MVC

Template – MVC

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

Bem-Vindo - ASP.NET MVC

Bem-Vindo – ASP.NET MVC

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

Aplicação - MVC

Aplicação – MVC

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

Aplicação - Adaptável

Aplicação – Adaptável

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

MVC - Código HTML

MVC – Código HTML

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

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

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

MVC – Design Pattern

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

Controlador

Controlador

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

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

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

MVC - View

MVC – View

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

Aplicação MVC

Aplicação MVC

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

MVC - View - Viewbag

MVC – View – Viewbag

Exemplo:

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

C#

Controlador

HomeController.cs

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

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

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

            return View();
        }

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

            return View();
        }
    }
}

Visão

index.cshtml

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

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

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

about.cshtml

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

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

Como parte dos esforços da Microsoft o ASP.NET vem sendo desenvolvido especialmente para plataformas cruzadas, trabalhando ativamente para fazer aplicações escritas em ASP.NET serem fáceis de implantar e portar no Linux e no Mac OS X. O Mono disponibiliza o servidor XSP que é um pequeno servidor web que hospeda o Mono e as classes System.web para executar o que é comumente conhecido como ASP.NET. O XPS  é um servidor web independente que trabalha com o Mono e o MS Runtime. É  usado para debug/completar classes. O MonoApplicationHost e MonoWorkerRequest pode ser utilizado para incorporar um servidor ASP.NET em sua aplicação. Quando você instala XSP, um monte de páginas ASP.NET e serviços web de amostra são instalados também.

Você também pode usar o mod_mono que é um módulo do Apache 2.0 / 2.2 / 2.4.3 que fornece suporte para o ASP.NET. O módulo passa solicitações de páginas ASP.NET para um programa externo, mod-mono-servidor, que realmente lida com os pedidos. A comunicação entre o módulo do Apache e mod-mono-servidor é estabelecida através de um socket Unix ou um soquete TCP.

mod_mono: http://www.mono-project.com/docs/web/mod_mono/

Criando uma aplicação ASP.NET em Linux

1 – Para criar sua primeira aplicação ASP.NET no sistema operacional Linux você pode utilizar o servidor StandAlone chamado XPS. Para isso precisamos instalar o XPS4:

sudo zypper install xsp
Instalar XPS4

Instalar XPS4

2 – Você precisa iniciar o servidos XPS para rodar sua aplicação ASP.NET:

xsp4 --port 9000
XPS 4

XPS 4

3 – Abra o Visual Studio Code ou o editor ou IDE de sua preferencia e cria uma pagina ASP.NET:

Visual Studio Code

Visual Studio Code

4 – Para testar sua aplicação rode o comando a seguir:

http://localhost:9000/hello.aspx
Aplicação - ASP.NET

Aplicação – ASP.NET

Pronto! você criou sua primeira aplicação ASP.NET no sistema operacional Linux, você já pode portar suas aplicações Windows para qualquer plataforma que use o Mono.

Exemplo:

Neste exemplo criamos uma simples página ASP.NET utilizando o servido XPS.

ASP.NET

<%@ Page Language="C#" %>
<html>
<head>
   <meta charset="utf-8" />

   <style>
.center {
    margin-left: auto;
    margin-right: auto;
    width: 70%;
    background-color: #b0e0e6;
}

.auto {
    text-align: center
}

.calendario {
   margin-left: auto;
   margin-right: auto;
     width: 30%;
}
</style>
   <title>Desenvolvimento Aberto - Hello World ASP.NET</title>
</head>
<html>
   <Body>

      <h1 class="auto">Mono 4 - ASP.NET 5 </h1>
      <h2 class="auto">Hello World Web - Linux  - openSuse</h2>
      <h3 class="auto">Desenvolvimento Aberto</h3>

      <div  class="center">
         <p>“Rê, Uma parte de você cresceu em mim, juntos para sempre seremos, nunca distante,
            talvez na distância, mas não no coração.”</p>
      </div>
      <div class="calendario">
         <asp:calendar showtitle="true" runat="server"></asp:calendar>
      </div>
   </body>
</html>

A Microsoft entrou definitivamente no universo do código aberto com o lançamento da previa deu seu novo editor de códigos para Windows, Linux e OSX chamado Visual Studio Code, que na verdade é um editor de código como muitos outros editores de código existentes, VSCode adota uma interface de usuário comum e simples, utilizando o layout de um explorador à esquerda, que mostra todos os arquivos e pastas que você tem acesso ao editor e menus simples que permitem debugar e controlar seu código via GIT entre outras funcionalidades, e à direita um painel que mostra o conteúdo dos arquivos que você tem aberto. O VSCode inclui enriquecido suporte embutido para ASP.NET 5 desenvolvimento com C#, e desenvolvimento Node.js com texto TypeScript e JavaScript, alimentado pelas mesmas tecnologias subjacentes que impulsionam o Visual Studio. Code inclui grandes ferramentas para tecnologias web como HTML, CSS, Less, Sass, e JSON. O VSCode também se integra com gestores de pacotes e repositórios, e outras tarefas comuns para tornar os fluxos de trabalhos diários mais rápidos.

Visual Studio Code: https://code.visualstudio.com/

Instalando e Usando o Visual Studio Code

1 – Antes de utilizar o VSCode você precisa instalar uma versão do MONO igual ou superior a versão 3.10.0, para ver como instalar o MONO consulte nossos posts anteriores.

instalar o MONO: Mono para Suse e SLES

Visual Studio Code  - Download

Visual Studio Code – Download

 

2 – Baixe e descompacte o arquivo do VSCode utilizando a interface gráfica do openSuse, não utilize a linha de comando em alguns casos você recebe uma mensagem de erro:

Descompactar VSCode

Descompactar VSCode

3 – Abra o Visual Studio Code apenas clicando no arquivo Code, não é necessário instalar. Escolha e abra a pasta do seu projeto e crie um novo arquivo chamado helloworld.cs, utilize o código abaixo para seu arquivo:

Visual Studio Code Editor

Visual Studio Code Editor

4 – Você pode compilar seu programa pelo ícone Debug ou pela linha de comando, vamos utilizar a linha de comando:


mcs helloworld.cs
mono helloworld.exe

Mono - 4.0 - C# - Programa

Mono – 4.0 – C# – Programa

Exemplo: Neste exemplo baixamos e instalamos o VSCode para Linux, visto que já temos uma instalação do MONO (3.10.o ou maior é requerida). C#

using System;
 
namespace NetLinux
{
    class HelloWorld
    {
        public static void Main (string[] args)
        {
            // Imprime texto no console
 
            Console.WriteLine ("**********************");
            Console.WriteLine ("Desenvolvimento Aberto!\n");
            Console.WriteLine ("Hello World Mono!");
            Console.WriteLine ("Visual Studio Code!\n");
            Console.WriteLine ("**********************\n\n") ;
 
            var texto = "Re:\nEu até morreria por você. E não faria diferença alguma,\n" +
                  "porque eu morro todo minuto um pouquinho sem ter você por perto.\n";
 
            Console.WriteLine (texto);                  
 
        }
    }
}

A Microsoft e a SUSE entraram em um acordo histórico em 2006, para construir uma ponte entre o SUSE Linux Enterprise Server e Microsoft Windows Server. Desde então, soluções de interoperabilidade exclusivas da aliança têm ajudado muitos clientes ao redor do mundo consolidar, simplificar e gerenciar melhor seus ambientes de TI mistos, enquanto implementam estratégias para avançar para a nuvem.

A Novell também se engajou no desenvolvimento .NET para Linux desde cedo, criando o SUSE Linux Enterprise Mono Extension que permitia que você aproveitasse o código ASP.NET 2.0 existente, independentemente de onde ele foi desenvolvido, entre outros recursos.

Contudo em novembro de 2014 a Microsoft anunciou a abertura do código .NET CORE que é uma pilha de desenvolvimento modular que é a base de todas as futuras plataformas .NET, ele já é usado pela versão 5 do ASP.NET e .NET Native. entretanto o Mono tem uma base de código completamente separada. A comunidade Mono foi essencialmente forçada a re-implementar o .NET porque nenhuma implementação open source estava disponível. Pois antes vários clientes relataram vários desencontros, que são difíceis de corrigir, porque nenhum dos lados pode olhar o código do outro lado.

Então a versão 4.0 do Mono veio para resolver este problema com a adoção do código-fonte aberto da Microsoft, C# 6.0, porem retirou o suporte para os assemblies nas versões 2.0, 3.5 e 4.0. No futuro será lançado uma versão chamada Mono Core para permitir a utilização do tempo de execução Mono com o novo sistema de distribuição de biblioteca que está sendo desenvolvido com CoreFX.

Mono 4: http://www.mono-project.com/docs/about-mono/releases/4.0.0/

O sistema operacional Suse torna muito fácil instalar, configurar e desenvolver aplicativos .NET graças a sua intimidade com a Microsoft ao longo de sua aliança.

Mono Download: http://www.mono-project.com/download/

Instalando o Mono no openSuse

1 – Para instalar o Mono escolha a opção Mono para openSuse e SLES, clique em mono-complete:

Mono-complete

Mono-complete

2 – Escolha abrir com YaST:

YaST

YaST

3 – Na instalação do Mono clique em próximo:

Instalar Mono

Instalar Mono

4 – Nas configurações da instalação caso não queira personalizar, clique em próximo:

Personalizar

Personalizar

5 – Aguarde o andamento da instalação:

Mono - Instalando

Mono – Instalando

6 – Após a instalação bem sucedida clique em concluir:

Mono - concluir

Mono – concluir

7 – Para testar abra o terminal e digite mono -V:

mono -V

mono -V

Se você seguiu estes passos você pode utilizar o mono para desenvolver para a plataforma .NET no sistema operacional Linux, caso queira completar seu ambiente você pode instalar o banco de dados Oracle XE para Linux usando os links abaixo:

Oracle XE 11.2g x64 : Oracle XE openSuse

Oracle SQL Developer: Oracle SQL Developer openSuse

Visual Studio Code: VSCode for Linux

ASP.NET: ASP.NET

Mono – Visual Studio Code for Linux – Ubuntu

Publicado: 9 de maio de 2015 em C#

A Microsoft entrou definitivamente no universo do código aberto com o lançamento da previa deu seu novo editor de códigos para Windows, Linux e OSX chamado Visual Studio Code, que na verdade é um editor de código como muitos outros editores de código existentes, VSCode adota uma interface de usuário comum e simples, utilizando o layout de um explorador à esquerda, que mostra todos os arquivos e pastas que você tem acesso ao editor e menus simples que permitem debugar e controlar seu código via GIT entre outras funcionalidades, e à direita um painel que mostra o conteúdo dos arquivos que você tem aberto. O VSCode inclui enriquecido suporte embutido para ASP.NET 5 desenvolvimento com C#, e desenvolvimento Node.js com texto TypeScript e JavaScript, alimentado pelas mesmas tecnologias subjacentes que impulsionam o Visual Studio. Code inclui grandes ferramentas para tecnologias web como HTML, CSS, Less, Sass, e JSON. O VSCode também se integra com gestores de pacotes e repositórios, e outras tarefas comuns para tornar os fluxos de trabalhos diários mais rápidos.

Visual Studio Code: https://code.visualstudio.com/

Instalando e Usando o Visual Studio Code

1 – Antes de utilizar o VSCode você precisa instalar uma versão do MONO igual ou superior a versão 3.10.0, para ver como instalar o MONO consulte nossos posts anteriores.

instalar o MONO: Mono PPA

Visual Studio Code

Visual Studio Code

2 – Baixe e descompacte o arquivo do VSCode utilizando a interface gráfica do Ubuntu, não utilize a linha de comando em alguns casos você recebe uma mensagem de erro:

Descompactar VSCode

Descompactar VSCode

3 – Abra o Visual Studio Code apenas clicando no arquivo Code, não é necessário instalar. Escolha e abra a pasta do seu projeto e crie um novo arquivo chamado helloworld.cs, utilize o código abaixo para seu arquivo:

VSCODE - Editor

VSCODE – Editor

4 – Você pode compilar seu programa pelo ícone Debug ou pela linha de comando, vamos utilizar a linha de comando:


mcs helloworld.cs
mono helloworld.exe

Console - Executar

Console – Executar

Exemplo: Neste exemplo baixamos e instalamos o VSCode para Linux, visto que já temos uma instalação do MONO (3.10.o ou maior é requerida). C#

using System;

namespace NetLinux
{
    class HelloWorld
    {
        public static void Main (string[] args)
        {
            // Imprime texto no console

            Console.WriteLine ("**********************");
            Console.WriteLine ("Desenvolvimento Aberto!\n");
            Console.WriteLine ("Hello World Mono!");
            Console.WriteLine ("Visual Studio Code!\n");
            Console.WriteLine ("**********************\n\n") ;

            var texto = "Re:\nEu até morreria por você. E não faria diferença alguma,\n" +
                  "porque eu morro todo minuto um pouquinho sem ter você por perto.\n";

            Console.WriteLine (texto);                  

        }
    }
}