Courant convention Nhibernate Automap pour le champ non nul

Question

Aurait-on une aide, comment pourrais-je demander à Automap de ne pas avoir nulle pour une colonne?

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

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

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

Mais je reçois ce qui suit:

 <column name="SessionWeek"/>

Je sais que cela peut être fait en utilisant la carte-parler couramment. mais je voudrais savoir dans manière auto-mapping.

Answer 1

Merci. En outre, pour les propriétés de référence ReferenceConvention doivent faire. Ceci est le code qui fonctionne:

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

Voici la façon dont je le fais, essentiellement pris du lien que vous voyez dans le code. Il y a quelques autres conventions utiles là aussi

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

Si vous êtes satisfait de la plupart des résultats AutoMapping, mais ont besoin de temps en temps pour passer outre pour dire quelques propriétés dans une classe que je trouve mettre en œuvre un IAutoMappingOverride pour cette classe la meilleure façon d'y parvenir:

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

Et puis les utiliser comme ceci:

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

Similaire à ClassMaps - mais vous n'avez pas besoin de décrire tous les domaines de la classe. Cette approche est très similaire au code Première de manière API Courant du Entity Framework.

Answer 4

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

Int32 n'est pas type Nullable par défaut. Int32? est annulable, de sorte que vous le faites non annulable simplement en spécifiant comme Int32.

Vous pouvez utiliser les conventions pour le faire automatiquement. Je ne suis pas sûr de convention à utiliser, mais un coup d'oeil à FluentNHibernate.Conventions.Instances de trouver la bonne. Ça va ressembler à ceci.

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

Il suffit d'ajouter cette convention à votre AutoMapping.

Answer 5

Je trouve plus souvent qu'autrement, mes colonnes ne sont pas nulles, donc je préfère faire de cette convention et ne spécifient que des colonnes 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));
    }
  }