Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
Jegyzet
Ez nem a cikk legújabb verziója. Az aktuális kiadásról a cikk .NET 10-es verziójában olvashat.
Figyelmeztetés
A ASP.NET Core ezen verziója már nem támogatott. További információ: .NET és .NET Core támogatási szabályzat. Az aktuális verzió megtekintéséhez lásd a cikk .NET 9-es verzióját.
Készítette: Rick Anderson
Nyissa meg a Filmvezérlőt, és vizsgálja meg a Details metódust:
// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
A műveletmetódust létrehozó MVC-állványmotor megjegyzést ad hozzá, amely egy HTTP-kérést jelenít meg, amely meghívja a metódust. Ebben az esetben ez egy GET kérés három URL-szegmenssel, a Movies vezérlővel, a Details metódussal és egy id értékkel. Ezeket a szegmenseket a Program.cshatározza meg.
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
Az EF megkönnyíti az adatok keresését a FirstOrDefaultAsync metódus használatával. A metódusba beépített fontos biztonsági funkció, hogy a kód ellenőrzi, hogy a keresési módszer talált-e filmet, mielőtt bármit megpróbálna vele csinálni. Egy hacker például hibákat okozhat a webhelyen, ha a hivatkozások által létrehozott URL-címet a http://localhost:{PORT}/Movies/Details/1-ről a http://localhost:{PORT}/Movies/Details/12345-ra (vagy más olyan értékre módosítja, amely nem jelent tényleges filmet). Ha nem ellenőrizte a null filmet, az alkalmazás kivételt eredményezne.
Vizsgálja meg a Delete és DeleteConfirmed metódusokat.
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.FindAsync(id);
if (movie != null)
{
_context.Movie.Remove(movie);
}
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
Vegye figyelembe, hogy a HTTP GET Delete metódus nem törli a megadott filmet, hanem visszaadja annak a filmnek a nézetét, ahol elküldheti (HttpPost) a törlést. Ha a GET-kérésre válaszul törlési műveletet hajt végre (vagy ami azt illeti, szerkesztési művelet végrehajtása, létrehozási művelet vagy bármely más, az adatokat módosító művelet) biztonsági rést nyit meg.
Az adatokat törlő [HttpPost] metódus neve DeleteConfirmed, hogy a HTTP POST metódus egyedi aláírást vagy nevet adjon. A két metódusaláírás az alábbiakban láthatók:
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
A közös nyelvi futtatókörnyezet (CLR) megköveteli, hogy a túlterhelt metódusok egyedi paraméter-aláírással rendelkezzenek (ugyanazzal a metódusnévvel, de a paraméterek különböző listájával). Itt azonban két Delete metódusra van szükség – egyet a GET-hez, egyet a POST-hoz –, amelyek mindegyike ugyanazzal a paraméter-aláírászal rendelkezik. (Mindkettőnek egyetlen egész számot kell elfogadnia paraméterként.)
Ennek a problémának két megközelítése van, az egyik az, hogy különböző neveket ad a metódusoknak. Ezt tette az állványzati mechanizmus az előző példában. Ez azonban egy kis problémát jelent: ASP.NET egy URL-cím szegmenseit név alapján leképezi a műveletmetódusokra, és ha átnevez egy metódust, az útválasztás általában nem találja ezt a metódust. A megoldás az, amit a példában lát, vagyis a ActionName("Delete") attribútum hozzáadása a DeleteConfirmed metódushoz. Ez az attribútum az útválasztási rendszer számára végzi a leképezést, így egy /Delete/ URL-t tartalmazó POST-kérelem megtalálja a DeleteConfirmed metódust.
Az azonos névvel és aláírással rendelkező metódusok egy másik gyakori feladata, hogy mesterségesen módosítsa a POST metódus aláírását úgy, hogy egy extra (nem használt) paramétert tartalmazzon. Ezt tettük egy korábbi bejegyzésben, amikor hozzáadtuk a notUsed paramétert. Ugyanezt megteheti itt a [HttpPost] Delete metódus esetében is:
// POST: Movies/Delete/6
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)
Közzététel az Azure-ban
Az Azure-ban való üzembe helyezésről további információt a oktatóanyagban talál: ASP.NET Core- és SQL Database-alkalmazás létrehozása az Azure App Service.
Vállalati webalkalmazás-minták
A megbízható, biztonságos, teljesíthető, tesztelhető és méretezhető ASP.NET Core-alkalmazás létrehozásával kapcsolatos útmutatásért tekintse meg Vállalati webalkalmazás-mintákcímű témakört. Rendelkezésre áll egy teljes éles minőségű minta webalkalmazás, amely implementálja a mintákat.
Nyissa meg a Filmvezérlőt, és vizsgálja meg a Details metódust:
// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
A műveletmetódust létrehozó MVC-állványmotor megjegyzést ad hozzá, amely egy HTTP-kérést jelenít meg, amely meghívja a metódust. Ebben az esetben ez egy GET kérés három URL-szegmenssel, a Movies vezérlővel, a Details metódussal és egy id értékkel. Ezeket a szegmenseket a Program.cshatározza meg.
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
Az EF megkönnyíti az adatok keresését a FirstOrDefaultAsync metódus használatával. A metódusba beépített fontos biztonsági funkció, hogy a kód ellenőrzi, hogy a keresési módszer talált-e filmet, mielőtt bármit megpróbálna vele csinálni. Egy hacker például hibákat okozhat a webhelyen, ha a hivatkozások által létrehozott URL-címet a http://localhost:{PORT}/Movies/Details/1-ről a http://localhost:{PORT}/Movies/Details/12345-ra (vagy más olyan értékre módosítja, amely nem jelent tényleges filmet). Ha nem ellenőrizte a null filmet, az alkalmazás kivételt eredményezne.
Vizsgálja meg a Delete és DeleteConfirmed metódusokat.
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.FindAsync(id);
if (movie != null)
{
_context.Movie.Remove(movie);
}
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
Vegye figyelembe, hogy a HTTP GET Delete metódus nem törli a megadott filmet, hanem visszaadja annak a filmnek a nézetét, ahol elküldheti (HttpPost) a törlést. Ha a GET-kérésre válaszul törlési műveletet hajt végre (vagy ami azt illeti, szerkesztési művelet végrehajtása, létrehozási művelet vagy bármely más, az adatokat módosító művelet) biztonsági rést nyit meg.
Az adatokat törlő [HttpPost] metódus neve DeleteConfirmed, hogy a HTTP POST metódus egyedi aláírást vagy nevet adjon. A két metódusaláírás az alábbiakban láthatók:
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
A közös nyelvi futtatókörnyezet (CLR) megköveteli, hogy a túlterhelt metódusok egyedi paraméter-aláírással rendelkezzenek (ugyanazzal a metódusnévvel, de a paraméterek különböző listájával). Itt azonban két Delete metódusra van szükség – egyet a GET-hez, egyet a POST-hoz –, amelyek mindegyike ugyanazzal a paraméter-aláírászal rendelkezik. (Mindkettőnek egyetlen egész számot kell elfogadnia paraméterként.)
Ennek a problémának két megközelítése van, az egyik az, hogy különböző neveket ad a metódusoknak. Ezt tette az állványzati mechanizmus az előző példában. Ez azonban egy kis problémát jelent: ASP.NET egy URL-cím szegmenseit név alapján leképezi a műveletmetódusokra, és ha átnevez egy metódust, az útválasztás általában nem találja ezt a metódust. A megoldás az, amit a példában lát, vagyis a ActionName("Delete") attribútum hozzáadása a DeleteConfirmed metódushoz. Ez az attribútum az útválasztási rendszer számára végzi a leképezést, így egy /Delete/ URL-t tartalmazó POST-kérelem megtalálja a DeleteConfirmed metódust.
Az azonos névvel és aláírással rendelkező metódusok egy másik gyakori feladata, hogy mesterségesen módosítsa a POST metódus aláírását úgy, hogy egy extra (nem használt) paramétert tartalmazzon. Ezt tettük egy korábbi bejegyzésben, amikor hozzáadtuk a notUsed paramétert. Ugyanezt megteheti itt a [HttpPost] Delete metódus esetében is:
// POST: Movies/Delete/6
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)
Közzététel az Azure-ban
Az Azure-ban való üzembe helyezésről további információt a oktatóanyagban talál: ASP.NET Core- és SQL Database-alkalmazás létrehozása az Azure App Service.
Vállalati webalkalmazás-minták
A megbízható, biztonságos, teljesíthető, tesztelhető és méretezhető ASP.NET Core-alkalmazás létrehozásával kapcsolatos útmutatásért tekintse meg Vállalati webalkalmazás-mintákcímű témakört. Rendelkezésre áll egy teljes éles minőségű minta webalkalmazás, amely implementálja a mintákat.
Nyissa meg a Filmvezérlőt, és vizsgálja meg a Details metódust:
// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
A műveletmetódust létrehozó MVC-állványmotor megjegyzést ad hozzá, amely egy HTTP-kérést jelenít meg, amely meghívja a metódust. Ebben az esetben ez egy GET kérés három URL-szegmenssel, a Movies vezérlővel, a Details metódussal és egy id értékkel. Ezeket a szegmenseket a Program.cshatározza meg.
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
Az EF megkönnyíti az adatok keresését a FirstOrDefaultAsync metódus használatával. A metódusba beépített fontos biztonsági funkció, hogy a kód ellenőrzi, hogy a keresési módszer talált-e filmet, mielőtt bármit megpróbálna vele csinálni. Egy hacker például hibákat okozhat a webhelyen, ha a hivatkozások által létrehozott URL-címet a http://localhost:{PORT}/Movies/Details/1-ről a http://localhost:{PORT}/Movies/Details/12345-ra (vagy más olyan értékre módosítja, amely nem jelent tényleges filmet). Ha nem ellenőrizte a null filmet, az alkalmazás kivételt eredményezne.
Vizsgálja meg a Delete és DeleteConfirmed metódusokat.
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.FindAsync(id);
if (movie != null)
{
_context.Movie.Remove(movie);
}
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
Vegye figyelembe, hogy a HTTP GET Delete metódus nem törli a megadott filmet, hanem visszaadja annak a filmnek a nézetét, ahol elküldheti (HttpPost) a törlést. Ha a GET-kérésre válaszul törlési műveletet hajt végre (vagy ami azt illeti, szerkesztési művelet végrehajtása, létrehozási művelet vagy bármely más, az adatokat módosító művelet) biztonsági rést nyit meg.
Az adatokat törlő [HttpPost] metódus neve DeleteConfirmed, hogy a HTTP POST metódus egyedi aláírást vagy nevet adjon. A két metódusaláírás az alábbiakban láthatók:
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
A közös nyelvi futtatókörnyezet (CLR) megköveteli, hogy a túlterhelt metódusok egyedi paraméter-aláírással rendelkezzenek (ugyanazzal a metódusnévvel, de a paraméterek különböző listájával). Itt azonban két Delete metódusra van szükség – egyet a GET-hez, egyet a POST-hoz –, amelyek mindegyike ugyanazzal a paraméter-aláírászal rendelkezik. (Mindkettőnek egyetlen egész számot kell elfogadnia paraméterként.)
Ennek a problémának két megközelítése van, az egyik az, hogy különböző neveket ad a metódusoknak. Ezt tette az állványzati mechanizmus az előző példában. Ez azonban egy kis problémát jelent: ASP.NET egy URL-cím szegmenseit név alapján leképezi a műveletmetódusokra, és ha átnevez egy metódust, az útválasztás általában nem találja ezt a metódust. A megoldás az, amit a példában lát, vagyis a ActionName("Delete") attribútum hozzáadása a DeleteConfirmed metódushoz. Ez az attribútum az útválasztási rendszer számára végzi a leképezést, így egy /Delete/ URL-t tartalmazó POST-kérelem megtalálja a DeleteConfirmed metódust.
Az azonos névvel és aláírással rendelkező metódusok egy másik gyakori feladata, hogy mesterségesen módosítsa a POST metódus aláírását úgy, hogy egy extra (nem használt) paramétert tartalmazzon. Ezt tettük egy korábbi bejegyzésben, amikor hozzáadtuk a notUsed paramétert. Ugyanezt megteheti itt a [HttpPost] Delete metódus esetében is:
// POST: Movies/Delete/6
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)
Közzététel az Azure-ban
Az Azure-ban való üzembe helyezésről további információt a oktatóanyagban talál: ASP.NET Core- és SQL Database-alkalmazás létrehozása az Azure App Service.
Nyissa meg a Filmvezérlőt, és vizsgálja meg a Details metódust:
// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
A műveletmetódust létrehozó MVC-állványmotor megjegyzést ad hozzá, amely egy HTTP-kérést jelenít meg, amely meghívja a metódust. Ebben az esetben ez egy GET kérés három URL-szegmenssel, a Movies vezérlővel, a Details metódussal és egy id értékkel. Ezeket a szegmenseket a Program.cshatározza meg.
app.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
Az EF megkönnyíti az adatok keresését a FirstOrDefaultAsync metódus használatával. A metódusba beépített fontos biztonsági funkció, hogy a kód ellenőrzi, hogy a keresési módszer talált-e filmet, mielőtt bármit megpróbálna vele csinálni. Egy hacker például hibákat okozhat a webhelyen, ha a hivatkozások által létrehozott URL-címet a http://localhost:{PORT}/Movies/Details/1-ről a http://localhost:{PORT}/Movies/Details/12345-ra (vagy más olyan értékre módosítja, amely nem jelent tényleges filmet). Ha nem ellenőrizte a null filmet, az alkalmazás kivételt eredményezne.
Vizsgálja meg a Delete és DeleteConfirmed metódusokat.
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.FindAsync(id);
_context.Movie.Remove(movie);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
Vegye figyelembe, hogy a HTTP GET Delete metódus nem törli a megadott filmet, hanem visszaadja annak a filmnek a nézetét, ahol elküldheti (HttpPost) a törlést. Ha a GET-kérésre válaszul törlési műveletet hajt végre (vagy ami azt illeti, szerkesztési művelet végrehajtása, létrehozási művelet vagy bármely más, az adatokat módosító művelet) biztonsági rést nyit meg.
Az adatokat törlő [HttpPost] metódus neve DeleteConfirmed, hogy a HTTP POST metódus egyedi aláírást vagy nevet adjon. A két metódusaláírás az alábbiakban láthatók:
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
A közös nyelvi futtatókörnyezet (CLR) megköveteli, hogy a túlterhelt metódusok egyedi paraméter-aláírással rendelkezzenek (ugyanazzal a metódusnévvel, de a paraméterek különböző listájával). Itt azonban két Delete metódusra van szükség – egyet a GET-hez, egyet a POST-hoz –, amelyek mindegyike ugyanazzal a paraméter-aláírászal rendelkezik. (Mindkettőnek egyetlen egész számot kell elfogadnia paraméterként.)
Ennek a problémának két megközelítése van, az egyik az, hogy különböző neveket ad a metódusoknak. Ezt tette az állványzati mechanizmus az előző példában. Ez azonban egy kis problémát jelent: ASP.NET egy URL-cím szegmenseit név alapján leképezi a műveletmetódusokra, és ha átnevez egy metódust, az útválasztás általában nem találja ezt a metódust. A megoldás az, amit a példában lát, vagyis a ActionName("Delete") attribútum hozzáadása a DeleteConfirmed metódushoz. Ez az attribútum az útválasztási rendszer számára végzi a leképezést, így egy /Delete/ URL-t tartalmazó POST-kérelem megtalálja a DeleteConfirmed metódust.
Az azonos névvel és aláírással rendelkező metódusok egy másik gyakori feladata, hogy mesterségesen módosítsa a POST metódus aláírását úgy, hogy egy extra (nem használt) paramétert tartalmazzon. Ezt tettük egy korábbi bejegyzésben, amikor hozzáadtuk a notUsed paramétert. Ugyanezt megteheti itt a [HttpPost] Delete metódus esetében is:
// POST: Movies/Delete/6
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)
Közzététel az Azure-ban
Az Azure-ban való üzembe helyezésről további információt a oktatóanyagban talál: ASP.NET Core- és SQL Database-alkalmazás létrehozása az Azure App Service.
Nyissa meg a Filmvezérlőt, és vizsgálja meg a Details metódust:
// GET: Movies/Details/5
public async Task<IActionResult> Details(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
A műveletmetódust létrehozó MVC-állványmotor megjegyzést ad hozzá, amely egy HTTP-kérést jelenít meg, amely meghívja a metódust. Ebben az esetben ez egy GET kérés három URL-szegmenssel, a Movies vezérlővel, a Details metódussal és egy id értékkel. Ezeket a szegmenseket a Startup.cshatározza meg.
app.UseEndpoints(endpoints =>
{
endpoints.MapControllerRoute(
name: "default",
pattern: "{controller=Home}/{action=Index}/{id?}");
});
Az EF megkönnyíti az adatok keresését a FirstOrDefaultAsync metódus használatával. A metódusba beépített fontos biztonsági funkció, hogy a kód ellenőrzi, hogy a keresési módszer talált-e filmet, mielőtt bármit megpróbálna vele csinálni. Egy hacker például hibákat okozhat a webhelyen, ha a hivatkozások által létrehozott URL-címet a http://localhost:{PORT}/Movies/Details/1-ről a http://localhost:{PORT}/Movies/Details/12345-ra (vagy más olyan értékre módosítja, amely nem jelent tényleges filmet). Ha nem ellenőrizte a null filmet, az alkalmazás kivételt eredményezne.
Vizsgálja meg a Delete és DeleteConfirmed metódusokat.
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
if (id == null)
{
return NotFound();
}
var movie = await _context.Movie
.FirstOrDefaultAsync(m => m.Id == id);
if (movie == null)
{
return NotFound();
}
return View(movie);
}
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
var movie = await _context.Movie.FindAsync(id);
_context.Movie.Remove(movie);
await _context.SaveChangesAsync();
return RedirectToAction(nameof(Index));
}
Vegye figyelembe, hogy a HTTP GET Delete metódus nem törli a megadott filmet, hanem visszaadja annak a filmnek a nézetét, ahol elküldheti (HttpPost) a törlést. Ha a GET-kérésre válaszul törlési műveletet hajt végre (vagy ami azt illeti, szerkesztési művelet végrehajtása, létrehozási művelet vagy bármely más, az adatokat módosító művelet) biztonsági rést nyit meg.
Az adatokat törlő [HttpPost] metódus neve DeleteConfirmed, hogy a HTTP POST metódus egyedi aláírást vagy nevet adjon. A két metódusaláírás az alábbiakban láthatók:
// GET: Movies/Delete/5
public async Task<IActionResult> Delete(int? id)
{
// POST: Movies/Delete/5
[HttpPost, ActionName("Delete")]
[ValidateAntiForgeryToken]
public async Task<IActionResult> DeleteConfirmed(int id)
{
A közös nyelvi futtatókörnyezet (CLR) megköveteli, hogy a túlterhelt metódusok egyedi paraméter-aláírással rendelkezzenek (ugyanazzal a metódusnévvel, de a paraméterek különböző listájával). Itt azonban két Delete metódusra van szükség – egyet a GET-hez, egyet a POST-hoz –, amelyek mindegyike ugyanazzal a paraméter-aláírászal rendelkezik. (Mindkettőnek egyetlen egész számot kell elfogadnia paraméterként.)
Ennek a problémának két megközelítése van, az egyik az, hogy különböző neveket ad a metódusoknak. Ezt tette az állványzati mechanizmus az előző példában. Ez azonban egy kis problémát jelent: ASP.NET egy URL-cím szegmenseit név alapján leképezi a műveletmetódusokra, és ha átnevez egy metódust, az útválasztás általában nem találja ezt a metódust. A megoldás az, amit a példában lát, vagyis a ActionName("Delete") attribútum hozzáadása a DeleteConfirmed metódushoz. Ez az attribútum az útválasztási rendszer számára végzi a leképezést, így egy /Delete/ URL-t tartalmazó POST-kérelem megtalálja a DeleteConfirmed metódust.
Az azonos névvel és aláírással rendelkező metódusok egy másik gyakori feladata, hogy mesterségesen módosítsa a POST metódus aláírását úgy, hogy egy extra (nem használt) paramétert tartalmazzon. Ezt tettük egy korábbi bejegyzésben, amikor hozzáadtuk a notUsed paramétert. Ugyanezt megteheti itt a [HttpPost] Delete metódus esetében is:
// POST: Movies/Delete/6
[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> Delete(int id, bool notUsed)
Közzététel az Azure-ban
Az Azure-ban való üzembe helyezésről további információt a oktatóanyagban talál: ASP.NET Core- és SQL Database-alkalmazás létrehozása az Azure App Service.