ASP.NET Core 2.0 verhindern doppelte Einträge

Question

Ich bin sehr neu in ASP.NET Core MVC. Ich benutze ASP.NET Core 2.0, C#, EntityFrameworkCore Code First und SQL Server 2016. Ich habe es geschafft, meine CRUD-Operationen nach Bedarf zu arbeiten.

Ich brauche jedoch Hilfe, um zu verhindern, dass Benutzer sich mehr als einmal auf meinem Formular registrieren. Wenn möglich, möchte ich die doppelten Einträge innerhalb des Codes auf der Controller-Seite und nicht innerhalb der Datenbank überprüfen/verhindern.

Ich füge meinen Code an, den ich jetzt habe, wenn jemand helfen könnte. Vielen Dank im Voraus!

Models

public class Employee 
{ 
    public int EmployeeID { get; set; } 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 

    public int DepartmentID { get; set; } 
    public Department Department { get; set; } 

    public int AppointmentID { get; set; } 
    public Appointment Appointment { get; set; } 
} 

public class Department 
{ 
    public int DepartmentID { get; set; } 
    public string Name { get; set; } 

    public ICollection<Employee> Employees { get; set; } 
} 

public class Appointment 
{ 
    public int AppointmentID { get; set; } 
    public string TimeSlot { get; set; } 

    public ICollection<Employee> Employees { get; set; } 
} 

Viewmodels

public class EmployeeFormVM 
{ 
    public int EmployeeID { get; set; } 

    [Required(ErrorMessage = "Please enter your First Name")] 
    [Display(Name = "First Name")] 
    [StringLength(50)] 
    public string FirstName { get; set; } 

    [Required(ErrorMessage = "Please enter your Last Name")] 
    [Display(Name = "Last Name")] 
    [StringLength(50)] 
    public string LastName { get; set; } 

    [Required(ErrorMessage = "Please select your Department")] 
    [Display(Name = "Department")] 
    public int DepartmentID { get; set; } 

    public IEnumerable<Department> Departments { get; set; } 

    [Required(ErrorMessage = "Please select your Appointment")] 
    [Display(Name = "Appointment")] 
    public int AppointmentID { get; set; } 

    public IEnumerable<Appointment> Appointments { get; set; } 
} 

DbContext

public class WinTenDbContext : DbContext 
{ 
    public WinTenDbContext(DbContextOptions<WinTenDbContext> options) : base(options) 
    { 
    } 

    public DbSet<Employee> Employees { get; set; } 
    public DbSet<Department> Departments { get; set; } 
    public DbSet<Appointment> Appointments { get; set; } 

    protected override void OnModelCreating(ModelBuilder modelBuilder) 
    { 
     modelBuilder.Entity<Employee>() 
      .HasKey(e => e.EmployeeID); 

     modelBuilder.Entity<Employee>() 
      .Property(e => e.FirstName) 
      .HasColumnType("varchar(50)") 
      .HasMaxLength(50) 
      .IsRequired(); 


     modelBuilder.Entity<Employee>() 
      .Property(e => e.LastName) 
      .HasColumnType("varchar(50)") 
      .HasMaxLength(50) 
      .IsRequired();    

     modelBuilder.Entity<Department>() 
      .HasKey(d => d.DepartmentID); 

     modelBuilder.Entity<Department>() 
      .Property(d => d.Name) 
      .HasColumnType("varchar(50)") 
      .HasMaxLength(50); 

     modelBuilder.Entity<Appointment>() 
      .HasKey(a => a.AppointmentID); 

     modelBuilder.Entity<Appointment>() 
      .Property(a => a.TimeSlot) 
      .HasColumnType("varchar(50)") 
      .HasMaxLength(50); 
    } 
} 

EmployeesController

public class EmployeesController : Controller 
{ 
    private readonly WinTenDbContext _context; 

    public EmployeesController(WinTenDbContext context) 
    { 
     _context = context; 
    } 

