Now that we have our entity relationships defined,

we can turn our attention to making some much needed database refinements.

Let's start by taking a look at how we can refine our model

by using data annotation attributes on our entity class properties.

The Artists Name database table column has a data type NVARCHAR (MAX) and

currently allows nulls.

To review, the NVARCHAR data type is a variable length Unicode string.

The MAX part within the parentheses indicates that the column can contain

a string as large as the maximum allowed size,

which is 2 gigabytes or approximately a billion characters.

We can use data annotation attributes to influence how EF will generate the Artists

database table.

As we discussed in an earlier video, EF is using the .NET data types nullability to

determine if the database column should allow nulls.

The .NET string data type is nullable.

So EF will by default make all string-based database columns nullable.

To let EF know that the name property should not allow nulls,

we can decorate it with the required data annotation attribute.

Be sure to add the using directive for

the System.ComponentModel.DataAnnotations namespace.

We can also let EF know what the maximum allowable number of characters

should be for this property by adding the StringLength attribute.

The StringLength attribute accepts some maximum length parameter, which I'll set

to 100, which seems like a reasonable maximum length for this property.

It's worth noting that we can also use the MaxLength

attribute to specify the maximum length.

Unfortunately, the MaxLength attribute doesn't work with ASP.NET MVC validation,

whereas the StringLength attribute does.

So while either would work fine for our console app, I prefer to use StringLength.

Which will make our code more easily ported to an MVC app later on, if or

when we choose to do that.

Let's add the same attributes to the Role entity class' Name property.

And the Series entity class' Title property.

Before we test our changes,

let's look at a few of the other data annotation attributes that we can use.

We already saw how we can change the foreign key property name

by using the foreign key attribute.

In a similar vein, we can customize the name of the database table

by using the Table attribute, Table,

And how about Talent, for our new database table name?

The attribute is in a different namespace.

So we'll need to add a using directive for

the System.ComponentModel.DataAnnotations.Sc-

hema namespace.

We can also customize the name of a column using the Column attribute, Column,

And let's change the name of the column to FullName.

The Table and Column attributes aren't typically used when you're

using EF to generate your database.

But they're useful when working with an existing database, and you want to use

entity class or property names that are different from their associated table or

column names, We can also use the NotMapped

attribute to tell EF to ignore any settable properties on our entity class.

I'll add a string property named Test,

And decorate it with the NotMapped attribute.

EF will automatically ignore any properties that don't have a setter.

So it's redundant to decorate read-only properties with the NotMapped attribute.

Now let's test our model changes.

Our console output still looks like we expect it to.

Let's review the generated database.

If you have the Tables folder open, be sure to refresh it.

Notice that we now have a Talent table instead of an Artists table.

And it contains a FullName column instead of a Name column.

Also the column's data type is now nvarchar(100) instead of nvarchar(MAX).

And the column no longer allows nulls.

And the Series, Title, and Roles Name columns have been updated as well.

And our test property that we added to our Artist entity class was ignored by EF.

Now that we've seen how the Table, Column, and

NotMapped attributes work, let's remove them from our Artist entity class.

We can also remove the using directive for

the System.ComponentModel.DataAnnotations.Sc-

hema namespace, and our test property.