Model Binding and Validation

🎭 The Magic Post Office: Understanding Model Binding & Validation

Imagine you run a magical post office where letters arrive from all over the world. Your job? Make sure every letter goes to the right person AND contains valid information!

🌟 The Big Picture

In ASP.NET MVC, when someone fills out a form or sends data to your website, that data needs to:

1. Find the right home (Model Binding)
2. Pass inspection (Validation)

Think of it like this: A letter arrives → You read the address → You check if it’s a real address → You deliver it!

📬 What is Model Binding?

The Magical Translation Machine

Model binding is like having a super-smart translator at your post office.

🧒 Kid sends: "name=Tommy&age=10"

🤖 Translator turns it into:
   Person {
     Name = "Tommy",
     Age = 10
   }

Before model binding:

// Old, painful way 😫
string name = Request.Form["name"];
int age = int.Parse(Request.Form["age"]);

With model binding:

// Magic way! 🎉
public IActionResult Save(Person person)
{
    // person.Name = "Tommy"
    // person.Age = 10
    // It just works!
}

How Does the Magic Work?

graph TD
    A["📨 Data Arrives"] --> B["🔍 Find Matching Property"]
    B --> C["🔄 Convert to Right Type"]
    C --> D["📦 Put in Your Model"]
    D --> E["✅ Ready to Use!"]

Real Example:

<!-- Your HTML form -->
<form method="post">
    <input name="FirstName" value="Sara" />
    <input name="Age" value="8" />
    <button>Send!</button>
</form>

// Your C# model
public class Child
{
    public string FirstName { get; set; }
    public int Age { get; set; }
}

// Your controller - Magic happens here!
public IActionResult Register(Child child)
{
    // child.FirstName = "Sara"
    // child.Age = 8
    // No extra code needed!
}

🏷️ Binding Source Attributes

Telling the Post Office WHERE to Look

Sometimes your data comes from different places. Binding source attributes are like labels telling the translator where to find information.

Examples That Make Sense

🔗 FromRoute - Data in the URL path:

// URL: /toys/42
[HttpGet("toys/{id}")]
public IActionResult GetToy([FromRoute] int id)
{
    // id = 42
}

❓ FromQuery - Data after the ? in URL:

// URL: /search?color=red&size=large
public IActionResult Search(
    [FromQuery] string color,
    [FromQuery] string size)
{
    // color = "red"
    // size = "large"
}

📝 FromBody - JSON data sent in request:

// Incoming JSON: {"name":"Teddy","price":25}
[HttpPost]
public IActionResult CreateToy(
    [FromBody] Toy toy)
{
    // toy.Name = "Teddy"
    // toy.Price = 25
}

📋 FromForm - Traditional form data:

[HttpPost]
public IActionResult SubmitForm(
    [FromForm] string email)
{
    // email from form field
}

📮 FromHeader - Hidden info in request:

public IActionResult CheckUser(
    [FromHeader(Name = "X-User-Id")]
    string userId)
{
    // Gets special header value
}

📊 Model State: The Report Card

Is Everything Okay?

After binding happens, ModelState is like a report card that tells you:

• ✅ Did all the data arrive safely?
• ❌ Were there any problems?

public IActionResult Save(Person person)
{
    // Check the report card!
    if (ModelState.IsValid)
    {
        // All good! Save the data
        return Ok("Saved!");
    }
    else
    {
        // Problems found!
        return BadRequest(ModelState);
    }
}

What’s Inside ModelState?

graph TD
    A["ModelState"] --> B["IsValid: true/false"]
    A --> C["Errors Collection"]
    A --> D["Values Dictionary"]
    C --> E["Error Messages"]
    C --> F["Which Field Failed"]

Getting Error Details:

