In ASP.NET Core, routing to controller actions is typically handled through the use of attributes on controller methods. These attributes define the route template that maps incoming HTTP requests to specific controller actions.
Here's a basic example of how routing is set up in ASP.NET Core.
Example One for Teacher Controller
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.EntityFrameworkCore;
using DataTransferBetweenControllersinASPNETCoreMVC.DatbaseContext;
using DataTransferBetweenControllersinASPNETCoreMVC.Models;
namespace DataTransferBetweenControllersinASPNETCoreMVC.Controllers
{
public class TeachersController : Controller
{
private readonly AppDbContext _context;
public TeachersController(AppDbContext context)
{
_context = context;
}
// GET: Teachers
public async Task<IActionResult> Index()
{
// Recieve the Student Object data and then keep the data
var studentData = TempData["student"];
TempData.Keep();
return View(await _context.Teachers.ToListAsync());
}
// GET: Teachers/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var teacher = await _context.Teachers
.FirstOrDefaultAsync(m => m.Id == id);
if (teacher == null)
{
return NotFound();
}
return View(teacher);
}
// GET: Teachers/Create
public IActionResult Create()
{
return View();
}
// POST: Teachers/Create
// To protect from overposting attacks, 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([Bind("Id,Name,Course,Department")] Teacher teacher)
{
if (ModelState.IsValid)
{
_context.Add(teacher);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
return View(teacher);
}
// GET: Teachers/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}
var teacher = await _context.Teachers.FindAsync(id);
if (teacher == null)
{
return NotFound();
}
return View(teacher);
}
// POST: Teachers/Edit/5
// To protect from overposting attacks, 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(int id, [Bind("Id,Name,Course,Department")] Teacher teacher)
{
if (id != teacher.Id)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(teacher);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TeacherExists(teacher.Id))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
return View(teacher);
}
// GET: Teachers/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var teacher = await _context.Teachers
.FirstOrDefaultAsync(m => m.Id == id);
if (teacher == null)
{
return NotFound();
}
return View(teacher);
}
// POST: Teachers/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var teacher = await _context.Teachers.FindAsync(id);
if (teacher != null)
{
_context.Teachers.Remove(teacher);
}
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
private bool TeacherExists(int id)
{
return _context.Teachers.Any(e => e.Id == id);
}
}
}
Example 2 for student Controller
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.EntityFrameworkCore;
using DataTransferBetweenControllersinASPNETCoreMVC.DatbaseContext;
using DataTransferBetweenControllersinASPNETCoreMVC.Models;
namespace DataTransferBetweenControllersinASPNETCoreMVC.Controllers
{
public class StudentsController : Controller
{
private readonly AppDbContext _context;
public StudentsController(AppDbContext context)
{
_context = context;
}
// GET: Students
public async Task<IActionResult> Index()
{
return View(await _context.Students.ToListAsync());
}
// GET: Students/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var student = await _context.Students
.FirstOrDefaultAsync(m => m.Id == id);
if (student == null)
{
return NotFound();
}
return View(student);
}
// GET: Students/Create
public IActionResult Create()
{
return View();
}
// POST: Students/Create
// To protect from overposting attacks, 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(Student student)
{
if (ModelState.IsValid)
{
_context.Add(student);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
// Transfer the Complete Student Object to Teacher
TempData["student"] = student;
return RedirectToAction("Index","Teacher");
}
// GET: Students/Edit/5
public async Task<IActionResult> Edit(int? id)
{
if (id == null)
{
return NotFound();
}
var student = await _context.Students.FindAsync(id);
if (student == null)
{
return NotFound();
}
return View(student);
}
// POST: Students/Edit/5
// To protect from overposting attacks, 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(int id, [Bind("Id,Name,RollNo,Section,Program")] Student student)
{
if (id != student.Id)
{
return NotFound();
}
if (ModelState.IsValid)
{
try
{
_context.Update(student);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentExists(student.Id))
{
return NotFound();
}
else
{
throw;
}
}
return RedirectToAction(nameof(Index));
}
return View(student);
}
// GET: Students/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var student = await _context.Students
.FirstOrDefaultAsync(m => m.Id == id);
if (student == null)
{
return NotFound();
}
return View(student);
}
// POST: Students/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var student = await _context.Students.FindAsync(id);
if (student != null)
{
_context.Students.Remove(student);
}
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
private bool StudentExists(int id)
{
return _context.Students.Any(e => e.Id == id);
}
}
}
- The
[Route] attribute at the controller level sets the base route for all actions within the controller.
- The
[HttpGet], [HttpPost], [HttpPut], and [HttpDelete] attributes specify the HTTP verb used to invoke the corresponding action.
- The
[HttpGet("{id}")], [HttpPut("{id}")], and [HttpDelete("{id}")] attributes include route parameters (like {id}) in the route template, allowing actions to handle requests with dynamic values.
Multiple conventional routes
In ASP.NET Core, you can define multiple conventional routes using the MapControllerRoute method within the Startup.cs file's Configure method. This allows you to specify different routes for different controllers or groups of controllers.
Here's an example of how you can set up multiple conventional routes in ASP.NET Core.
using DataTransferBetweenControllersinASPNETCoreMVC.DatbaseContext;
using Microsoft.EntityFrameworkCore;
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddRazorPages();
var configuration = builder.Configuration;
// Add services to the container.
builder.Services.AddDbContext<AppDbContext>(options =>
options.UseSqlite(configuration.GetConnectionString("DefaultConnection")));
var app = builder.Build();
// Configure the HTTP request pipeline.
if(!app.Environment.IsDevelopment())
{
app.UseExceptionHandler("/Error");
// The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
app.UseHsts();
}
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
endpoints.MapControllerRoute(
name: "Teacher",
pattern: "Teacher/{controller=Teacher}/{action=Index}/{id?}");
endpoints.MapControllerRoute(
name: "Student",
pattern: "Student/{controller=Student}/{action=Index}/{id?}");
});
app.MapRazorPages();
app.Run();
In this example
- The
MapControllerRoute method is used to define conventional routes.
- The
"default" route specifies the default route pattern, which matches requests to controllers and actions, optionally including an ID parameter.
- The
"Teacher" , "Student" route specifies a custom route pattern for controllers and actions under the "blog" directory.
- Additional conventional routes can be defined as needed, each with its unique name and pattern.
- The
MapFallbackToController method is used to specify a fallback route, which directs requests to the "Index" action of the "Home" controller if no other route matches.
By defining multiple conventional routes in this manner, you can organize and customize the URL structure of your ASP.NET Core application to suit your needs.
GitHub Project URL: https://github.com/SardarMudassarAliKhan/DataTransferBetweenControllersinASPNETCoreMVC
Conclusion
In ASP.NET Core, routing to controller actions is achieved through the use of attributes on controller methods, which define the route templates mapping incoming HTTP requests to specific actions. Additionally, multiple conventional routes can be set up in the Startup.cs file using the MapControllerRoute method, allowing for customization of the URL structure for different controllers or groups of controllers. This flexibility in routing enables developers to design clear and organized routes tailored to the requirements of their applications.