通过 Fluent-nHibernate 约定的复合主键声明

Question

我需要对具有复合主键的表使用 Fluent-nHibernate（Azure 表，主键为 (PartitionKey,RowKey)，我想将它们映射到实体上的相应属性（或者使用组件属性，如果更容易的话）

我的表看起来像：

{
  PartitionKey PK,
  RowKey PK,
  [..]
}

我当前的项目

public class MyRecord
{
  public virtual string PartitionKey{get;set;}
  public virtual string RowKey{get;set;}

  [...]
}

使用针对 AzureTable 的自定义 nHibernate 驱动程序，

因此我确信该驱动程序正在工作。使用类映射或 XML 声明是正确的。

但是，我确实需要约定，因此这不是一个可接受的解决方案。

最后，即使数据存储区使用 (​​PartitionKey,RowKey)，也始终可以选择仅将 RowKey 映射为 PK。然而，它并不太令人满意，因为它引入了 nHibernate 和底层数据存储之间的唯一性处理不匹配。

更新：

我尝试构建一个自定义的 IIdentityConvention。 IIdentityInstance.Column() 方法仅考虑第一次调用。 但是，如果我使用反射将两列添加到基础映射字段，则配置构建会失败并出现 XML 验证异常（需要属性“class”）

Answer 1

我今天成功了，但是不太好。它也不使用约定。据我了解，约定实际上是为了在主映射发生后进行调整。我认为添加映射被认为超出了约定的范围。

在我的项目中，我有一个通用的基于自动映射的初始化过程，它对类型一无所知，但具有复合键的依赖注入映射覆盖。不完全是你的情况，但这是一个类似的问题。

我通过反射实现此目的的方法是获取适当的 AutoPersistenceModel 对象。如果您的代码如下所示：

Fluently.Configure().Mappings(m => ...

AutoPersistenceModel 对象将是 m.AutoMappings.First()

从这里开始，这是相当严肃的反射工作，最终调用 FluentNHibernate 内的受保护方法。这是我正在使用的代码：

    private void Override(AutoPersistenceModel container, 
                          Type type, 
                          IEnumerable<KeyValuePair<string,string>> compositeKeys)
    {
        // We need to call container.Override<T>(Action<Automapping<T>> populateMap)
        // Through reflection...yikes
        var overrideMethod = typeof(AutoPersistenceModel)
                               .GetMethod("Override")
                               .MakeGenericMethod(type);
        var actionFactoryMethod = typeof(FluentNHibernateInitializer)
                                    .GetMethod("CompositeMapperFactory",
                                       BindingFlags.Instance | BindingFlags.NonPublic)
                                    .MakeGenericMethod(type);
        var actionMethod = actionFactoryMethod
                             .Invoke(this, new object[] { compositeKeys });
        overrideMethod.Invoke(container, new object[] {actionMethod});
    }

    private Action<AutoMapping<T>> CompositeMapperFactory<T>
           (IEnumerable<KeyValuePair<string, string>> compositeKeys)
    {
        return new Action<AutoMapping<T>>(m =>
            {
                var compositeId = m.CompositeId();
                foreach (var kvp in compositeKeys) 
                    compositeId = 
                      AddKeyProperty(
                        compositeId, 
                        typeof(T).GetProperty(kvp.Key), 
                        kvp.Value);
            }
        );
    }

    /// <summary>
    /// Uses reflection to invoke private and protected members!
    /// </summary>
    /// <param name="compositeId"></param>
    /// <param name="propertyInfo"></param>
    /// <returns></returns>
    private CompositeIdentityPart<T> AddKeyProperty<T>
      (CompositeIdentityPart<T> compositeId, 
       PropertyInfo propertyInfo, 
       string column)
    {
        var member = FluentNHibernate.MemberExtensions.ToMember(propertyInfo);
        var keyPropertyMethod = typeof(CompositeIdentityPart<T>)
                                  .GetMethod("KeyProperty", 
                                     BindingFlags.Instance | BindingFlags.NonPublic);
        return (CompositeIdentityPart<T>)
                 keyPropertyMethod
                   .Invoke(compositeId, new object[] { member, column, null });
    }