if (!ModelState.IsValid)
{
    foreach (var error in ModelState)
    {
        string fieldName = error.Key;
        var messages = error.Value.Errors;

        foreach (var msg in messages)
        {
            Console.WriteLine(
                quot;{fieldName}: {msg.ErrorMessage}");
        }
    }
}

✅ Model Validation: The Inspector

Making Sure Everything is Correct

Validation is like having an inspector who checks every letter before delivery.

Without validation:

• Age could be -500 😱
• Email could be “banana” 🍌
• Name could be empty “”

With validation:

• Age must be 1-120 ✓
• Email must look like email ✓
• Name is required ✓

🏷️ Data Annotations: Magic Labels

Built-in Validation Rules

Data annotations are special labels you put on your model properties. They’re like rules written on sticky notes!

The Most Useful Annotations

📌 [Required] - Must have a value

public class Student
{
    [Required]
    public string Name { get; set; }
    // Can't be empty or null!
}

📏 [StringLength] - Control text length

[StringLength(50, MinimumLength = 2)]
public string Nickname { get; set; }
// Must be 2-50 characters

🔢 [Range] - Numbers in a range

[Range(1, 100)]
public int Score { get; set; }
// Only 1 through 100 allowed

📧 [EmailAddress] - Valid email format

[EmailAddress]
public string Email { get; set; }
// Must look like name@example.com

🔗 [Url] - Valid web address

[Url]
public string Website { get; set; }
// Must start with http:// or https://

📞 [Phone] - Phone number format

[Phone]
public string PhoneNumber { get; set; }

🔐 [Compare] - Two fields must match

[Required]
public string Password { get; set; }

[Compare("Password")]
public string ConfirmPassword { get; set; }
// Must match Password!

📝 [RegularExpression] - Custom pattern

[RegularExpression(@"^[A-Z]{3}\d{3}quot;)]
public string ProductCode { get; set; }
// Must be like "ABC123"

Complete Example

public class SignupForm
{
    [Required(ErrorMessage = "Tell us your name!")]
    [StringLength(100, MinimumLength = 2)]
    public string FullName { get; set; }

    [Required]
    [EmailAddress(ErrorMessage = "That's not an email!")]
    public string Email { get; set; }

    [Required]
    [Range(5, 120, ErrorMessage = "Age seems wrong!")]
    public int Age { get; set; }

    [Required]
    [StringLength(100, MinimumLength = 8)]
    public string Password { get; set; }

    [Compare("Password",
        ErrorMessage = "Passwords don't match!")]
    public string ConfirmPassword { get; set; }
}

🛠️ Custom Validation Attributes

When Built-in Rules Aren’t Enough

Sometimes you need special rules. Like: “Username can’t be ‘admin’” or “Date must be in the future.”

Creating Your Own Validator

Step 1: Create the attribute class

public class NoBadWordsAttribute
    : ValidationAttribute
{
    private string[] _badWords =
        { "spam", "fake", "test" };

    protected override ValidationResult
        IsValid(object value,
        ValidationContext context)
    {
        if (value == null)
            return ValidationResult.Success;

        string input = value.ToString().ToLower();

        foreach (var word in _badWords)
        {
            if (input.Contains(word))
            {
                return new ValidationResult(
                    quot;'{word}' is not allowed!");
            }
        }

        return ValidationResult.Success;
    }
}

Step 2: Use it on your model

public class Comment
{
    [Required]
    [NoBadWords]
    public string Text { get; set; }
}

Another Example: Future Date Only

public class FutureDateAttribute
    : ValidationAttribute
{
    protected override ValidationResult
        IsValid(object value,
        ValidationContext context)
    {
        if (value is DateTime date)
        {
            if (date <= DateTime.Now)
            {
                return new ValidationResult(
                    "Date must be in the future!");
            }
        }
        return ValidationResult.Success;
    }
}

// Usage
public class Event
{
    [Required]
    public string Title { get; set; }

    [FutureDate]
    public DateTime EventDate { get; set; }
}

Custom Validator with Parameters

public class MinAgeAttribute
    : ValidationAttribute
{
    private int _minAge;

    public MinAgeAttribute(int minAge)
    {
        _minAge = minAge;
    }

    protected override ValidationResult
        IsValid(object value,
        ValidationContext context)
    {
        if (value is DateTime birthDate)
        {
            int age = DateTime.Now.Year
                - birthDate.Year;

            if (age < _minAge)
            {
                return new ValidationResult(
                    quot;Must be at least {_minAge}!");
            }
        }
        return ValidationResult.Success;
    }
}

// Usage
public class User
{
    [MinAge(13)]
    public DateTime BirthDate { get; set; }
}

🎯 Putting It All Together

The Complete Journey

graph TD
    A["🌐 User Submits Form"] --> B["📬 Model Binding"]
    B --> C["🔄 Convert Data Types"]
    C --> D["✅ Run Validations"]
    D --> E{All Valid?}
    E -->|Yes| F["💾 Save Data"]
    E -->|No| G["❌ Return Errors"]
    G --> H["📝 Show Errors to User"]

Real-World Controller

[HttpPost]
public IActionResult CreateUser(
    [FromBody] CreateUserRequest request)
{
    // Step 1: Check ModelState
    if (!ModelState.IsValid)
    {
        return BadRequest(ModelState);
    }

    // Step 2: All validations passed!
    var user = new User
    {
        Name = request.Name,
        Email = request.Email
    };

    _database.Save(user);

    return Ok("User created!");
}

🌈 Quick Summary

💡 Remember This!

1. Model binding happens automatically - just name things correctly!
2. Always check ModelState.IsValid before using data
3. Use data annotations for common validation
4. Create custom attributes for special rules
5. Binding sources tell ASP.NET WHERE to look for data

You’re now ready to handle any data that comes to your magical post office! Every letter will be properly addressed and validated before delivery. 🎉📬