Kurs:Asp Net Core Model Binding
Zur Navigation springen
Zur Suche springen
Query String
using Microsoft.AspNetCore.Mvc;
namespace start.{{c1::Controllers;}}
// Diese Klasse definiert einen Controller für die ASP.NET Core MVC-Anwendung.
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Diese Methode wird aufgerufen, wenn die Route "/start" aufgerufen wird.
// Der optionale Parameter "name" kann über die URL als Query-Parameter übergeben werden (z. B. /start?name=Thorsten).
{{c1::[Route("start")]}}
{{c1::public IActionResult Index(string? name)}}
{
// Überprüft, ob der Parameter "name" nicht null ist.
{{c1::if (name!=null){}}
// Gibt den Wert von "name" als Antwort zurück.
{{c1::return Content($"{name}");}}
{{c1::} }}
// Gibt den Standardinhalt keine Inhalt zurück, wenn "name" null ist.
{{c1::return Content("Keine Inhalt");}}
{{c1::} }}
{{c1::} }}
Route Data
using Microsoft.AspNetCore.Mvc;
// Der HomeController erbt von der Basisklasse "Controller", die grundlegende Funktionen für MVC-Controller bereitstellt.
namespace start.{{c1::Controllers;}}
{{c1::public class HomeController : Controller}}
{
// Die Route-Attributdeklaration definiert eine URL-Route für die Methode "Index".
// Beispiel: Ein Aufruf von "http://localhost/start/100" würde diese Methode aufrufen,
// wobei "100" als Parameter "id" übergeben wird.
{{c1::[Route("/start/{id:int}")] }} // Die Route akzeptiert nur Ganzzahlen (int) als Parameter.
{{c1::public IActionResult Index(int? id){}}
// Gibt den Wert des Parameters "id" als Textinhalt zurück.
// Wenn "id" null ist, wird "null" als String zurückgegeben.
{{c1::return Content($"{id}");}}
{{c1::} }}
{{c1::} }}
Die HomeController-Klasse erbt von der Controller-Basis-Klasse
using Microsoft.AspNetCore.Mvc; // Importiert den Namespace für ASP.NET Core MVC-Funktionen
namespace start.{{c1::Controllers;}} // Definiert den Namespace der Anwendung
// Die HomeController-Klasse erbt von der Controller-Basis-Klasse
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Die Route "/start" wird für diese Methode definiert
// Beispiel: http://localhost/start?id=100 als Ganzahl
{{c1::[Route("/start")]}}
{{c1::public IActionResult Index([FromQuery] int? id){}} // Nimmt eine optionale Abfrageparameter "id" aus der URL entgegen Ganzahl
{{c1::return Content($"{id}");}} // Gibt den Wert von "id" als Textinhalt zurück
{{c1::} }}
{{c1::} }}
Der HomeController stellt einen Endpunkt zur Verfügung, der eine ID aus der URL entgegennimmt
using Microsoft.AspNetCore.Mvc;
namespace start.{{c1::Controllers;}}
// Der HomeController stellt einen Endpunkt zur Verfügung, der eine ID aus der URL entgegennimmt
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Diese Methode reagiert auf Aufrufe wie /start/123 und gibt die ID als Text zurück(Ganz Zahl)
{{c1::[Route("/start/{id}")]}}
{{c1::public IActionResult Index ([FromRoute] int id)}}
{{c1::{}}
// Gibt die übergebene ID als Inhalt der HTTP-Antwort zurück
{{c1::return Content($"{id}");}}
{{c1::} }}
{{c1::} }}
Person.css
using Microsoft.AspNetCore.Mvc;
namespace start.{{c1::Models;}}
// Diese Klasse repräsentiert eine Person.
{{c1::public class Person}}
{
// Holt den Wert für die Eigenschaft Id aus den Query-Parametern der HTTP-Anfrage.
{{c1::[FromQuery]}}
// Die eindeutige ID der Person (Ganzzahl).
{{c1::public int? Id {get;set;}}}
// Der Vorname der Person.
{{c1::public string? Vorname {get;set;}}}
// Gibt eine Zeichenkette zurück, die die Person anhand von Id und Vorname beschreibt.
{{c1::public override string ToString()}}
{{c1::{}}
{{c1::return}} $"{Id}={Vorname}";
{{c1::} }}
{{c1::} }}
HomeController
using Microsoft.AspNetCore.Mvc;
using start.Models;
namespace start.{{c1::Controllers;}}
// Dies ist der Controller für die Startseite.
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Diese Methode wird aufgerufen, wenn die Route "/start?id=1&Vorname=Thorsten aufgerufen wird.
// Sie nimmt ein Person-Objekt entgegen und gibt dessen Inhalt als Text zurück.
{{c1::[Route("/start")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
{{c1::return Content($"{person}");}}
{{c1::} }}
{{c1::} }}
Person.cs
using System.ComponentModel.DataAnnotations;
namespace start.{{c1::Models;}}
// Die Klasse `Person` repräsentiert eine Person mit grundlegenden Eigenschaften wie Vorname, Nachname und Telefonnummer.
{{c1::public class Person}}
{
// Die Eigenschaft `Vorname` ist erforderlich und darf nicht leer sein.
{{c1::[Required]}}
{{c1::public string? Vorname {get;set;} }}
// Die Eigenschaft `Nachname` ist optional, kann aber bei Bedarf ebenfalls als erforderlich markiert werden.
{{c1::public string? Nachname {get;set;} }}
// Die Eigenschaft `Telefonnummer` ist optional. Es gibt keine Validierung für das Format der Telefonnummer.
{{c1::public string? Telefonnummer {get;set;} }}
// Überschreibt die `ToString`-Methode, um die Eigenschaften der Klasse als lesbaren String zurückzugeben.
{{c1::public override string ToString()}}
{{c1::{}}
{{c1::return}} $"Vorname {Vorname} , Nachname: {Nachname}: Telefonummer: {Telefonnummer} ";
{{c1::} }}
{{c1::} }}
HomeController
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Der `HomeController` verwaltet die Routen und Aktionen für die Startseite der Anwendung.
{{c1::public class HomeController : Controller}}
{
// Die Methode `Index` wird aufgerufen, wenn die Route "/Register" aufgerufen wird.
// Sie erwartet ein `Person`-Objekt als Parameter, das automatisch durch Model Binding gefüllt wird.
// Die Methode gibt die Eigenschaften des `Person`-Objekts als Textinhalt zurück.
{{c1::[Route("Register")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
// Gibt die `ToString`-Darstellung des `Person`-Objekts als HTTP-Antwort zurück.
{{c1::return Content($"{person}");}}
{{c1::} }}
{{c1::} }}
Der HomeController verarbeitet Anfragen an die Route "Register".
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Der HomeController verarbeitet Anfragen an die Route "Register".
// Die Methode Index nimmt ein Person-Objekt entgegen und prüft,
// ob das Model gültig ist. Bei ungültigem Model sollte eine Fehlerbehandlung erfolgen.
{{c1::public class HomeController : Controller}}
{
{{c1::[Route("Register")]}}
{{public IActionResult Index(Person person)}}
{
// Überprüft, ob das Model gültig ist
{{c1::if (!ModelState.IsValid)}}
{
// Hier sollte die Fehlerbehandlung implementiert werden
}
// Weitere Verarbeitung, falls das Model gültig ist
}
}
Dies ist der HomeController, der von der ASP.NET Core Controller-Basis-Klasse erbt
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Dies ist der HomeController, der von der ASP.NET Core Controller-Basis-Klasse erbt.
{{c1::public class HomeController : Controller}}
{
// Diese Methode wird aufgerufen, wenn die Route "/Register" aufgerufen wird.
// Sie erwartet ein Person-Objekt als Parameter.
{{c1::[Route("Register")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
// Überprüft, ob das übergebene Modell gültig ist.
{{c1::if (!ModelState.IsValid)}}
{{c1::{}}
// Falls das Modell ungültig ist, werden alle Fehlermeldungen aus dem ModelState gesammelt.
{{c1::var errors=ModelState.Values}}
{{c1::.SelectMany(v => v.Errors)}}
{{c1::.Select(e => e.ErrorMessage)}}
{{c1::.ToList();}}
// Gibt die Fehlermeldungen als Text zurück, getrennt durch Semikolons.
{{c1::return Content(string.Join("; ", errors));}}
{{c1::} }}
// Falls das Modell gültig ist, wird "Richtig" als Text zurückgegeben.
{{c1::return Content("Richtig");}}
{{c1::} }}
{{c1::} }}
Person.cs
using System;
using System.ComponentModel.DataAnnotations;
namespace start.{{c1::Models;}}
/// Die Klasse Person repräsentiert eine Person mit Vor- und Nachnamen
{{c1::public class Person}}
{
/// Gibt den Vornamen der Person zurück oder legt ihn fest.
/// Das Attribut stellt sicher, dass dieses Feld nicht leer bleibt.
{{c1::[Required]}}
{{c1::public string? Vorname {{c1::{get;set;} }}
/// Gibt den Nachnamen der Person zurück oder legt ihn fest.
/// Das Attribut stellt sicher, dass dieses Feld nicht leer bleibt.
{{c1::[Required]}}
{{c1::public string? Nachname {get;set;} }}
{{c1::} }}
HomeController
using Microsoft.AspNetCore.Mvc;
using start.Models;
namespace start.Controllers;
/// Der HomeController behandelt die Startseite der Anwendung.
public class HomeController : Controller
{
/// Diese Methode empfängt ein Person-Objekt und gibt entweder die Namen aus
/// oder bei ungültigem Model die Fehlermeldungen zurück.
/// Url http://localhost?Vorname=ttt&Nachname=rrr
{{c1::[Route("/")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
{{c1::if (!ModelState.IsValid)}}
{{c1::{}}
// Fehler aus dem ModelState extrahieren und als BadRequest zurückgeben
{{c1::var errors=ModelState.Values}}
{{c1::.SelectMany(v=>v.Errors)}}
{{c1::.Select(e=>e.ErrorMessage);}}
{{c1::return BadRequest(errors);}}
{{c1::} }}
// Vor- und Nachname der Person als Text zurückgeben
{{c1::return Content}}($"{person.Vorname} {person.Nachname}");
{{c1::} }}
{{c1::} }}
Person.cs
using System;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
namespace start.{{c1::Models;}}
// Die Klasse "Person" repräsentiert ein Modell für eine Person mit Vor- und Nachnamen.
{{c1::public class Person}}
{
// Die Eigenschaft "Vorname" ist erforderlich und darf nicht null sein.
// Der Anzeigename wird als "Vorname" definiert.
{{c1::[Required(ErrorMessage = "{0} darf nicht leer sein.")]}}
{{c1::[Display(Name = "Vorname")]}}
{{c1::public string? Vorname {get;set;} }}
// Die Eigenschaft "Nachname" ist ebenfalls erforderlich und darf nicht null sein.
// Der Anzeigename wird als "Nachname" definiert.
{{c1::[Required(ErrorMessage = "{0} darf nicht leer sein.")]}}
{{c1::[Display(Name = "Nachname")]}}
{{c1::public string? Nachname {get;set;} }}
{{c1::} }}
HomeController
using System;
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Die HomeController-Klasse erbt von der Controller-Basis-Klasse und stellt Endpunkte für die Anwendung bereit.
{{c1::public class HomeController : Controller}}
{
// Dieser Endpunkt wird über die Route "Register" aufgerufen. Beispiel: https://localhost/Register?Vorname=steffi&Nachname=Timm
{{c1::[Route("Register")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
// Überprüft, ob das übermittelte Modell (Person) gültig ist.
{{c1::if (!ModelState.IsValid)}}
{{c1::{}}
// Falls das Modell ungültig ist, werden alle Validierungsfehler gesammelt.
{{c1::var errors = ModelState.Values}}
{{c1::.SelectMany(e => e.Errors)}}
{{c1::.Select(v => v.ErrorMessage);}}
// Gibt die Fehler als BadRequest-Antwort zurück.
{{v1::return BadRequest(errors);}}
{{c1::} }}
// Falls das Modell gültig ist, wird der Nachname und Vorname der Person zurückgegeben.
{{c1::return}} Json(person);
{{c1::} }}
{{c1::} }}
Person.cs
using System;
using System.ComponentModel.DataAnnotations;
namespace start.{{c1::Models;}}
// Die Klasse Person repräsentiert eine Person mit einer Eigenschaft "Vorname".
{{c1::public class Person}}
{{c1::{}}
// Die Eigenschaft "Vorname" ist erforderlich und unterliegt bestimmten Validierungsregeln.
// Stellt sicher, dass die Eigenschaft "Vorname" nicht leer ist.
// Eine benutzerdefinierte Fehlermeldung wird angezeigt, wenn die Validierung fehlschlägt.
// Satz soll ausgaben '''Das Feld Vorname darf nicht leer sein'''
{{c1::[Required(ErrorMessage="Das Feld {0} darf nicht leer sein.")]}}
// [Display]: Gibt an, wie die Eigenschaft "Vorname" in der Benutzeroberfläche angezeigt wird.
{{c1::[Display(Name="Vorname")]}}
// Legt die maximale und minimale Länge für die Eigenschaft "Vorname" fest.
// Die Länge muss zwischen 5 und 40 Zeichen liegen. Eine Fehlermeldung wird definiert.
// Satz soll ausgaben '''Die Länge von Vornaame muss zwischen 5 und 40 Zeichen liegen
{{c1::[StringLength(40,MinimumLength=5,ErrorMessage="Die Länge von {0} muss zwischen {2} und {1} Zeichen liegen.")]}}
{{c1::public string? Vorname {get;set;} }}
{{c1::} }}
HomeController
using System;
using System.ComponentModel.Design;
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Der HomeController erbt von der Basisklasse Controller, die grundlegende Funktionen für MVC-Controller bereitstellt.
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Die Index-Methode ist mit der Route "/" verknüpft und wird aufgerufen, wenn die Basis-URL der Anwendung aufgerufen wird.
{{c1::[Route("/")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
// Überprüfung, ob das übergebene Modell (Person) gültig ist.
{{c1::if (!ModelState.IsValid)}}
{{c1::{}}
// Wenn das Modell ungültig ist, werden die Fehler aus dem ModelState extrahiert.
{{c1::var errors=ModelState.Values}}
{{c1::.SelectMany(e=>e.Errors)}}
{{c1::.Select(v=>v.ErrorMessage);}}
// Rückgabe eines BadRequest (HTTP 400) mit den Fehlern.
{{c1::return BadRequest(errors);}}
{{c1::} }}
// Wenn das Modell gültig ist, wird es als JSON zurückgegeben.
{{c1::return Json(person);}}
{{c1::} }}
{{c1::} }}
Person
using System.ComponentModel.DataAnnotations;
namespace start.{{c1::Models;}}
// Die Klasse "Person" repräsentiert ein Modell mit einer Eigenschaft "Alter".
{{c1::public class Person}}
{{c1::{}}
// "Alter" darf nicht leer sein. Eine Fehlermeldung wird angezeigt,
// wenn kein Wert angegeben wird.
{{c1::[Required(ErrorMessage = "{0} darf nicht leer sein")]}}
// Der Anzeigename für "Alter" wird auf "Alter" gesetzt, was z. B.
// in Formularen oder Fehlermeldungen verwendet wird.
{{c1::[Display(Name="Alter")]}}
// Der Wert von "Alter" muss zwischen 10 und 20 liegen. Andernfalls wird
// eine Fehlermeldung mit den entsprechenden Grenzwerten angezeigt.
// Fehlermeldung: "Alter darf nur mindestens 10 bis 20 sein."
{{c1::[Range(10, 20, ErrorMessage = "{0} darf nur mindestens {1} bis {2} sein")]}}
{{c1::public int? Alter {get;set;} }}
{{c1::} }}
HomeController
using System;
using System.ComponentModel.Design;
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Der HomeController erbt von der Basisklasse Controller, die grundlegende Funktionen für MVC-Controller bereitstellt.
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Die Index-Methode ist mit der Route "/" verknüpft und wird aufgerufen, wenn die Basis-URL der Anwendung aufgerufen wird.
{{c1::[Route("/")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
// Überprüfung, ob das übergebene Modell (Person) gültig ist.
{{c1::if (!ModelState.IsValid)}}
{{c1::{}}
// Wenn das Modell ungültig ist, werden die Fehler aus dem ModelState extrahiert.
{{c1::var errors=ModelState.Values}}
{{c1::.SelectMany(e=>e.Errors)}}
{{c1::.Select(v=>v.ErrorMessage);}}
// Rückgabe eines BadRequest (HTTP 400) mit den Fehlern.
{{c1::return BadRequest(errors);}}
{{c1::} }}
// Wenn das Modell gültig ist, wird es als JSON zurückgegeben.
{{c1::return Json(person);}}
{{c1::} }}
{{c1::} }}
Person.css
using System.ComponentModel.DataAnnotations;
namespace start.Models;
// Die Klasse Person repräsentiert ein Modell mit Validierungsregeln für die Eigenschaften Passwort und RePasswort.
public class Person
{c1::{}}
// Die Eigenschaft Passwort ist erforderlich und muss zwischen 8 und 12 Zeichen lang sein.
// Das Attribut stellt sicher, dass das Feld nicht leer ist.
// Das Attribut definiert den Anzeigenamen für die Eigenschaft.
// Das Attribut legt die minimale und maximale Länge der Zeichenfolge fest.
//Fehler Meldung "Passwort darf nicht leer sein.
{{c1::[Required(ErrorMessage="{0} darf nicht leer sein")}}
{{c1::[Display(Name="Passwort")]}}
//Fehler Meldung "Passwort: Die Länge muss zwischen 12 und 8 Zeichen liegen")]
{{c1::[StringLength(12,MinimumLength=8,ErrorMessage ="{0}: Die Länge muss zwischen {2} und {1} Zeichen liegen")]}}
{{c1::public string? Passwort{get; set;} }}
// Die Eigenschaft RePasswort ist ebenfalls erforderlich und muss die gleichen Längenbeschränkungen wie Passwort erfüllen.
// Zusätzlich wird mit dem Attribut sichergestellt, dass RePasswort mit Passwort übereinstimmt.
//Fehler Meldung ""RePasswort darf nicht leer sein."
{{c1::[Required(ErrorMessage="{0} darf nicht leer sein")]}}
{{c1::[Display(Name="RePasswort")]}}
//Fehler Meldung "RePasswort: Die Länge muss zwischen 12 und 8 Zeichen liegen")]
{{c1::[StringLength(12,MinimumLength=8,ErrorMessage="{0}: Die Länge muss zwischen {2} und {1} Zeichen liegen")]}}
//Fehler Meldung "RePasswort stimmt nicht mit Passwort überein"
{{c1::[Compare("Passwort",ErrorMessage="{0} stimmt nicht mit {1} überein")]}}
{{c1::public string? RePasswort {get;set;} }}
{{c1::} }}
HomeController
using System;
using System.ComponentModel.Design;
using Microsoft.AspNetCore.Mvc;
using start.{{c1::Models;}}
namespace start.{{c1::Controllers;}}
// Der HomeController erbt von der Basisklasse Controller, die grundlegende Funktionen für MVC-Controller bereitstellt.
{{c1::public class HomeController : Controller}}
{{c1::{}}
// Die Index-Methode ist mit der Route "/" verknüpft und wird aufgerufen, wenn die Basis-URL der Anwendung aufgerufen wird.
{{c1::[Route("/")]}}
{{c1::public IActionResult Index(Person person)}}
{{c1::{}}
// Überprüfung, ob das übergebene Modell (Person) gültig ist.
{{c1::if (!ModelState.IsValid)}}
{{c1::{}}
// Wenn das Modell ungültig ist, werden die Fehler aus dem ModelState extrahiert.
{{c1::var errors=ModelState.Values}}
{{c1::.SelectMany(e=>e.Errors)}}
{{c1::.Select(v=>v.ErrorMessage);}}
// Rückgabe eines BadRequest (HTTP 400) mit den Fehlern.
{{c1::return BadRequest(errors);}}
{{c1::} }}
// Wenn das Modell gültig ist, wird es als JSON zurückgegeben.
{{c1::return Json(person);}}
{{c1::} }}
{{c1::} }}
Grundklasse für Start-Validierung
using System;
using System.ComponentModel.DataAnnotations;
namespace start.praxis;
// Grundklasse für Start-Validierung
// Diese Klasse kann erweitert werden, um spezifische Validierungslogik zu implementieren
// Grundsätzlich wird die Validierung in der abgeleiteten Klasse implementiert
{{c1::public class Start : ValidationAttribute}} // Automaazisch ersellt, um Validierung zu ermöglichen
{
{{c1::protected override}} ValidationResult? IsValid(object? value, ValidationContext validationContext)
{
return base.IsValid(value, validationContext);
}
}