Olá agora vamos criar um dropdown em um projeto MVC3 o dropdown cria dinamicamente um select o código fonte encontra-se disponível no msdn então vamos lá, primeiramente vamos criar um projeto do zero (você pode inserir o nome que quiser).

Vamos adicionar na pasta Models uma nova classe com o nome de cidades ela não ira conter os atributos do anotation mas (não será mesário para o exemplo).

   1: using System.Collections.Generic; 

   2: using System.Linq; 

   3: using System.Web; 

   4:  

   5: namespace testeSelectItem.Models 

   6: { 

   7:     /// <summary> 

   8:     ///  Model de cidade 

   9:     /// </summary> 

  10:     public class Cidades 

  11:     { 

  12:         /// <summary> 

  13:         /// Código da cidade 

  14:         /// </summary> 

  15:         public int idCidade { get; set; } 

  16:  

  17:         /// <summary> 

  18:         /// Nome da cidade 

  19:         /// </summary> 

  20:         public string nomeCidade { get; set; } 

  21:     } 

  22: }

Vamos criar um novo projeto de nome infraestrutura poderia criar a classe na mesmo projeto mas por questão de organização preferível separar os componentes reaproveitáveis em um outro projeto, quando for desenvolver outro projeto MVC não precisar copiar a classe novamente.

Vamos criar uma classe de nome DropDown que vai criar dinamicamente o objeto consumido pelo Html.DropDownList veja que utilizei duas lambda expression como parâmetro de texto e valor do nosso dropdown existe uma grande vantagem nisso em vez de deixar o parâmetro como uma string.

1 – Obriga a sempre ser um objeto a carregar o DropDown ou melhor dizendo não um objeto estranho que não esta acessível diretamente da aplicação.

2 – Evita erros na classe devido a parâmetros informados de forma incorreta escritos errados ou alterados, qualquer um destes cenários seja gerado um erro de parâmetro incorreto e não um erro dentro da classe. 

 

   1: using System; 

   2: using System.Collections.Generic; 

   3: using System.Linq; 

   4: using System.Text; 

   5: using System.Web.Mvc; 

   6: using System.Linq.Expressions; 

   7: using System.Reflection; 

   8:  

   9: namespace Infraestrutura 

  10: { 

  11:     /// <summary> 

  12:     ///  Classe de select do HTML 

  13:     /// </summary> 

  14:     public class DropDown 

  15:     { 

  16:         /// <summary> 

  17:         ///  Construtor 

  18:         /// </summary> 

  19:         /// <param name="text">nome da propriedade a ser o texto</param> 

  20:         /// <param name="value">nome da propriedade a ser valor</param> 

  21:         /// <param name="entity">entidade (modelView)</param> 

  22:         /// <returns>lista de selectItens do ASP.NET MVC</returns> 

  23:         public IEnumerable<SelectListItem> Create<TSouce>(List<TSouce> list, Expression<Func<TSouce, object>> text, Expression<Func<TSouce, object>> value, int selectValue) 

  24:         { 

  25:             // Utiliza linq para criar o objeto (dispendando o uso de um forreach) 

  26:             return list.Select( 

  27:                                 s => new SelectListItem() 

  28:                                 { 

  29:                                     // Seta o text propriedade do objeto que e o text do <select> 

  30:                                     Text = s.GetType() 

  31:                                             .GetProperty(this.GetPropetionsName(text.Body)) 

  32:                                             .GetValue(s, null) 

  33:                                             .ToString(), 

  34:  

  35:                                     // Seta o value propriedade do objeto que e o value do <select> 

  36:                                     Value = s.GetType() 

  37:                                              .GetProperty(this.GetPropetionsName(value.Body)) 

  38:                                              .GetValue(s, null) 

  39:                                              .ToString(), 

  40:  

  41:                                     // verifica se o objeto e o que foi selecionado <select> 

  42:                                     Selected = ( 

  43:                                                     s.GetType() 

  44:                                                      .GetProperty(this.GetPropetionsName(value.Body)) 

  45:                                                      .GetValue(s, null).Equals(selectValue) 

  46:                                                 ) 

  47:                                 }).AsEnumerable<SelectListItem>(); 

  48:         } 

  49:  

  50:         /// <summary> 

  51:         ///  Retorna o nome da propriedade 

  52:         /// </summary> 

  53:         /// <param name="member">menbro expression</param> 

  54:         /// <returns>nome da propriedade</returns> 

  55:         public string GetPropetionsName(Expression member) 

  56:         { 

  57:             MemberInfo info = null; 

  58:  

  59:             // Retorna o operador da expressão 

  60:             var nextOperand = member; 

  61:  

  62:             // Verifica os tipos da árvore de expressão. 

  63:             // ExpressionType.Convert : Uma operação de conversão ou de conversão, como (SampleType)obj  

  64:             if (nextOperand.NodeType == ExpressionType.Convert) 

  65:             { 

  66:                 var unaryExpression = (UnaryExpression)nextOperand; 

  67:                 info = (unaryExpression.Operand as MemberExpression).Member; 

  68:             } 

  69:             // ExpressionType.MemberAccess : Uma operação que lê a partir de um campo ou propriedade, como obj.SampleProperty. 

  70:             else if (nextOperand.NodeType == ExpressionType.MemberAccess) 

  71:             { 

  72:                 info = (nextOperand as MemberExpression).Member; 

  73:             } 

  74:             // Se não a expressão não e assesivel 

  75:             else 

  76:             { 

  77:                 throw new ArgumentException("Not a member access", "expression"); 

  78:             } 

  79:  

  80:             return info.Name; 

  81:         } 

  82:     } 

  83: } 

