richardlawley / entityframeworkattributeconfig

Configure code-first mappings using attributes

Entity Framework Attribute Config

Allows you to configure properties by placing attributes on the properties of the Entity, rather than using the fluent configuration method. For example...

public class MyEntity 
{
    [DateTimePrecision(0)]    // Column will be created as datetime(0)
    public DateTime ShortDate { get; set; }
    
    [DecimalPrecision(18, 5)] // Column will be created as decimal(18,5)
    public decimal PreciseNumber { get; set; }
}

Install from nuget:

PM> Install-Package EFAttributeConfig

For each type of precision attribute you wish to use, add a line to your OnModelCreating method:

public class TestContext : DbContext 
{
	protected override void OnModelCreating(DbModelBuilder modelBuilder)
	{
	    base.OnModelCreating(modelBuilder);
	    
        // Add conventions for Precision Attributes
	    modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());
        modelBuilder.Conventions.Add(new DateTimePrecisionAttributeConvention());
	}
}

The following attributes have been implemented so far:

• DecimalPrecisionAttribute - change the precision of a decimal
• DateTimePrecisionAttribute - change the precision of a datetime2 or datetimeoffset type

Adding further attributes is simple - take a look at the implementation of the existing attributes for an example!

This project is an extension of this StackOverflow answer. Thanks to @richi2666 for the suggestion of using conventions instead of Reflection.

entityframeworkattributeconfig's Issues

License?

Could you designate a license for this project?

Use a Convention insteat of Reflection

Hi Richard,

first off all: This is a very great Library!

After some troubles with inheritance and generic types, i have found a nice way to implement this:

using System.Data.Entity.ModelConfiguration.Configuration;
using System.Data.Entity.ModelConfiguration.Conventions;

public class DecimalPrecisionAttributeConvention : PrimitivePropertyAttributeConfigurationConvention<DecimalPrecisionAttribute>
{
    public override void Apply(ConventionPrimitivePropertyConfiguration configuration, DecimalPrecisionAttribute attribute)
    {
        configuration.HasPrecision(attribute.Precision, attribute.Scale);
    }
}

and then in the OnModelCreation:

modelBuilder.Conventions.Add(new DecimalPrecisionAttributeConvention());

What do you think about this solution?

Doesn't work with .Net Core

The namespace System.Data.Entity.ModelConfiguration.Conventions doesn't exist in .Net Core.

Error Message

How Can i Add Error Message to CDecimalPrecisionAttribute?!

String is Unicode Attribute

Here's another attribute you can add to this library:

/// <summary>Attribute for string is unicode. This class cannot be inherited.</summary>
/// <seealso cref="T:System.Attribute"/>
[AttributeUsage(AttributeTargets.Property)]
public sealed class StringIsUnicodeAttribute : Attribute
{
    /// <summary>Initializes a new instance of the <see cref="StringIsUnicodeAttribute"/> class.</summary>
    /// <param name="isUnicode">true if this object is unicode, false if not.</param>
    public StringIsUnicodeAttribute(bool isUnicode)
    {
        IsUnicode = isUnicode;
    }

    /// <summary>Gets a value indicating whether this object is unicode.</summary>
    /// <value>true if this object is unicode, false if not.</value>
    public bool IsUnicode { get; }
}

And here's how I'm implementing it with my modelBuilder, you would need to convert this to your Convention methodology:

private static void ImplementStringIsUnicodeAttributes(DbModelBuilder modelBuilder)
{
    // Implement String Is Unicode Attributes
    foreach (var classType in Assembly.GetAssembly(typeof(StringIsUnicodeAttribute))
                                .GetTypes()
                                .Where(t => t.IsClass && t.Namespace == "YOUR.NAMESPACE"))
    {
        foreach (var propAttr in classType.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                    .Where(p => p.GetCustomAttribute<StringIsUnicodeAttribute>() != null)
                                    .Select(p => new { prop = p, attr = p.GetCustomAttribute<StringIsUnicodeAttribute>(true) }))
        {
            var entityConfig = modelBuilder.GetType().GetMethod("Entity").MakeGenericMethod(classType).Invoke(modelBuilder, null);
            var param = Expression.Parameter(classType, "c");
            var property = Expression.Property(param, propAttr.prop.Name);
            var lambdaExpression = Expression.Lambda(property, true, param);
            var methodInfo = entityConfig.GetType().GetMethods().Where(p => p.Name == "Property").ToList()[4];
            var stringConfig = methodInfo.Invoke(entityConfig, new object[] { lambdaExpression }) as StringPropertyConfiguration;
            stringConfig?.IsUnicode(propAttr.attr.IsUnicode);
        }
    }
}