Fluent NHibernate Automap Konvention für nicht-Null-Feld

Question

Kann jemand helfen, wie würde ich anweisen Automap nicht-null haben, für eine Spalte?

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

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

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

Aber ich erhalte die folgenden:

 <column name="SessionWeek"/>

Ich weiß, es fließend-Karte durchgeführt werden kann. aber ich mag es wissen, in Auto-Mapping Art und Weise.

Answer 1

Danke. Auch für Referenzobjekte ReferenceConvention Notwendigkeit zu tun. Dies ist der Code, das funktioniert:

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

Dies ist die Art, wie ich es tun, im Grunde von der Verbindung genommen Sie den Code zu sehen. Es gibt einige andere nützliche Konventionen auch dort

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

Wenn Sie sind meist zufrieden mit Automapping Ergebnisse, aber gelegentlich müssen sie außer Kraft zu setzen für sagen ein paar Eigenschaften in einer Klasse I eine IAutoMappingOverride der einfachste Weg für diese Klasse finden Implementierung, das zu erreichen:

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

Und dann sie wie folgt verwendet werden:

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

Ähnlich wie ClassMaps - aber Sie nicht jedes Feld in der Klasse beschreiben müssen. Dieser Ansatz ist sehr ähnlich wie die Entity Framework-Code Ersten Fluent API Weg.

Answer 4

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

Int32 ist nicht auf NULL festlegbaren Typ standardmäßig. Int32? NULL-Werte zulässt, so dass Sie es nicht auf NULL festlegbare nur machen, indem die Angabe als Int32.

Sie können Konventionen verwenden, um dies automatisch zu tun. Ich bin nicht sicher zu benutzen, die Konvention zu, habe aber einen Blick auf FluentNHibernate.Conventions.Instances die richtigen zu finden. Es wird so aussehen.

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

Fügen Sie einfach diese Konvention zu Ihrem Automapping.

Answer 5

ich häufiger finden als nicht, sind meine Spalten nicht null, so dass ich diese Konvention machen bevorzugen und nur Spalten als nullable angeben:

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