Dane Morgridge

Programmer, Geek, ASPInsider
A blog about code and data access

  Home  |   Contact  |   Syndication    |   Login
  43 Posts | 0 Stories | 67 Comments | 0 Trackbacks

News

INETA Community Speakers Program

Twitter












Archives

Post Categories

Monday, December 20, 2010 #

There are several attributes available when using code first with the Entity Framework 4 CTP5 Code First option.  When working with strings you can use [MaxLength(length)] to control the length and [Required] will work on all properties.  But there are a few things missing. By default all string will be created using unicode so you will get nvarchar instead of varchar.  You can change this using the fluent API or you can create an attribute to make the change.  If you have a lot of properties, the attribute will be much easier and require less code.

You will need to add two classes to your project to create the attribute itself:

   1: public class UnicodeAttribute : Attribute
   2: {
   3:     bool _isUnicode;
   4:  
   5:     public UnicodeAttribute(bool isUnicode)
   6:     {
   7:         _isUnicode = isUnicode;
   8:     }
   9:  
  10:     public bool IsUnicode { get { return _isUnicode; } }
  11: }
  12:  
  13: public class UnicodeAttributeConvention : AttributeConfigurationConvention<PropertyInfo, StringPropertyConfiguration, UnicodeAttribute>
  14: {
  15:     public override void Apply(PropertyInfo memberInfo, StringPropertyConfiguration configuration, UnicodeAttribute attribute)
  16:     {
  17:         configuration.IsUnicode = attribute.IsUnicode;
  18:     }
  19: }

The UnicodeAttribue class gives you a [Unicode] attribute that you can use on your properties and the UnicodeAttributeConvention will tell EF how to handle the attribute.

You will need to add a line to the OnModelCreating method inside your context for EF to recognize the attribute:

   1: protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
   2: {
   3:     modelBuilder.Conventions.Add(new UnicodeAttributeConvention());
   4:     base.OnModelCreating(modelBuilder);
   5: }

Once you have this done, you can use the attribute in your classes to make sure that you get database types of varchar instead of nvarchar:

   1: [Unicode(false)]
   2: public string Name { get; set; }

 

Another option that is missing is the ability to set the precision and scale on a decimal.  By default decimals get created as (18,0).  If you need decimals to be something like (9,2) then you can once again use the fluent API or create a custom attribute.  As with the unicode attribute, you will need to add two classes to your project:

   1: public class DecimalPrecisionAttribute : Attribute
   2: {
   3:     int _precision;
   4:     private int _scale;
   5:  
   6:     public DecimalPrecisionAttribute(int precision, int scale)
   7:     {
   8:         _precision = precision;
   9:         _scale = scale;
  10:     }
  11:  
  12:     public int Precision { get { return _precision; } }
  13:     public int Scale { get { return _scale; } }
  14: }
  15:  
  16: public class DecimalPrecisionAttributeConvention : AttributeConfigurationConvention<PropertyInfo, DecimalPropertyConfiguration, DecimalPrecisionAttribute>
  17: {
  18:     public override void Apply(PropertyInfo memberInfo, DecimalPropertyConfiguration configuration, DecimalPrecisionAttribute attribute)
  19:     {
  20:         configuration.Precision = Convert.ToByte(attribute.Precision);
  21:         configuration.Scale = Convert.ToByte(attribute.Scale);
  22:  
  23:     }
  24: }

Add your line to the OnModelCreating:

   1: protected override void OnModelCreating(System.Data.Entity.ModelConfiguration.ModelBuilder modelBuilder)
   2: {
   3:     modelBuilder.Conventions.Add(new UnicodeAttributeConvention());
   4:     modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());
   5:     base.OnModelCreating(modelBuilder);
   6: }

Now you can use the following on your properties:

   1: [DecimalPrecision(9,2)]
   2: public decimal Cost { get; set; }

Both these options use the same concepts so if there are other attributes that you want to use, you can create them quite simply.  The key to it all is the PropertyConfiguration classes.   If there is a class for the datatype, then you should be able to write an attribute to set almost everything you need.  You could also create a single attribute to encapsulate all of the possible string combinations instead of having multiple attributes on each property.

All in all, I am loving code first and having attributes to control database generation instead of using the fluent API is huge and saves me a great deal of time.