Mappage un-à-un dans l'architecture S # arp

Question

Il y a une odeur distincte de circuits brûlés venant de ma tête, alors pardonnez mon ignorance. J'essaye de mettre en place une relation un-à-un (bien, laissez Automapper le faire) dans l'architecture S # arp.

J'ai

public class User : Entity 
{ 
    public virtual Profile Profile { get; set; } 
    public virtual Basket Basket { get; set; } 
    public virtual IList<Order> Orders { get; set; } 
    public virtual IList<Role> Roles { get; set; } 
    ... 
} 

public class Basket : Entity 
{ 
    public virtual User User { get; set; } 
    ... 
} 

public class Profile : Entity 
{ 
    public virtual User User { get; set; } 
    ... 
} 

Et mon schéma db est

CREATE TABLE [dbo].[Users](
    [Id] [int] IDENTITY(1,1) NOT NULL, 
    ... 

CREATE TABLE [dbo].[Profiles](
    [Id] [int] IDENTITY(1,1) NOT NULL, 
    [UserFk] [int] NULL, 
    ... 

CREATE TABLE [dbo].[Baskets](
    [Id] [int] IDENTITY(1,1) NOT NULL, 
    [UserFk] [int] NULL, 
    ... 

Quand je lance les CanConfirmDatabaseMatchesMappings de tests unitaires dans MappingIntegrationTests je reçois l'erreur suivante

NHibernate.ADOException: pourrait pas exécuter la requête ... System.D ata.SqlClient.SqlException: Nom de colonne non valide 'ProfileFk'. Nom de colonne incorrect 'BasketFk'.

et sql qu'il essaie d'exécuter est

SELECT TOP 0 
    this_.Id AS Id6_1_ , 
    .. 
    user2_.ProfileFk AS ProfileFk9_0_ , 
    user2_.BasketFk AS BasketFk9_0_ 
FROM 
    Profiles this_ 
    LEFT OUTER JOIN Users user2_ 
     ON this_.UserFk = user2_.Id 

Il est donc à la recherche d'un champ ProfileFk et BasketFk dans la table des utilisateurs. Je n'ai configuré aucun mappage de remplacement client et, pour autant que je puisse voir, j'ai suivi la configuration par défaut des conventions dans S #.

Les deux autres mappages pour les ordres et les rôles IList semblent parfaitement correspondre. Donc je devine qu'il a manqué quelque chose pour établir une relation un-à-un.

Qu'est-ce qui me manque?

Answer 1

Vous l'avez. C'est vraiment un problème NHibernate à résoudre avec la syntaxe Fluent NHibernate, mais cela s'avère pertinent pour S #.

lecture de fond: NHibernate Mapping et Fluent NHibernate HasOne

Ce que vous faites est le mappage pour remplacer l'utilisateur et lui donner deux correspondances de .HasOne. Définissez ensuite une référence unique à l'utilisateur sur le profil et panier classe:

public class UserMap : IAutoMappingOverride<User> 
    { 
     #region Implementation of IAutoMappingOverride<User> 
     /// <summary> 
     /// Alter the automapping for this type 
     /// </summary> 
     /// <param name="mapping">Automapping</param> 
     public void Override(AutoMapping<User> mapping) 
     { 
      mapping.HasOne(u => u.Profile); 
      mapping.HasOne(u => u.Basket); 
     } 
     #endregion 
    } 

public class ProfileMap : IAutoMappingOverride<Profile> 
    { 
     #region Implementation of IAutoMappingOverride<Profile> 
     /// <summary> 
     /// Alter the automapping for this type 
     /// </summary> 
     /// <param name="mapping">Automapping</param> 
     public void Override(AutoMapping<Profile> mapping) 
     { 
      mapping.References(p => p.User).Unique().Column("UserFk"); 
     } 
     #endregion 
    } 

public class BasketMap : IAutoMappingOverride<Basket> 
    { 
     #region Implementation of IAutoMappingOverride<Basket> 
     /// <summary> 
     /// Alter the automapping for this type 
     /// </summary> 
     /// <param name="mapping">Automapping</param> 
     public void Override(AutoMapping<Basket> mapping) 
     { 
      mapping.References(b => b.User).Unique().Column("UserFk"); 
     } 
     #endregion 
    } 

Comme une note de côté, au moment de la rédaction de ce, NHibernate 3 vient d'être publié. Il y a un bon livre appelé NHibernate 3.0 Cookbook que je viens d'acheter et il semble extrêmement utile pour travailler avec S #.