Introduction
Recently, I embarked on an intriguing journey of code analysis for a migration project, transitioning an application from .NET to .NET Core (.NET 8). As I delved into the codebase, I discovered a labyrinth of validation logic embedded within the model classes. A custom validator had been meticulously crafted to handle these validations, but it was clear that this approach had led to a bloated and complex codebase.
As I navigated through the code, a realization dawned upon me: many of these custom validators could be elegantly replaced with .NET’s in-built Data Annotations. This revelation was a game-changer. By leveraging these powerful attributes, we could simplify the validation logic, making it more readable and maintainable.
However, not all validations were straightforward. Some were intricate and required a level of customization that the standard Data Annotations couldn’t provide. This is where Custom Data Annotations came into play. By designing custom attributes tailored to our specific needs, we could handle even the most complex validation scenarios with ease.
The process of redesigning the application was both challenging and rewarding. As we refactored the code, we witnessed a significant reduction in the codebase. The validations became highly configurable, testable, and maintainable. The transformation was remarkable.
To illustrate the impact of this transformation, I have highlighted some of the key Data Annotations that played a pivotal role in our success. Additionally, I have showcased a few of the new annotations introduced in .NET 8 and .NET 9, which further enhanced our validation capabilities.
This journey not only improved the application’s architecture but also reinforced the importance of leveraging modern frameworks and tools to achieve cleaner, more efficient code. It was a testament to the power of .NET Core and the elegance of Data Annotations in creating robust and maintainable applications.
Intro to Data Annotations
Data Annotations in C# are a powerful way to add metadata to your classes and properties, enabling validation, formatting, and database schema generation. In this blog, we’ll explore various Data Annotations, including those newly introduced in .NET 8 and .NET 9, with real-world implementation scenarios and sample code.
Data Annotations are attributes that provide a declarative way to enforce validation rules, format data, and define database schema details. They are commonly used in ASP.NET Core MVC and Entity Framework Core.
Commonly Used Data Annotations
Required
The Required attribute ensures that a property is not null or empty.
Real-World Scenario: In a user registration form, the email field must be filled out to create an account.
Sample Code:
public class User
{
[Required(ErrorMessage = "Email is required.")]
public string Email { get; set; }
}
StringLength
The StringLength attribute specifies the minimum and maximum length of a string property.
Real-World Scenario: A product name should be between 5 and 100 characters long.
Sample Code:
public class Product
{
[StringLength(100, MinimumLength = 5, ErrorMessage = "Product name must be between 5 and 100 characters.")]
public string Name { get; set; }
}
Range
The Range attribute defines the minimum and maximum value for a numeric property.
Real-World Scenario: An employee’s age should be between 18 and 65.
Sample Code:
public class Employee
{
[Range(18, 65, ErrorMessage = "Age must be between 18 and 65.")]
public int Age { get; set; }
}
EmailAddress
The EmailAddress attribute validates that a property contains a valid email address.
Real-World Scenario: Ensuring that the contact email provided by a customer is valid.
Sample Code:
public class Contact
{
[EmailAddress(ErrorMessage = "Invalid email address.")]
public string Email { get; set; }
}
Compare
The Compare attribute compares two properties to ensure they match.
Real-World Scenario: Confirming that the password and confirm password fields match during user registration.
Sample Code:
public class UserRegistration
{
[Required]
public string Password { get; set; }
[Compare("Password", ErrorMessage = "Passwords do not match.")]
public string ConfirmPassword { get; set; }
}RegularExpression
The RegularExpression attribute validates that a property matches a specified regular expression pattern.
Real-World Scenario: Validating that a username contains only alphanumeric characters.
Sample Code:
public class User
{
[RegularExpression(@"^[a-zA-Z0-9]*$", ErrorMessage = "Username can only contain alphanumeric characters.")]
public string Username { get; set; }
}MaxLength
The MaxLength attribute specifies the maximum length of a string or array property.
Real-World Scenario: Limiting the length of a product description to 500 characters.
Sample Code:
public class Product
{
[MaxLength(500, ErrorMessage = "Description cannot exceed 500 characters.")]
public string Description { get; set; }
}MinLength
The MinLength attribute specifies the minimum length of a string or array property.
Real-World Scenario: Ensuring that a password is at least 8 characters long.
Sample Code:
public class User
{
[MinLength(8, ErrorMessage = "Password must be at least 8 characters long.")]
public string Password { get; set; }
}CreditCard
The CreditCard attribute validates that a property contains a valid credit card number.
Real-World Scenario: Validating the credit card number provided during an online purchase.
Sample Code:
public class Payment
{
[CreditCard(ErrorMessage = "Invalid credit card number.")]
public string CardNumber { get; set; }
}Url
The Url attribute validates that a property contains a valid URL.
Real-World Scenario: Ensuring that the website URL provided by a business is valid.
Sample Code:
public class Business
{
[Url(ErrorMessage = "Invalid URL.")]
public string Website { get; set; }
}Phone
The Phone attribute validates that a property contains a valid phone number.
Real-World Scenario: Validating the phone number provided during user registration.
Sample Code:
public class User
{
[Phone(ErrorMessage = "Invalid phone number.")]
public string Phone { get; set; }
}Custom Validation
The CustomValidation attribute allows for custom validation logic.
Real-World Scenario: Validating that a user’s age is at least 18 years old using a custom validation method.
Sample Code:
public class User
{
[CustomValidation(typeof(UserValidator), "ValidateAge")]
public int Age { get; set; }
}
public static class UserValidator
{
public static ValidationResult ValidateAge(int age, ValidationContext context)
{
if (age < 18)
{
return new ValidationResult("User must be at least 18 years old.");
}
return ValidationResult.Success;
}
}New Data Annotations in .NET 8 and .NET 9
PhoneNumber (Introduced in .NET 8)
The PhoneNumber attribute validates that a property contains a valid phone number.
Real-World Scenario: Validating the phone number provided during user registration.
Sample Code:
public class User
{
[PhoneNumber(ErrorMessage = "Invalid phone number.")]
public string Phone { get; set; }
}Url (Introduced in .NET 9)
The Url attribute validates that a property contains a valid URL.
Real-World Scenario: Ensuring that the website URL provided by a business is valid.
Sample Code:
public class Business
{
[Url(ErrorMessage = "Invalid URL.")]
public string Website { get; set; }
}CreditCard (Introduced in .NET 9)
The CreditCard attribute validates that a property contains a valid credit card number.
Real-World Scenario: Validating the credit card number provided during an online purchase.
Sample Code:
public class Payment
{
[CreditCard(ErrorMessage = "Invalid credit card number.")]
public string CardNumber { get; set; }
}Real-World Implementation Scenarios
User Registration Form
In a user registration form, it’s crucial to validate the user’s input to ensure data integrity and security. Using Data Annotations, we can enforce rules such as required fields, valid email addresses, and phone numbers.
Product Management System
In a product management system, we need to ensure that product names and descriptions meet specific length requirements. Data Annotations help us enforce these rules declaratively.
Employee Management System
In an employee management system, we need to validate employee details such as age and email address. Data Annotations provide a simple way to enforce these validation rules.
Sample Code
Here’s a complete example of a user registration form using various Data Annotations:
public class UserRegistration
{
[Required(ErrorMessage = "Username is required.")]
public string Username { get; set; }
[Required(ErrorMessage = "Email is required.")]
[EmailAddress(ErrorMessage = "Invalid email address.")]
public string Email { get; set; }
[Required(ErrorMessage = "Password is required.")]
[StringLength(100, MinimumLength = 6, ErrorMessage = "Password must be at least 6 characters long.")]
public string Password { get; set; }
[Phone(ErrorMessage = "Invalid phone number.")]
public string Phone { get; set; }
}Conclusion
Data Annotations in C# provide a powerful and declarative way to enforce validation rules, format data, and define database schema details. With the introduction of new annotations in .NET 8 and .NET 9, developers have even more tools at their disposal to ensure data integrity and improve user experience.
dotnetjaikum.com 