Asp.Net Web Api Using Modelstate For Validation Complete Guide

Step 1: Create an ASP.NET Web API Project

Let's start by creating a new ASP.NET Web API project. You can achieve this using Visual Studio which has built-in templates for different types of APIs.

1. Open Visual Studio.
2. Click "Create a New Project".
3. Choose "ASP.NET Core Web API" template (Ensure you select the appropriate .NET version if prompted).
4. Name your project (e.g., WebApiValidationExample) and click "Create".
5. Follow the setup wizard, leaving the defaults unless you have specific requirements.

Step 2: Define a Model

Define a model class that will be used in your Web API. For demonstration purposes, we'll use a simple Product model.

Create a folder named Models in your root project directory if it doesn't already exist:

namespace WebApiValidationExample.Models
{
    public class Product
    {
        public int Id { get; set; }

        [Required(ErrorMessage = "Name is required.")]
        [StringLength(50, MinimumLength = 3, ErrorMessage = "Name must be between 3 and 50 characters.")]
        public string Name { get; set; } = default!;

        [Range(1, 1000, ErrorMessage = "Price must be between 1 and 1000.")]
        public decimal Price { get; set; }
    }
}

In the above snippet:

• The [Required] attribute ensures that the Name property is not null or empty.
• The [StringLength] attribute validates that the Name property has a length within the specified range.
• The [Range] attribute enforces a numeric value to fall between the defined minimum and maximum values.

Step 3: Add a Controller

Next, add a controller that handles HTTP requests related to the Product model.

1. Right-click on the "Controllers" folder.
2. Select "Add" → "Controller".
3. Choose "API Controller - Empty" and name it ProductsController.

Here’s an example of what the ProductsController might look like with ModelState validation:

using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using WebApiValidationExample.Models;
using System.Linq;

namespace WebApiValidationExample.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class ProductsController : ControllerBase
    {
        private static readonly List<Product> products = new()
        {
            new Product { Id = 1, Name = "Coffee", Price = 10 },
            new Product { Id = 2, Name = "Tea", Price = 5 }
        };

        // GET api/products
        [HttpGet]
        public ActionResult<IEnumerable<Product>> Get()
        {
            return Ok(products);
        }

        // GET api/products/5
        [HttpGet("{id}")]
        public ActionResult<Product> Get(int id)
        {
            var product = products.FirstOrDefault(p => p.Id == id);
            if (product == null)
                return NotFound();

            return Ok(product);
        }

        // POST api/products
        [HttpPost]
        public ActionResult<Product> Post([FromBody] Product product)
        {
            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            product.Id = products.Max(p => p.Id) + 1;
            products.Add(product);

            return CreatedAtAction(nameof(Get), new { id = product.Id }, product);
        }

        // PUT api/products/5
        [HttpPut("{id}")]
        public ActionResult<Product> Put(int id, [FromBody] Product product)
        {
            if (id != product.Id)
                return BadRequest("ID mismatch");

            if (!ModelState.IsValid)
                return BadRequest(ModelState);

            var index = products.FindIndex(p => p.Id == id);
            if (index < 0)
                return NotFound();

            products[index] = product;

            return NoContent();
        }

        // DELETE api/products/5
        [HttpDelete("{id}")]
        public IActionResult Delete(int id)
        {
            var product = products.FirstOrDefault(p => p.Id == id);
            if (product == null)
                return NotFound();

            products.Remove(product);

            return NoContent();
        }
    }
}

Explanation:

[ApiController]

This attribute on the controller enables features such as automatic model validation. If the model validation fails (i.e., ModelState.IsValid is false), ASP.NET Core automatically returns a 400 Bad Request response.

[Route("api/[controller]")]

This makes your endpoints accessible via api/products.

[HttpPost]

The Post method is used to create a new product.

• ModelState.IsValid checks if the model passed all data annotations validation rules.
• If invalid, it returns a BadRequest response along with validation errors from ModelState.

[HttpPut]

The Put method updates an existing product by its ID.

• It first checks if the provided ID matches the product ID in the request body.
• Then it verifies the model's validity using ModelState.IsValid.
• If these conditions are met, it finds and updates the product in the list.

[HttpDelete]

The Delete method removes an existing product by its ID.

• It checks if a product with that ID exists before attempting to delete it.

Step 4: Test Your API

Now that you've set up the API and validation, it's time to test it.

Using Postman or another tool

You can test your API using tools like Postman.

Creating a Product (POST)

Send a POST request to http://localhost:<port>/api/products/ with a JSON payload:

Valid Payload:

{
    "name": "Milk",
    "price": 3
}

Invalid Payload (missing name):

{
    "price": 3
}

Expected Response (invalid payload):

{
    "type": "https://tools.ietf.org/html/rfc7231#section-6.5.1",
    "title": "One or more validation errors occurred.",
    "status": 400,
    "traceId": "|<trace-id>",
    "errors": {
        "Name": [
            "Name is required."
        ]
    }
}

Fetching All Products (GET)

Send a GET request to http://localhost:<port>/api/products/ to fetch all products.

Expected Response:

[
    {
        "id": 1,
        "name": "Coffee",
        "price": 10
    },
    {
        "id": 2,
        "name": "Tea",
        "price": 5
    },
    {
        "id": 3,
        "name": "Milk",
        "price": 3
    }
]

Fetching a Product by ID (GET)

Send a GET request to http://localhost:<port>/api/products/<id> with a valid product ID.

Expected Response:

{
    "id": 1,
    "name": "Coffee",
    "price": 10
}

Updating a Product (PUT)

Send a PUT request to http://localhost:<port>/api/products/<id> with an updated product data.

Valid Payload:

{
    "id": 1,
    "name": "Espresso Coffee",
    "price": 15
}

Expected Response:

204 No Content

Deleting a Product (DELETE)

Send a DELETE request to http://localhost:<port>/api/products/<id> to remove a product.

Expected Response:

204 No Content

Manually in Browser or Console (if applicable)

While GET requests are easily tested from a browser or console, POST, PUT, and DELETE requests usually require tools like Postman or Insomnia for easy manipulation of the HTTP request bodies.

Step 5: Run the Application

1. Press F5 or click the "Run" button in Visual Studio to start debugging the application.
2. Ensure that IIS Express or Kestrel is running and note the local URL (usually something like https://localhost:44326 or http://localhost:5000).

Conclusion

Using ModelState in ASP.NET Web API allows you to leverage server-side data annotation validations for ensuring that the incoming data meets your required criteria before processing. This not only helps maintain data integrity but also provides informative error messages back to the client about what went wrong.