Durchgängiges NHibernate erzwingen Not Nullable auf Foreign Key Reference

Question

Nur meine Füße nass mit einigen Fluent NHibernate AutoMap Konventionen, und stieß auf etwas, das ich nicht herausfinden konnte. Ich nehme an, ich schaue einfach nicht an der richtigen Stelle ... Im Grunde versucht, NOT-NULL auf der "vielen" Seite der Eins-zu-viele-Beziehung zu erzwingen. Es scheint, mit dem automatischen Zuweisen, es macht immer die Eltern-Eigenschaft Id Nullable in der Datenbank.

Ich habe etwas auf StackOverFlow gesucht und ähnliche Fragen gefunden, aber nichts in Bezug auf AutoMapping und Konventionen (außer ich habe es verpasst).

Schnell Beispiel ...

public class Group // One Group 
{ 
    public Group() { this.Jobs = new List<Job>(); } 
    public virtual Guid Id { get; set; } 
    public virtual string Name { get; set; } 
    public virtual IList<Job> Jobs { get; protected set; } 
} 

public class Job // Has many Jobs 
{ 
    public virtual Guid Id { get; set; } 
    public virtual string Name { get; set; } 

    // Trying to make this field not-nullable in the database. 
    public virtual Group Group { get; set; } 
} 

Ich dachte, ich wäre in der Lage zu schaffen, nur eine Konvention wie ...

public class OneToManyConvention : IHasOneConvention 
{ 
    public void Apply(IOneToOneInstance instance) 
    { 
     // Nullable() isn't a valid method... 
     instance.Not.Nullable(); 
    } 
} 

Aber es scheint IOneToOnInstance nicht über eine Nullable () Methode. Ich kann das tun, wenn ich eine Map-Datei für Job erstelle, aber versuche, Map-Dateien zu vermeiden und bei der automatischen Zuordnung zu bleiben.

Ich stieß auf diese link on the Fluent group list beschreibt etwas ähnliches.

, das ungefähr so ​​beschreibt ...

public class NotNullPropertyConvention : IPropertyConvention 
{ 
    public bool Accept(IProperty target) 
    { 
      return true; 
    } 
    public void Apply(IProperty target) 
    { 
      target.Not.Nullable(); 
    } 
} 

Aber das wirft die Frage von ... 1) Wie würde ich IProperty bestimmen ein Job (oder jedes Kind Eigentum zu sein, dass ein Link zurück ist zum Elternteil)

2) Es machte auf dieser Seite eine Erwähnung, dass das Überschreiben meiner manuellen Überschreibungen, z. wenn eine sehr spezifische Eigenschaftenverknüpfung NULL sein muss. Was wäre ein Problem (wenn es immer noch ein Problem ist, aber nicht getestet werden kann, ohne Nummer 1 als erstes herauszufinden)

Irgendwelche Ideen dazu? Fehle ich gerade etwas?

---

aktualisieren 1

Noch nicht gehen. Auch noch die folgende erzwingt nicht Nicht-Nullable in das Datenbankschema ...

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

Es tut für alle anderen Felder obwohl ...
/Achselzucken

Irgendwelche Ideen?

---

Update 2

Während dies nicht die Antwort ist, ich suchte, habe ich eine Arbeit um finden ... ich NHibernate Validator Montage wurde mit und innerhalb dieser Versammlung dort ist ein [NotNull] -Attribut. Wenn ich meine Klasse mit dem Validator-Attribut versehen und die ValidationEngine vor der Schemaerstellung mit NHibernate verknüpft habe, würde dies die FK-Datenbankspalte als Nicht-Nullable markieren.

public class Job // Has many Jobs 
{ 
    public virtual Guid Id { get; set; } 
    public virtual string Name { get; set; } 

    [NHibernate.Validator.Constraints.NotNull] 
    public virtual Group Group { get; set; } 
} 

Wenn jemand den vollständigen Code für die NHibernate + ValidationEngine Initialisierung braucht, lass es mich wissen. Immer noch auf der Suche nach einer Möglichkeit, es mit dem reinen Mapping Konvention Route zu tun, wenn jemand irgendwelche Informationen hat ...

Vielen Dank!

Answer 1

Sie können die automatisch zugeordneten Eigenschaften als Teil Ihrer AutoMap in Fluenttly.Configure() überschreiben.

So können Sie dies tun:

.Override<Job>(map => map.References(x => x.Group).Not.Nullable()) 

Es ist nicht gerade praktisch, wenn Sie viele Klassen haben, die diese allerdings müssen.

Edit: Sie auch die Überschreibung in einer Klasse angeben, die IAutoMappingOverride implementiert wie so:

public class JobMappingOverride : IAutoMappingOverride<Job> 
    { 
      public void Override(AutoMapping<Job> mapping) 
      { 
        mapping.References(x => x.Group).Not.Nullable(); 
      } 
    } 

und sind es etwa so:

.UseOverridesFromAssemblyOf<JobMappingOverride>() 

Dies würde Ihre fließend Konfiguration halten ein bisschen sauberer.

Answer 2

Es scheint, dass IPropertyConvention nur für einfache Eigenschaften Ihrer Klassen aufgerufen wird. Wenn Ihre Eigenschaft eine andere Klasse referenziert, müssen Sie auch IReferenceConvention verwenden.

Versuchen Sie folgendes:

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

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