Help me een C#-oplossing implementeren die gebruikmaakt van data-annotaties voor modelvalidatie.
description
Door data-annotaties te implementeren, kan ik de gegevensintegriteit waarborgen en runtime-fouten verminderen, waardoor mijn toepassing robuuster en gebruiksvriendelijker wordt.
prompt
try_prompt
Help me bij het maken van een C#-toepassing waarin ik data-annotaties kan toepassen voor het effectief valideren van modellen. Ik wil ervoor zorgen dat mijn gegevens voldoen aan specifieke criteria en beperkingen voordat ... more
generate_helper
...
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hieronder vind je een voorbeeld van hoe je een C#-model kunt maken met datavalidatie-annotaties, inclusief de regels dat de naam verplicht is en een maximale lengte van 50 heeft. Daarnaast laat ik zien hoe je deze validatie kunt afdwingen tijdens modelbinding in bijvoorbeeld ASP.NET Core.
### Stap 1: Definieer het model met data-annotaties
```csharp
using System.ComponentModel.DataAnnotations;
public class Persoon
{
[Required(ErrorMessage = "Naam is verplicht.")]
[MaxLength(50, ErrorMessage = "Naam mag niet langer zijn dan 50 tekens.")]
public string Naam { get; set; }
}
```
### Stap 2: Gebruik het model in een controller (bijvoorbeeld in ASP.NET Core)
```csharp
using Microsoft.AspNetCore.Mvc;
public class PersoonController : Controller
{
[HttpPost]
public IActionResult VoegPersoonToe([FromBody] Persoon persoon)
{
if (!ModelState.IsValid)
{
// Valideringsfouten terugsturen
return BadRequest(ModelState);
}
// Verwerk de geldige gegevens
return Ok("Persoon succesvol toegevoegd");
}
}
```
### Stap 3: Validatie afdwingen tijdens modelbinding
ASP.NET Core voert automatisch de validatie uit op basis van de data-annotaties wanneer je `[ApiController]` gebruikt of wanneer je `ModelState.IsValid` controleert. Als de validatie mislukt, krijg je een `BadRequest` met details over de fouten.
### Samenvatting
- Gebruik `[Required]` om een veld verplicht te maken.
- Gebruik `[MaxLength(50)]` om een maximale lengte te specificeren.
- Tijdens modelbinding worden deze regels automatisch gecontroleerd, en kun je dit afhandelen met `ModelState.IsValid`.
Mocht je nog meer validatieregels willen toevoegen of verdere hulp nodig hebben, laat het gerust weten!
provider: deepseek
model: deepseek-chat
Hier is een complete uitleg voor het maken van een C#-toepassing met data-annotaties voor modelvalidatie:
### 1. Installeer vereiste NuGet package
```bash
Install-Package System.ComponentModel.Annotations
```
### 2. Maak een model met data-annotaties
```csharp
using System.ComponentModel.DataAnnotations;
public class Gebruiker
{
[Required(ErrorMessage = "Naam is verplicht")]
[StringLength(50, ErrorMessage = "Naam mag maximaal 50 karakters bevatten")]
public string Naam { get; set; }
// Optioneel: extra eigenschappen
[EmailAddress(ErrorMessage = "Ongeldig e-mailadres")]
public string Email { get; set; }
[Range(18, 99, ErrorMessage = "Leeftijd moet tussen 18 en 99 zijn")]
public int Leeftijd { get; set; }
}
```
### 3. Valideer het model in je controller (ASP.NET Core voorbeeld)
```csharp
using Microsoft.AspNetCore.Mvc;
using System.ComponentModel.DataAnnotations;
[ApiController]
[Route("api/[controller]")]
public class GebruikerController : ControllerBase
{
[HttpPost]
public IActionResult MaakGebruiker([FromBody] Gebruiker gebruiker)
{
// Handmatige validatie
var validationContext = new ValidationContext(gebruiker);
var validationResults = new List<ValidationResult>();
bool isValid = Validator.TryValidateObject(gebruiker, validationContext, validationResults, true);
if (!isValid)
{
// Retourneer foutmeldingen
var errors = validationResults.Select(vr => vr.ErrorMessage);
return BadRequest(new { Errors = errors });
}
// Verwerk geldige data
// ... je logica hier
return Ok(new { Message = "Gebruiker succesvol aangemaakt" });
}
}
```
### 4. Automatische validatie in ASP.NET Core
Voeg dit toe aan je `Program.cs` of `Startup.cs`:
```csharp
builder.Services.AddControllers()
.ConfigureApiBehaviorOptions(options =>
{
options.SuppressModelStateInvalidFilter = false;
});
```
De controller wordt dan eenvoudiger:
```csharp
[HttpPost]
public IActionResult MaakGebruiker([FromBody] Gebruiker gebruiker)
{
// ModelState wordt automatisch gevalideerd door ASP.NET Core
if (!ModelState.IsValid)
{
return BadRequest(ModelState);
}
// Verwerk geldige data
return Ok(new { Message = "Gebruiker succesvol aangemaakt" });
}
```
### 5. Test met Postman of curl
**Request:**
```json
{
"naam": "",
"email": "ongeldig-email",
"leeftijd": 15
}
```
**Response:**
```json
{
"errors": {
"Naam": ["Naam is verplicht"],
"Email": ["Ongeldig e-mailadres"],
"Leeftijd": ["Leeftijd moet tussen 18 en 99 zijn"]
}
}
```
### 6. Andere nuttige data-annotaties:
```csharp
public class Product
{
[Required]
public string Naam { get; set; }
[RegularExpression(@"^[A-Z]{2}\d{4}$", ErrorMessage = "Code moet formaat AA1234 hebben")]
public string ProductCode { get; set; }
[Url(ErrorMessage = "Ongeldige URL")]
public string Website { get; set; }
[Phone(ErrorMessage = "Ongeldig telefoonnummer")]
public string Telefoon { get; set; }
[CreditCard(ErrorMessage = "Ongeldig creditcardnummer")]
public string CreditCard { get; set; }
}
```
### Belangrijkste punten:
- Data-annotaties werken zowel in ASP.NET Core als in andere C#-toepassingen
- Validatie wordt automatisch uitgevoerd tijdens modelbinding
- Je kunt custom error messages toevoegen voor betere gebruikerservaring
- Gebruik `ModelState.IsValid` om te controleren of alle validatieregels zijn voldaan
Deze aanpak zorgt ervoor dat je gegevens altijd voldoen aan de gestelde criteria voordat ze worden verwerkt!