    // GET: Employees 
    public async Task<IActionResult> Index() 
    { 
     //return View(await _context.Employees.ToListAsync()); 

     var webAppDbContext = _context.Employees.Include(d => d.Department).Include(a => a.Appointment); 
     return View(await webAppDbContext.ToListAsync()); 
    } 

    // GET: Employees/Details/5 
    public async Task<IActionResult> Details(int? id) 
    { 
     if (id == null) 
     { 
      return NotFound(); 
     } 

     var employee = await _context.Employees 
      .SingleOrDefaultAsync(m => m.EmployeeID == id); 
     if (employee == null) 
     { 
      return NotFound(); 
     } 

     return View(employee); 
    } 

    // GET: Employees/Create 
    public IActionResult Create() 
    { 
     var departments = _context.Departments.ToList(); 
     var appointments = _context.Appointments.ToList(); 

     var viewModel = new EmployeeFormVM 
     { 
      Departments = departments, 
      Appointments = appointments 
     }; 

     return View(viewModel); 
    } 

    // POST: Employees/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 async Task<IActionResult> Create(EmployeeFormVM employee) 
    { 
     if (ModelState.IsValid) 
     { 
      var emp = new Employee(); 
      { 
       emp.FirstName = employee.FirstName; 
       emp.LastName = employee.LastName; 
       emp.DepartmentID = employee.DepartmentID; 
       emp.AppointmentID = employee.AppointmentID; 
      } 
      _context.Add(emp); 
      await _context.SaveChangesAsync(); 
      return RedirectToAction(nameof(Index)); 
     } 

     else 
     { 
      employee.Departments = _context.Departments.ToList(); 
      employee.Appointments = _context.Appointments.ToList(); 
      return View(employee); 
     } 
    } 

    // GET: Employees/Edit/5 
    public async Task<IActionResult> Edit(int? id) 
    { 
     if (id == null) 
     { 
      return NotFound(); 
     } 

     var employeevm = new EmployeeFormVM(); 
     { 
      Employee employee = await _context.Employees.SingleOrDefaultAsync(m => m.EmployeeID == id); 

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

      employeevm.EmployeeID = employee.EmployeeID; 
      employeevm.FirstName = employee.FirstName; 
      employeevm.LastName = employee.LastName; 

      // Retrieve list of Departments 
      var departments = _context.Departments.ToList(); 
      employeevm.Departments = departments; 
      // Set the selected department 
      employeevm.DepartmentID = employee.DepartmentID; 

      // Retrieve list of Appointments 
      var appointments = _context.Appointments.ToList(); 
      employeevm.Appointments = appointments; 
      // Set the selected department 
      employeevm.AppointmentID = employee.AppointmentID; 
     } 
     return View(employeevm); 
    } 

    // POST: Employees/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 async Task<IActionResult> Edit(EmployeeFormVM vmEdit) 
    { 
     if (ModelState.IsValid) 
     { 
      Employee employee = _context.Employees.SingleOrDefault(e => e.EmployeeID == vmEdit.EmployeeID); 

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

      employee.FirstName = vmEdit.FirstName; 
      employee.LastName = vmEdit.LastName; 
      employee.DepartmentID = vmEdit.DepartmentID; 
      employee.AppointmentID = vmEdit.AppointmentID; 

      try 
      { 
       _context.Update(employee); 
       await _context.SaveChangesAsync(); 
      } 
      catch (DbUpdateConcurrencyException) 
      { 
       if (!EmployeeExists(vmEdit.EmployeeID)) 
       { 
        return NotFound(); 
       } 
       else 
       { 
        throw; 
       } 
      } 
      return RedirectToAction(nameof(Index)); 
     } 
     return View(vmEdit); 
    } 

