Models can be enhanced to add hints for display, data type, minimum length or amount, and similar constraints. We will use model attributes to annotate ASP.NET models and validate forms.

Data Validation

There are more validation patterns that we can apply to the `Country` data model. This will change the display name for headers and `<label>` tags.
```cs
[Display(Name = "Code")]
```
The format of numeric and date data strings can be applied like this:
```cs
[DisplayFormat(DataFormatString = "{0:N0}", ApplyFormatInEditMode = true)]
```
Ranges with minimum and maximum values can be applied to numbers, dates, and strings:
```cs
[Range(1, 10000000000)]
```
Specific data types can be applied to fields:
```cs
[DataType(DataType.Date)]
```
Once the model is annotated, the database must be recreated to allow EF to modify the table schema to match the model design. This ensures that data is validated on the server using `ModelState.IsValid` and again when it is persisted to the database. We will see in the next exercise that validation can also happen in the browser.

Code Country Model Annotations

The server code and the database now validate any data that is saved. The user can’t see this yet. This can be frustrating since records are not saved when the `ModelState.IsValid` is false. The user could get stuck in the edit page and not know why the Save button is failing. To solve this, we need to apply validation controls and client-side JavaScript to the edit page.

Basic validation messages are displayed in a `<span>` tag using the tag helper `asp-validation-for`. This will show a default message if any of the model annotations are violated. If you specified a custom `ErrorMessage` in your annotation, that displays instead. Here is a sample:
```html
<div style="flex:1 0 auto;width:auto">
  <input asp-for="Continent.ID" class="form-control" />
  <span asp-validation-for="Continent.ID" class="text-danger"></span>
</div>
```
Some client-side scripts are needed to handle the validation logic in the browser. These are provided by ASP.NET but must be added to each page that needs them. This is done in a `@section` which matches the `@RenderSection` in the **Pages/Shared/_Layout.cshtml** file.

For example, this `@section` is named `OtherScripts` and it would render some partial named `_UsefulScriptsPartial`:

```cs
@section OtherScripts {
  @{ await Html.RenderPartialAsync("_UsefulScriptsPartial"); }
}
```

This might have a matching section in **_Layout.cshtml** like:

```cs
@RenderSection("OtherScripts", required: false)
```

In the Bootstrap CSS:

* `text-danger` - make the message red


Markup Continent Field Level Validation

The EF diagram now includes additional steps to accommodate data validation:

* Notations are made in the model classes that tailor each field for type, display, length, and regex patterns
* The model hints alter the database schema so the data has proper constraints
* The model hints are also used by the context to determine if any data changes are valid
* The model hints also interact with JavaScript validation scripts that display helpful information on the browser page when data is changed by the user
* The JavaScript validation scripts will restrict a `<form>` POST if the data does not match the model hints
* Once the requested changes are marked as valid, the context method `SaveChangesAsync()` passes the data to the database by way of SQL statements
* The database constraints created by the context via the model hints further restrict inserts, updates, and deletes using SQL referential techniques

EF Diagram

We now have a full working set of CRUD pages. But, there are some problems with our approach. There is no data validation so the user could enter numbers where letters are required. They could enter bad dates or negative population values.

We will enhance our data models with annotations. That will refine the database schema and ensure that the correct data types, string lengths, and character types are stored. This is coupled with some validation tag helpers that display helpful messages to the user if the incorrect data is entered in each field.

Thankfully, Entity Framework provides those enhancements to data models that can make our display and editing more consistent and robust. Model annotations are included in the `System.ComponentModel.DataAnnotations` library. They can be used to force a column to accept certain data patterns or display more efficiently. There are many of these annotations and we will focus on the following.

Field must contain a value:
```cs
[Required]
```
Set minimum and maximum lengths:
```cs
[StringLength]
```
Match input patterns for things like email addresses and zip codes:
```cs
[RegularExpression]
```
Numeric or date limits:
```cs
[Range]
```
Define a data type which determines the database column type:
```cs
[DataType]
```
Change the field label:
```cs
[Display]
```
Change how the value is displayed:
```cs
[DisplayFormat]
```
The annotations are entered in the EF model class above each property field. Some annotations accept additional parameters like `ErrorMessage`.

Once the model is annotated, the database must be recreated to allow EF to modify the table schema to match the model design. This ensures that data is validated on the server using `ModelState.IsValid` and again when it is persisted to the database. We will see in the next exercise that validation can also happen in the browser.

Code Continent Model Annotations

We enhanced our data models with annotations. That refines the database schema and ensures that the correct data types, string lengths, and character types are stored. This is coupled with some validation tag helpers that display helpful messages to the user if the incorrect data is entered in each field.

Model annotations are included in the `System.ComponentModel.DataAnnotations` library. They are used to force a column to accept certain data patterns or display more efficiently. There are many of these annotations and we will focus on the following.

Field must contain a value:
```cs
[Required]
```
Set minimum and maximum lengths:
```cs
[StringLength]
```
Match input patterns for things like email addresses and zip codes:
```cs
[RegularExpression]
```
Numeric or date limits:
```cs
[Range]
```
Define a data type which determines the database column type:
```cs
[DataType]
```
Change the field label:
```cs
[Display]
```
Change how the value is displayed:
```cs
[DisplayFormat]
```
The annotations were entered in the EF model class above each property field. Some annotations accept additional parameters like `ErrorMessage`.

Once the model is annotated, the database was recreated to allow EF to modify the table schema to match the model design. This ensures that data is validated on the server using `ModelState.IsValid` and again when it is persisted to the database.

We applied validation controls and client-side JavaScript to the edit page. Basic validation messages are displayed in a `<span>` tag using the tag helper `asp-validation-for`. This shows a default message if any of the model annotations are violated. If you specified a custom `ErrorMessage` in your annotation, that displays instead.

Some client-side scripts are needed to handle the validation logic in the browser. These are provided by ASP.NET but must be added to each page that needs them. This is done in a `@section` which matches the `@RenderSection` in the **Pages/Shared/_Layout.cshtml** file.