CheckBoxList mit ASP.NET MVC 5

Question

Ich habe Probleme zu verstehen, wie Daten aus meiner Device-Tabelle in meiner Datenbank zu einer CheckBoxList abgerufen werden.

Ich glaube, ich habe die Modelle, ViewModel und Datenbank richtig eingerichtet, aber ich bin mir nicht sicher, was ich als nächstes tun soll. Für den Moment möchte ich einfach lernen, wie man die Daten von meiner Tabelle zu einer CheckBoxList zurückholt.

Kunden Modell

public class Customer 
{ 
    public int CustId { get; set; } 
    public string CustDisplayName { get; set; } 
    public string CustFirstName { get; set; } 
    public string CustLastName { get; set; } 
    public string CustCompanyName { get; set; } 
    public string CustAddress { get; set; } 
    public string CustPhoneNumber { get; set; } 
    public string CustMobileNumber { get; set; } 
    public string CustEmailAddress { get; set; } 

    public int StId { get; set; } 
    public State State { get; set; } 
} 

State Model

public class State 
{ 
    public int StId { get; set; } 
    public string StAbbr { get; set; } 

    public List<Customer> Customers { get; set; } 
} 

Gerätemodell

public class Device 
{ 
    public int DevId { get; set; } 
    public string DevType { get; set; } 
    public bool isChecked { get; set; } 
} 

CustomerDevice Modell

public class CustomerDevice 
{ 
    public int CustId { get; set; } 
    public int DevId { get; set; } 

    public Customer Customer { get; set; } 
    public Device Device { get; set; } 
} 

CustomerViewModel

public class CustomerFormViewModel 
{ 
    public int CustId { get; set; } 

    [Required(ErrorMessage = "Enter Display Name")] 
    [Display(Name = "Display Name")] 
    [StringLength(100)] 
    public string CustDisplayName { get; set; } 

    [Display(Name = "First Name")] 
    [StringLength(50)] 
    public string CustFirstName { get; set; } 

    [Display(Name = "Last Name")] 
    [StringLength(50)] 
    public string CustLastName { get; set; } 

    [Display(Name = "Company Name")] 
    [StringLength(50)] 
    public string CustCompanyName { get; set; } 

    [Display(Name = "Phone Number")] 
    [DataType(DataType.PhoneNumber)] 
    [StringLength(12)] 
    public string CustPhoneNumber { get; set; } 

    [Display(Name = "Mobile Number")] 
    [DataType(DataType.PhoneNumber)] 
    [StringLength(12)] 
    public string CustMobileNumber { get; set; } 

    [Display(Name = "Email Address")] 
    [DataType(DataType.EmailAddress)] 
    [StringLength(320)] 
    public string CustEmailAddress { get; set; } 

    [Required(ErrorMessage = "Enter Address")] 
    [Display(Name = "Address")] 
    [StringLength(100)] 
    public string CustAddress { get; set; } 

    [Required(ErrorMessage = "Select State")] 
    [Display(Name = "State")] 
    public int StId { get; set; } 

    public IEnumerable<State> States { get; set; } 
} 

CustomerController

public class CustomerController : Controller 
{ 
    private CoreWebAppContext _context; 

    public CustomerController(CoreWebAppContext context) 
    { 
     _context = context; 
    } 


    // GET: /<controller>/ 
    public IActionResult Index() 
    { 
     return View(_context.Customers.ToList()); 
    } 


    public ActionResult Create() 
    { 
     var states = _context.States.ToList(); 
     var viewModel = new CustomerFormViewModel 
     { 
      States = states 
     }; 

     return View(viewModel); 
    } 


    [HttpPost] 
    [ValidateAntiForgeryToken] 
    public ActionResult Create(CustomerFormViewModel vm) 
    { 
     if (ModelState.IsValid) 
     { 
      var customer = new Customer(); 
      { 
       customer.CustDisplayName = vm.CustDisplayName; 
       customer.CustFirstName = vm.CustFirstName; 
       customer.CustLastName = vm.CustLastName; 
       customer.CustCompanyName = vm.CustCompanyName; 
       customer.CustAddress = vm.CustAddress; 
       customer.CustPhoneNumber = vm.CustPhoneNumber; 
       customer.CustMobileNumber = vm.CustMobileNumber; 
       customer.CustEmailAddress = vm.CustEmailAddress; 
       customer.StId = vm.StId; 
      } 
      _context.Customers.Add(customer); 
      _context.SaveChanges(); 
      return RedirectToAction("Index"); 
     } 

     else 
     { 
      vm.States = _context.States.ToList(); 
      return View(vm); 
     } 
    } 


