Fluent Nhibernate Automap convention for not-null field

Question

Could some one help, how would I instruct automap to have not-null for a column?

public class Paper : Entity
{
    public Paper() { }

            [DomainSignature]
            [NotNull, NotEmpty]
            public virtual string ReferenceNumber { get; set; }

            [NotNull]
            public virtual Int32 SessionWeek { get; set; }
}

But I am getting the following:

 <column name="SessionWeek"/>

I know it can be done using fluent-map. but i would like to know it in auto-mapping way.

Robi · Accepted Answer · 2010-04-09T16:54:56.077

Thank you. Also, for reference properties ReferenceConvention need to be done. This is the code that works:

public class ColumnNullConvention : IPropertyConvention
{
    public void Apply(IPropertyInstance instance)
    {
        if (instance.Property.MemberInfo.IsDefined(typeof(NotNullAttribute), false))
            instance.Not.Nullable();
    }

}  public class ReferenceConvention : IReferenceConvention
{
    public void Apply(FluentNHibernate.Conventions.Instances.IManyToOneInstance instance)
    {
        instance.Column(instance.Property.Name + "Fk");


        if (instance.Property.MemberInfo.IsDefined(typeof(NotNullAttribute), false))
            instance.Not.Nullable();

    }
}

score 1 · Answer 2 · answered Aug 01 '12 at 07:56

If you are mostly happy with Automapping results but occasionally need to override it for say a couple of properties in a class I find implementing a IAutoMappingOverride for that class the easiest way to achieve that:

public class UserMappingOverride : IAutoMappingOverride<User>
{
      public void Override(AutoMapping<User> mapping)
      {
          mapping.Map(x => x.UserName).Column("User").Length(100).Not.Nullable();
      }
}

And then use them like this:

AutoMap.AssemblyOf<User>().UseOverridesFromAssemblyOf<UserMappingOverride>();

Similar to ClassMaps - but you don't need to describe every field in the class. This approach is very similar to the Entity Framework's Code First Fluent API way.

score 1 · Answer 3 · answered Apr 10 '10 at 05:34

Here is the way I do it, basically taken from the link you see in the code. There are some other useful conventions there as well

HTH,
Berryl

/// <summary>
/// If nullability for the column has not been specified explicitly to allow NULL, then set to “NOT NULL”.
/// </summary>
/// <remarks>see http://marcinobel.com/index.php/fluent-nhibernate-conventions-examples/</remarks>
public class ColumnNullabilityConvention : IPropertyConvention, IPropertyConventionAcceptance
{
    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
        criteria.Expect(x => x.Nullable, Is.Not.Set);
    }

    public void Apply(IPropertyInstance instance)
    {
        instance.Not.Nullable();
    }
}

This worked the best for me. I also implemented a similar convention for not-null references as mentioned in the other post. But using this format. Just change IPropertyConvention and IPropertyConventionAcceptance to use IReferenceConvention and IReferenceConventionAcceptance. — Matt Johnson-Pint, Jun 08 '11 at 15:51

Egor Pavlikhin · Answer 4 · 2010-04-09T11:19:58.647

0

public class Paper Map : IAutoMappingOverride<Paper >
{
    public void Override(AutoMapping<Paper> mapping)
    {
        mapping.Map(x => x.ReferenceNumber).Not.Nullable();
    }
}

Int32 is not nullable type by default. Int32? is nullable, so you make it non-nullable just by specifying it as Int32.

You can use conventions to do this automatically. I am not sure which convention to use, but have a look at FluentNHibernate.Conventions.Instances to find the right one. It'll look like this.

public class ColumnConvention : IColumnConvention
{
    public void Apply(FluentNHibernate.Conventions.Instances.ColumnInstance instance)
    {
        if (instance.EntityType.IsDefined(typeof(NotNullAttribute), false))
            instance.NotNull = true;
    }

    public void Apply(FluentNHibernate.Conventions.Instances.IColumnInstance instance)
    {
        return;
    }
}

Just add this convention to your automapping.

edited Apr 09 '10 at 11:19

answered Apr 09 '10 at 09:05

Egor Pavlikhin

17,503
16
61
99

Thanks, But what if I have many properties in many entities in my application that is not null. Do I override them all? It does not sound right to me though. – Robi Apr 09 '10 at 09:59
nHibernate Validator is a separate thing. You will have to check for the attribute in your automapper. – Egor Pavlikhin Apr 09 '10 at 10:19
Many thanks for your reply. OK. So, it does mean that there is no AutoMapping convention to instruct Fluent Nhibernate to specify a field to be not null other then overriding all the properties of my application. This indactes to me that AutoMap is lacking a very basic feature. If I need to ovverride each class map as alomost all of them have more or less "not-null" fields then why should someone use automapping over fluent-mapping. Please share your thoughts. – Robi Apr 09 '10 at 11:00
No, it's not lacking a feature, because NHibernate Validator is NOT a part of NHibernate, it's an extension. You don't have to write it every time. I have updated my answer to show you what you can do. – Egor Pavlikhin Apr 09 '10 at 11:20
(instance.EntityType.IsDefined(typeof(NotNullAttribute), false) this is always returning false resulting the convention not being applyed. I am not sure how else to detect the presense of the attribute. I have also tried this with PropertConvesntion and its the same isssue. Thanks for your contunius support though. – Robi Apr 09 '10 at 14:50
Well, duh, the attribute is on the properties, not on the class -_- sorry – Egor Pavlikhin Apr 09 '10 at 15:18

score 0 · Answer 5 · answered Aug 05 '11 at 10:58

I find more often than not, my columns are not null, so I prefer make this convention and only specify columns as nullable:

  /// <summary>
  /// Indicates that a column should allow nulls 
  /// </summary>
  [Serializable]
  [AttributeUsage(AttributeTargets.Property)]
  public class NullableAttribute : Attribute
  {
  }



 public class ColumnIsNotNullByDefaultConvention : IPropertyConvention, IPropertyConventionAcceptance
  {
    public void Apply(IPropertyInstance instance)
    {
      instance.Not.Nullable();
    }

    public void Accept(IAcceptanceCriteria<IPropertyInspector> criteria)
    {
      criteria.Expect(c => !c.Property.MemberInfo.IsDefined(typeof(NullableAttribute), false));
    }
  }

Fluent Nhibernate Automap convention for not-null field

5 Answers5

Linked