能否使用.NET Core MVC创建CRUD子视图模块？新手技术咨询

Absolutely! Handling CRUD for your ContactAssignments join entity as a subview is totally doable, and it’s a common pattern when working with explicit many-to-many relationships in EF Core MVC. Let’s break this down step by step to make it straightforward for you as a .NET newbie.

First, double-check that your entities and DbContext are configured correctly to support the relationships. Here’s a quick sanity check for your setup:

// Person entity
public class Person
{
    public int Id { get; set; }
    public string Name { get; set; }
    // Navigation to related assignments
    public ICollection<ContactAssignments> ContactAssignments { get; set; } = new List<ContactAssignments>();
}

// ContactDetails entity
public class ContactDetails
{
    public int Id { get; set; }
    public string Email { get; set; }
    public string Phone { get; set; }
    // Navigation to related assignments
    public ICollection<ContactAssignments> ContactAssignments { get; set; } = new List<ContactAssignments>();
}

// ContactAssignments join entity
public class ContactAssignments
{
    public int Id { get; set; }
    public int PersonID { get; set; }
    public int ContactDetailsID { get; set; }
    // Navigation back to parent entities
    public Person Person { get; set; }
    public ContactDetails ContactDetails { get; set; }
}

In your DbContext, configure the relationships explicitly:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    // Configure primary key (can use composite key if you don't need a standalone Id)
    modelBuilder.Entity<ContactAssignments>()
        .HasKey(ca => ca.Id);

    // Link to Person
    modelBuilder.Entity<ContactAssignments>()
        .HasOne(ca => ca.Person)
        .WithMany(p => p.ContactAssignments)
        .HasForeignKey(ca => ca.PersonID)
        .OnDelete(DeleteBehavior.Cascade); // Adjust delete behavior as needed

    // Link to ContactDetails
    modelBuilder.Entity<ContactAssignments>()
        .HasOne(ca => ca.ContactDetails)
        .WithMany(cd => cd.ContactAssignments)
        .HasForeignKey(ca => ca.ContactDetailsID)
        .OnDelete(DeleteBehavior.Restrict); // Prevent accidental deletion of contact details
}

Since you’ll need to work with both a Person and its related ContactAssignments (plus available contact details to assign), create a view model to bundle this data:

public class PersonWithContactsViewModel
{
    public Person Person { get; set; }
    public ICollection<ContactAssignments> ExistingAssignments { get; set; }
    public SelectList AvailableContactDetails { get; set; }
    public int? SelectedContactDetailsId { get; set; } // For new assignments
}

Modify your PersonController to populate the view model and handle assignment CRUD:

Get Edit/Details Action #

public async Task<IActionResult> Edit(int? id)
{
    if (id == null) return NotFound();

    // Fetch the person with existing assignments (and linked contact details)
    var person = await _context.Persons
        .Include(p => p.ContactAssignments)
        .ThenInclude(ca => ca.ContactDetails)
        .FirstOrDefaultAsync(m => m.Id == id);

    if (person == null) return NotFound();

    // Get contact details NOT already assigned to this person
    var assignedContactIds = person.ContactAssignments.Select(ca => ca.ContactDetailsId).ToList();
    var availableContacts = await _context.ContactDetails
        .Where(cd => !assignedContactIds.Contains(cd.Id))
        .ToListAsync();

    var viewModel = new PersonWithContactsViewModel
    {
        Person = person,
        ExistingAssignments = person.ContactAssignments,
        AvailableContactDetails = new SelectList(availableContacts, "Id", "Email") // Use your preferred display property
    };

    return View(viewModel);
}

Add/Remove Assignment Actions #

Add these to handle subview-specific CRUD operations:

[HttpPost]
public async Task<IActionResult> AddContactAssignment(int personId, int selectedContactDetailsId)
{
    // Validate the person and contact exist
    if (!_context.Persons.Any(p => p.Id == personId) || !_context.ContactDetails.Any(cd => cd.Id == selectedContactDetailsId))
    {
        return NotFound();
    }

    // Create and save the new assignment
    var newAssignment = new ContactAssignments
    {
        PersonID = personId,
        ContactDetailsID = selectedContactDetailsId
    };

    _context.ContactAssignments.Add(newAssignment);
    await _context.SaveChangesAsync();

    // Redirect back to the person's edit page
    return RedirectToAction(nameof(Edit), new { id = personId });
}

[HttpPost]
public async Task<IActionResult> RemoveContactAssignment(int id)
{
    var assignment = await _context.ContactAssignments.FindAsync(id);
    if (assignment == null) return NotFound();

    _context.ContactAssignments.Remove(assignment);
    await _context.SaveChangesAsync();

    // Redirect back to the person's edit page
    return RedirectToAction(nameof(Edit), new { id = assignment.PersonID });
}

Create a partial view (e.g., _ContactAssignmentsPartial.cshtml) to display and manage assignments:

@model PersonWithContactsViewModel

<h4>Assigned Contact Details</h4>
<table class="table table-sm">
    <thead>
        <tr>
            <th>Email</th>
            <th>Phone</th>
            <th>Actions</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var assignment in Model.ExistingAssignments)
        {
            <tr>
                <td>@assignment.ContactDetails.Email</td>
                <td>@assignment.ContactDetails.Phone</td>
                <td>
                    <button type="submit" 
                            formaction="@Url.Action("RemoveContactAssignment", "Person", new { id = assignment.Id })"
                            class="btn btn-sm btn-danger">
                        Remove
                    </button>
                </td>
            </tr>
        }
    </tbody>
</table>

<h4>Assign New Contact</h4>
<div class="form-group">
    <label asp-for="SelectedContactDetailsId"></label>
    <select asp-for="SelectedContactDetailsId" asp-items="Model.AvailableContactDetails" class="form-control">
        <option value="">-- Select a Contact --</option>
    </select>
    <button type="submit" 
            formaction="@Url.Action("AddContactAssignment", "Person", new { personId = Model.Person.Id })"
            class="btn btn-sm btn-primary mt-2">
        Assign Contact
    </button>
</div>

In your main Edit.cshtml view for Person, add the partial view where you want the assignment controls to appear:

@model PersonWithContactsViewModel

<!-- Your existing Person edit form fields here -->
<div class="form-group">
    <label asp-for="Person.Name"></label>
    <input asp-for="Person.Name" class="form-control" />
    <span asp-validation-for="Person.Name" class="text-danger"></span>
</div>

<!-- Embed the contact assignments subview -->
<div class="mt-4 border-top pt-3">
    <partial name="_ContactAssignmentsPartial" model="Model" />
</div>

<button type="submit" class="btn btn-primary mt-3">Save Person</button>

• Start simple: Use the synchronous redirect approach first, then explore AJAX for seamless updates once you’re comfortable.
• Validate everything: Add model validation to your view model and controller actions to avoid invalid assignments.
• Test incrementally: Test adding/removing assignments before integrating with the full person edit flow to catch issues early.

If you run into specific roadblocks (like model binding errors or EF save conflicts), feel free to share more details and we can troubleshoot further!

内容的提问来源于stack exchange，提问作者Derek