Fluent nhibernate FluentNHibernate：获取列&；应用映射约定后的表名

我想知道，在应用了所有约定之后，是否可以为已映射为FluentNHibernate的类/组件找到运行时列名

例如，给定简单模型：

 public class Address{ 
    public string Street {get; set;} 
    public string Zip {get; set;} 
 } 

 public class AddressMap : ComponentMap<Address>{
     Map( x => x.Street );
     Map( x => x.Zip );
 }

 public class PersonMap : ClassMap<Person> 
 { 
    public PersonMap(){ 

       Id( x => x.Id ); 
       Map( x=> x.Ssn );
       Map( x=> x.Name ); 

       Component( x => x.Address ) 
          .ColumnPrefix("ADDRESS_"); 
    } 
 }

public class ClassConvention : IClassConvention
{
    public void Apply( IClassInstance instance )
    {
        instance.Table( "tbl" + instance.EntityType.Name );
    }
}

---

我正在寻找的以及我不确定如何做的是：

var mappings = FluentNHibaernate.CompileMergeAndBuildAllMappings();

var zipCodeColumnName = mappings.FindMappedType<Address>().ColumnName(a => a.Zip)

zipCodeColumnName.ShouldBe("ADDRESS_Zip");
// Here I'm interested in the run-time & final column name with the
// prefix applied from the PersonMap class.

var personTableName = mappings.FindMappedType<Person>().TableName;
personTableName.ShouldBe("tblPerson");
// I'm interested in the final table name after the ClassConvention
// modified the table name.

var-mappings=fluentnhibiernate.CompileMergeAndBuildAllMappings（）；
var zipCodeColumnName=mappings.FindMappedType（）.ColumnName（a=>a.Zip）
zipCodeColumnName.ShouldBe（“地址”）；
//在这里，我感兴趣的是运行时和最终的列名
//从PersonMap类应用的前缀。
var personTableName=mappings.FindMappedType（）.TableName；
personTableName.应该是（“tblPerson”）；
//我对类约定之后的最终表名感兴趣
//修改了表名。

补充澄清

• 我只对FluentNHiberante应用约定和映射的结果感兴趣。不在NHibernate生成的实际SQL中

谢谢你的帮助，

---

Brian

由于组件的每个应用程序的组件列名可能不同，因此您必须知道需要哪个属性

var config = Fluently.Configure()
    .DataBase(...)
    .Mappings(...)
    .BuildConfiguration();

var map = config.GetClassMapping(typeof(Person));

map.Table.Name.ShouldBe("tblPerson");
map.GetProperty("Address").IsComposite.ShouldBe(true);
((Component)map.GetProperty("Address").Value)
    .GetProperty("Zip").ColumnIterator.First()
    .Text.ShouldBe("ADDRESS_Zip");

[测试]
公共无效测试4（）
{
var ssnColumn=运行时名称
.ColumnName（x=>x.Ssn）；
Ssn列应相等（“Ssn”）；
var addressColumn=运行时名称
.ColumnName（x=>x.Address.Street）；
addressColumn.ShouldEqual（“ADDRESS_Street”）；
var personTableName=运行时名称
.TableName（）；
personTableName.ShouldEqual（“tblPerson”）；
}

---

公共静态类运行时名称
{
私有静态配置cfg=fluntly.Configure（）
.数据库（MsSqlConfiguration.MsSql2005）
.Mappings（m=>m.FluentMappings
.AddFromAssemblyOf（）的
.公约
.AddFromAssemblyOf（）的
).BuildConfiguration（）；
公共静态字符串ColumnName（表达式属性）
其中T:class，new（）
{
var访问器=FluentNHibernate.Utils.Reflection
.ReflectionHelper.GetAccessor（属性）；
var Name=accessor.Name.Split（'.'）；
var classMapping=cfg.GetClassMapping（typeof（T））；
返回WalkPropertyChain（classMapping.GetProperty（names.First（）），0，names）；
}
私有静态字符串WalkPropertyChain（属性属性、int索引、字符串[]名称）
{
if（property.IsComposite）
返回WalkPropertyChain（（（组件）property.Value）.GetProperty（名称[++index]），索引，名称）；
返回property.ColumnIterator.First（）.Text；
}
公共静态字符串TableName（），其中T:class，new（）
{
返回cfg.GetClassMapping（typeof（T））
.Table.Name；
}
}

是的。这是正确的想法。我已经给了您答案，并且在您的答案下面添加了我的

RuntimeNames

类。谢谢很好的实现（如果您知道配置）

    [Test]
    public void test4()
    {
        var ssnColumn = RuntimeNames
                           .ColumnName<Person>( x => x.Ssn );
        ssnColumn.ShouldEqual( "Ssn" );

        var addressColumn = RuntimeNames
                               .ColumnName<Person>( x => x.Address.Street );
        addressColumn.ShouldEqual( "ADDRESS_Street" );

        var personTableName = RuntimeNames
                                 .TableName<Person>();
        personTableName.ShouldEqual( "tblPerson" );
    }

public static class RuntimeNames
{
    private static Configuration cfg = Fluently.Configure()
        .Database( MsSqlConfiguration.MsSql2005 )
        .Mappings( m => m.FluentMappings
                            .AddFromAssemblyOf<PersonMap>()
                            .Conventions
                            .AddFromAssemblyOf<PersonMap>()
        ).BuildConfiguration();

    public static string ColumnName<T>( Expression<Func<T, object>> property )
        where T : class, new()
    {
        var accessor = FluentNHibernate.Utils.Reflection
            .ReflectionHelper.GetAccessor( property );

        var names = accessor.Name.Split('.');

        var classMapping = cfg.GetClassMapping( typeof( T ) );

        return WalkPropertyChain( classMapping.GetProperty(names.First()), 0, names );
    }

    private static string WalkPropertyChain(Property property, int index, string[] names)
    {
        if( property.IsComposite )
            return WalkPropertyChain( ((Component)property.Value).GetProperty( names[++index] ), index, names );

        return property.ColumnIterator.First().Text;
    }

    public static string TableName<T>() where T : class, new()
    {
        return cfg.GetClassMapping( typeof(T) )
            .Table.Name;
    }
}