    // GET: Employees/Delete/5 
    public async Task<IActionResult> Delete(int? id) 
    { 
     if (id == null) 
     { 
      return NotFound(); 
     } 

     var employee = await _context.Employees 
      .SingleOrDefaultAsync(m => m.EmployeeID == id); 
     if (employee == null) 
     { 
      return NotFound(); 
     } 

     return View(employee); 
    } 

    // POST: Employees/Delete/5 
    [HttpPost, ActionName("Delete")] 
    [ValidateAntiForgeryToken] 
    public async Task<IActionResult> DeleteConfirmed(int id) 
    { 
     var employee = await _context.Employees.SingleOrDefaultAsync(m => m.EmployeeID == id); 
     _context.Employees.Remove(employee); 
     await _context.SaveChangesAsync(); 
     return RedirectToAction(nameof(Index)); 
    } 

    private bool EmployeeExists(int id) 
    { 
     return _context.Employees.Any(e => e.EmployeeID == id); 
    } 
} 

Ansicht erstellen

@using (Html.BeginForm("Create", "Employees")) 
    { 
     <div class="form-group"> 
      @Html.LabelFor(e => e.FirstName) 
      @Html.TextBoxFor(e => e.FirstName, new { @class = "form-control" }) 
      @Html.ValidationMessageFor(e => e.FirstName) 
     </div> 

     <div class="form-group"> 
      @Html.LabelFor(e => e.LastName) 
      @Html.TextBoxFor(e => e.LastName, new { @class = "form-control" }) 
      @Html.ValidationMessageFor(e => e.LastName) 
     </div> 

     <div class="form-group"> 
      @Html.LabelFor(d => d.DepartmentID) 
      @Html.DropDownListFor(d => d.DepartmentID, new SelectList(Model.Departments, "DepartmentID", "Name"), "", new { @class = "form-control" }) 
      @Html.ValidationMessageFor(d => d.DepartmentID) 
     </div> 

     <div class="form-group"> 
      @Html.LabelFor(a => a.AppointmentID) 
      @Html.DropDownListFor(a => a.AppointmentID, new SelectList(Model.Appointments, "AppointmentID", "TimeSlot"), "", new { @class = "form-control" }) 
      @Html.ValidationMessageFor(a => a.AppointmentID) 
     </div> 

     <div class="form-group"> 
      <button type="submit" class="btn btn-primary">Submit</button> 
     </div> 
    } 

Answer 1

Sie können natürlich auch für doppelte Einträge aus der Code auf dieser Seite überprüfen, aber Sie werden natürlich brauchen eine Abfrage der Datenbank laufen, um zu erreichen, Dies. Von Ihrem Code geschrieben, haben Sie bereits etwas ähnliches in EmployeesController.Edit:

Employee employee = await _context.Employees.SingleOrDefaultAsync(
    m => m.EmployeeID == id); 

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

Sie könnten diesen Ansatz und eine Variation zu EmployeesController.Create anzuwenden. z.B .:

Employee existingEmployee = await _context.Employees.SingleOrDefaultAsync(
    m => m.FirstName == employee.FirstName && m.LastName == employee.LastName); 

if (existingEmployee != null) 
{ 
    // The employee already exists. 
    // Do whatever you need to do - This is just an example. 
    ModelState.AddModelError(string.Empty, "This employee already exists."); 
    employee.Departments = _context.Departments.ToList(); 
    employee.Appointments = _context.Appointments.ToList(); 
    return View(employee); 
} 

// Your existing code for creating a new employee. 

Der Ausdruck, den ich in SingleOrDefaultAsync verwendet habe, ist nur ein Beispiel: Sie müssen entscheiden, was Ihre eigenen Anforderungen Mitarbeiter einzigartig macht nach.

die Fehlermeldung sehen, in der Controller-Code habe ich gezeigt haben, werden Sie die Ansicht erstellen aktualisieren müssen:

@using (Html.BeginForm("Create", "Employees")) 
{ 
    @Html.ValidationSummary(true) 
    ...