Fluente convenzione NHibernate Automap per il campo non nullo

Question

Potrebbe qualcuno aiuto, come potrei istruire Automap di avere non-nullo per una colonna?

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

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

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

Ma io sono sempre il seguente:

 <column name="SessionWeek"/>

So che può essere fatto utilizzando correntemente-map. ma mi piacerebbe sapere in modo auto-mappatura.

Answer 1

Grazie. Inoltre, per necessità proprietà di riferimento ReferenceConvention da fare. Questo è il codice che funziona:

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();

    }
}

Answer 2

Ecco il modo in cui lo faccio, sostanzialmente preso dal link che vedete nel codice. Ci sono alcune altre convenzioni utili là pure

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();
    }
}

Answer 3

Se si è per lo più felice con i risultati automapping, ma di tanto in tanto bisogno di sovrascrivere per dire un paio di proprietà in una classe trovo l'attuazione di un IAutoMappingOverride per quella classe il modo più semplice per raggiungere questo obiettivo:

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

E poi usarli in questo modo:

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

Simile a ClassMaps - ma non c'è bisogno di descrivere ogni campo nella classe. Questo approccio è molto simile al modo in cui API primo codice Fluent di Entity Framework.

Answer 4

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

Int32 non è il tipo nullable per impostazione predefinita. Int32? è annullabile, in modo da renderlo non annullabile semplicemente specificando come Int32.

È possibile utilizzare le convenzioni per farlo automaticamente. Io non sono sicuro di quale convenzione per l'uso, ma dare un'occhiata a FluentNHibernate.Conventions.Instances per trovare quella giusta. Sarà simile a questa.

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;
    }
}

Basta aggiungere questa convenzione al vostro automapping.

Answer 5

Trovo il più delle volte, le mie colonne non sono nulli, quindi preferisco fare questa convenzione e specificare solo le colonne come annullabile:

  /// <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));
    }
  }