    public ActionResult Edit(int? id) 
    { 
     if (id == null) 
     { 
      return NotFound(); 
     } 

     var customervm = new CustomerFormViewModel(); 
     { 
      Customer customer = _context.Customers.SingleOrDefault(c => c.CustId == id); 

      if (customer == null) 
      { 
       return NotFound(); 
      } 

      customervm.CustId = customer.CustId; 
      customervm.CustDisplayName = customer.CustDisplayName; 
      customervm.CustFirstName = customer.CustFirstName; 
      customervm.CustLastName = customer.CustLastName; 
      customervm.CustCompanyName = customer.CustCompanyName; 
      customervm.CustAddress = customer.CustAddress; 
      customervm.CustPhoneNumber = customer.CustPhoneNumber; 
      customervm.CustMobileNumber = customer.CustMobileNumber; 
      customervm.CustEmailAddress = customer.CustEmailAddress; 

      // Retrieve list of States 
      var states = _context.States.ToList(); 
      customervm.States = states; 

      // Set the selected state 
      customervm.StId = customer.StId; 
     } 
     return View(customervm); 
    } 


    [HttpPost] 
    [ValidateAntiForgeryToken] 
    public ActionResult Edit(CustomerFormViewModel vmEdit) 
    { 
     if (ModelState.IsValid) 
     { 
      Customer customer = _context.Customers.SingleOrDefault(c => c.CustId == vmEdit.CustId); 

      if (customer == null) 
      { 
       return NotFound(); 
      } 

      customer.CustDisplayName = vmEdit.CustDisplayName; 
      customer.CustFirstName = vmEdit.CustFirstName; 
      customer.CustLastName = vmEdit.CustLastName; 
      customer.CustCompanyName = vmEdit.CustCompanyName; 
      customer.CustAddress = vmEdit.CustAddress; 
      customer.CustPhoneNumber = vmEdit.CustPhoneNumber; 
      customer.CustMobileNumber = vmEdit.CustMobileNumber; 
      customer.CustEmailAddress = vmEdit.CustEmailAddress; 
      customer.StId = vmEdit.StId; 

      _context.Entry(customer).State = EntityState.Modified; 
      _context.SaveChanges(); 
      return RedirectToAction("Index"); 
     } 
     return View(vmEdit); 
    } 


} 

Ansicht erstellen

Answer 1

Machen Sie eine weitere Ansichtsmodell Klasse IndexViewModel und setzen diese auf sie genannt:

public class IndexViewModel 
{ 
    public List<Customer> Customers { get; set; } 
    public List<Device> Devices { get; set; } 
} 

Hier ist der Controller Aktion. Bringen Sie den neuen IndexViewModel statt:

// GET: /<controller>/ 
public IActionResult Index() 
{ 
    return View(_context.Customers.ToList()); 
} 

zu

// GET: /<controller>/ 
public IActionResult Index() 
{ 
    var model = new IndexViewModel(); 
    model.Customers = _context.Customers.ToList(); 
    model.Devices = _context.Devices.ToList(); 

    return View(model); 
} 

Ihrer Ansicht nach iterieren einfach die Geräteliste:

@{ 
    for(int i = 0; i < Model.Devices.Count(); i++) 
    { 
     var checkboxAttributes = Model.Devices[i].isChecked == true ? 
      (object) new { @class = "checkbox", @checked = "checked" } : 
      (object) new { @class = "checkbox" }; 

     @Html.CheckBoxFor(model => model.Devices[i].DevType, checkboxAttributes) 
     @Html.LabelFor(model => model.Devices[i].DevType, new { @class = "label" }) 
    } 
} 

Update 1

Es tut mir leid um die vorherigen, aber dies ist die richtige Version: Es Bootstrap-Stil für das Kontrollkästchen verwendet:

@{ 
    for (int i = 0; i < Model.Devices.Count(); i++) 
    { 
     <div class="checkbox"> 
      <label> 
       @Html.HiddenFor(model => model.Devices[i].DevId) 
       @Html.CheckBoxFor(model => model.Devices[i].isChecked) 
       @Html.DisplayFor(model => model.Devices[i].DevType) 
       @Html.HiddenFor(model => model.Devices[i].DevType) 
      </label> 
     </div> 
    } 
} 

Answer 2

Sie so etwas wie dieses verwenden, so dass Sie es für verschiedene Modelle wiederverwenden können .

CheckboxViewModel:

public class CheckboxViewModel 
{ 
    public int Id { get; set; } 

    public string Name { get; set; } 

    public bool Checked { get; set; } 
} 

Erweiterungsmethode:

public static IEnumerable<CheckboxViewModel> CreateCheckboxList<T>(this List<T> entities, Func<T, object> value, Func<T, object> text, Func<T, bool> isChecked) 
    { 
     return entities.Select(x => new CheckboxViewModel 
     { 
      Id = (int)value(x), 
      Name = text(x).ToString(), 
      Checked = isChecked(x) 
     }); 
    } 

Mit Beispiel:

result = devices.CreateCheckboxList(x => x.Id, x => x.Name, x => selectedDevices.Contains(x.Id)).ToList(); 

@for (var deviceIndex = 0; deviceIndex < Model.Devices.Count(); deviceIndex ++) 
          { 
           <div class="form-group"> 
            <div class="checkbox checkbox-primary"> 
             @Html.HiddenFor(model => model.Devices[deviceIndex ].Id) 
             @Html.CheckBoxFor(model => model.Devices[deviceIndex ].Checked) 
             @Html.LabelFor(model => model.Devices[deviceIndex ].Checked, Model.Devices[deviceIndex ].Name) 
            </div> 
           </div> 
          }