Programmer vers les interfaces tout en cartographiant avec NHibernate Fluent

je me rends compte qu'il s'agit d'une diversion, et non d'une réponse à votre question (bien que je pense que mookid a obtenu ce couvert).

vous devriez vraiment évaluer si les interfaces sur vos entités de domaine fournissent réellement quelque chose de Valable; il est rare de trouver une situation où vous avez réellement besoin de le faire.

par exemple: comment utiliser IMessage moins couplé que Message , quand ils deux (presque) sans doute partager des signatures identiques? Vous ne devriez pas avoir besoin de vous moquer d'une entité, parce qu'il est rare qu'elle ait assez de comportement pour exiger d'être moquée.

vous pouvez ajuster votre interface pour ne contenir qu'un getter:

public interface ISomeEntity
{
    int Id { get; }
}

votre classe de béton peut encore implémenter un setter, et puisque vous programmez sur vos interfaces, vous n'appellerez jamais le setter "par accident".

si vous voulez refuser de définir l'id même si vous tenez une référence à une instance concrète, vous pouvez vous abstenir d'implémenter un setter, et puis laisser NHibernate accéder au champ au lieu de la propriété - C'est vrai, NHibernate peut utiliser une ruse de réflexion astucieuse pour définir votre champ d'identification directement au lieu d'invoquer la propriété. Alors vous pourriez cartographier l'id comme ceci:

Id(e => e.Id).Access.AsCamelCaseField();

dans ce cas, votre propriété Id doit être soutenue par un champ correspondant id . Il y a plus de conventions de nommage, par exemple si vous préférez les underscores comme préfixe de champ privé.

j'ai exactement le même problème. Malheureusement, j'ai une raison valable pour utiliser les interfaces entity; le modèle entity sera implémenté de différentes façons et avec différentes correspondances par client.

le modèle entier doit être lu en lecture seule, donc les interfaces sont du style:

public interface IAccount
{
    long AccountId { get; }
    IHouse House { get; }
}

public interface IHouse
{
    long HouseId { get; }
    HouseStatus Status { get; }
    IList<IAccount> Accounts { get; }
}

implémentations concrètes puis les mettre en œuvre avec des setters internes:

public class Account: IAccount
{
    public virtual long AccountId { get; internal set; }
    public virtual IHouse House { get; internal set; }
}

public class House: IHouse
{
    public virtual long HouseId { get; internal set; }
    public virtual HouseStatus Status { get; internal set; }
    public virtual IList<IAccount> Accounts { get; internal set; }
}

j'ai suivi la route de la cartographie pour les classes concrètes. Tout va bien jusqu'à ce que vous créiez des relations qui retournent des interfaces et doivent être moulées à des implémentations concrètes.

HasMany(x => x.Accounts)

peut devenir

HasMany<Account>(x => x.Accounts)

Mais il n'y a pas d'équivalent "cast" pour

References(x => x.House)

Mapping to the interfaces (the neater solution) soulève le problème mentionné ci-dessus en ce que L'Id doit exister sur la classe supérieure pour le réglage et nécessite un setter sur le interface.

public sealed class AccountMap : ClassMap<IAccount>
{
    public PokerPlayerMap()
    {
        Id(x => x.AccountId, "account_id");

        DiscriminateSubClassesOnColumn("Type").SubClass<Account>(s =>  
        {
            References(x => x.House);       
        });
    }
}

pour l'instant, ma seule solution est d'ajouter des setters à tous les champs d'ID d'interface. C'est une honte L'Id ne peut pas exister à l'intérieur d'une sous-classe ou avoir son type moulé à partir de l'interface.

on dirait que je n'ai pas assez de réputation pour commenter les réponses d'autres personnes encore en tant que tel je vais devoir faire ceci une réponse en elle-même.

Références a maintenant une surcharge générique pour permettre à la distribution que theGecko cherchait dans sa réponse.