Agora vamos criar um classe userView que contem a cidade utilizaremos agora o dataAnotatios já que geraremos a tela a partir desta classe.

   1:  

   2:  

   3: using System.Collections.Generic; 

   4: using System.Linq; 

   5: using System.Web; 

   6: using System.ComponentModel.DataAnnotations; 

   7: using System.Web.Mvc; 

   8:  

   9: namespace testeSelectItem.Models 

  10: { 

  11:     /// <summary> 

  12:     ///  Model de usuario 

  13:     /// </summary> 

  14:     public class UserView 

  15:     { 

  16:         /// <summary> 

  17:         ///  Codigo do usuario 

  18:         /// </summary> 

  19:         [Required] 

  20:         [Display(Name = "Código")] 

  21:         public int idUsuario { get; set; } 

  22:          

  23:         /// <summary> 

  24:         ///  Nome do usuario 

  25:         /// </summary> 

  26:         [Required] 

  27:         [Display(Name = "Nome")] 

  28:         public string nomeUsuario { get; set; } 

  29:  

  30:         /// <summary> 

  31:         /// Cidade do usuario 

  32:         /// </summary> 

  33:         [Required] 

  34:         [Display(Name = "Cidade")] 

  35:         public IEnumerable<SelectListItem> cidadeUsuario { get; set; } 

  36:     } 

  37: }

 

Crie agora um controller para user.

   1: using System; 

   2: using System.Collections.Generic; 

   3: using System.Linq; 

   4: using System.Web; 

   5: using System.Web.Mvc; 

   6: using testeSelectItem.Models; 

   7: using Infraestrutura; 

   8:  

   9: namespace testeSelectItem.Controllers 

  10: { 

  11:     public class UserController : Controller 

  12:     { 

  13:         /// <summary> 

  14:         ///  Lista de exemplo 

  15:         /// </summary> 

  16:         public List<Cidades> teste = new List<Cidades>() 

  17:         { 

  18:             new Cidades(){ idCidade = 1,nomeCidade= "belo horizonte"}, 

  19:             new Cidades(){ idCidade = 2,nomeCidade= "sao paulo"}, 

  20:             new Cidades(){ idCidade = 3,nomeCidade= "rio de janeiro"}, 

  21:         }; 

  22:  

  23:         // 

  24:         // GET: /User/Create 

  25:  

  26:         public ActionResult Create() 

  27:         { 

  28:             var user = new UserView(); 

  29:             user.cidadeUsuario = new DropDown().Create(teste, x => x.nomeCidade, y => y.idCidade, 0); 

  30:             return View(user); 

  31:         }  

  32:  

  33:         // 

  34:         // POST: /User/Create 

  35:         [HttpPost] 

  36:         public ActionResult Create(Infraestrutura.Model.User user) 

  37:         { 

  38:             return View(); 

  39:         } 

  40:  

  41:     } 

  42: } 

Veja que no controller no action create foi chamado a classe DropDown repare que no POST existe uma outra classe de User em infraestrutura ela e um POCO que não vou entrar em detalhes quem sabe numa outra oportunidade.

Na view e chamado o dropdown.

   1: @Html.DropDownListFor(x =>x.cidadeUsuario,Model.cidadeUsuario)

 

Espero que tenha sido útil ate mais……..