Fluent nhibernate FluentNHibernate.QueryOver.Join.Where（）无法从中确定成员类型_Fluent Nhibernate_Queryover

Fluent nhibernate FluentNHibernate.QueryOver.Join.Where（）无法从中确定成员类型

fluent-nhibernate

Fluent nhibernate FluentNHibernate.QueryOver.Join.Where（）无法从中确定成员类型,fluent-nhibernate,queryover,Fluent Nhibernate,Queryover,我用LINQ/NHibernate搜索并尝试了许多不同的方法来实现这一点，但没有找到任何可行的方法我正在尝试从我的数据中获取没有BolContainer的REF字段。我经常会遇到以下错误： “无法从bc确定成员类型” 或者返回所有的REF字段，不管它们是否有BolContainer 数据库创建表dbo.REF( Id BIGINT主键标识（1,1）不为空， HL_Id BIGINT引用HL（Id）NOT NULL， ElementOrder SMALLINT不为空， Element01 VA

我用LINQ/NHibernate搜索并尝试了许多不同的方法来实现这一点，但没有找到任何可行的方法

我正在尝试从我的数据中获取没有BolContainer的REF字段。我经常会遇到以下错误： “无法从bc确定成员类型” 或者返回所有的REF字段，不管它们是否有BolContainer

数据库

创建表dbo.REF( Id BIGINT主键标识（1,1）不为空， HL_Id BIGINT引用HL（Id）NOT NULL， ElementOrder SMALLINT不为空， Element01 VARCHAR（3）不为空， Element02 VARCHAR（30）不为空， Element03 VARCHAR（80）NULL )

创建表dbo.BolContainer( Id BIGINT主键标识（1,1）不为空， BSN_Id BIGINT唯一引用BSN（Id）不为空， REF_Id BIGINT唯一引用REF（Id）不为空， ErrorId BIGINT引用错误（Id）NULL，拒绝位NULL，完全位空，删除位空值 )

实体

public class REF : EdiEntity
{
    public virtual short Order { get; set; }
    public virtual string Element01 { get; set; }
    public virtual string Element02 { get; set; }
    public virtual string Element03 { get; set; }

    public virtual HL HL { get; set; }

    public virtual BolContainer BolContainer { get; set; }
}
public class BolContainer : Entity
{
    public virtual bool? Rejected { get; set; }
    public virtual bool? Complete { get; set; }
    public virtual bool? Deleted { get; set; }

    public virtual BSN BSN { get; set; }

    public virtual REF REF { get; set; }

    public virtual Error Error { get; set; }

    public virtual void AddBSN(BSN bsn)
    {
        bsn.BolContainer = this;
        BSN = bsn;
    }

    public virtual void AddREF(REF r)
    {
        r.BolContainer = this;
        REF = r;
    }

    public virtual void AddError(Error error)
    {
        error.BolContainers.Add(this);
        Error = error;
    }
}

映射

    public class REFMap : ClassMap<REF>
{

    public REFMap()
    {
        Id(x => x.Id);
        References(x => x.HL, "HL_Id");
        Map(x => x.Order, "ElementOrder");
        Map(x => x.Element01);
        Map(x => x.Element02);
        Map(x => x.Element03);

        HasOne(x => x.BolContainer)
            .Cascade.All()
            .Not.LazyLoad()
            .Fetch.Join();
    }

}

public class BolContainerMap : ClassMap<BolContainer>
{

    public BolContainerMap()
    {
        Id(x => x.Id);
        Map(x => x.Rejected).Nullable();
        Map(x => x.Complete).Nullable();
        Map(x => x.Deleted).Nullable();

        References(x => x.BSN, "BSN_Id")
            .Cascade.All();

        References(x => x.REF, "REF_Id")
            .Cascade.All()
            .Not.LazyLoad()
            .Fetch.Join();

        References(x => x.Error, "ErrorId")
            .Cascade.All()
            .Nullable();
    }

}

public class REFMap:ClassMap
{
公共参考地图（）
{
Id（x=>x.Id）；
参考文献（x=>x.HL，“HL_Id”）；
Map（x=>x.顺序，“ElementOrder”）；
Map（x=>x.Element01）；
Map（x=>x.Element02）；
Map（x=>x.Element03）；
HasOne（x=>x.BolContainer）
.Cascade.All（）
.Not.LazyLoad（）
.Fetch.Join（）；
}
}
公共类BolContainerMap:ClassMap
{
公共容器映射（）
{
Id（x=>x.Id）；
Map（x=>x.Rejected）.Nullable（）；
Map（x=>x.Complete）.Nullable（）；
Map（x=>x.Deleted）.Nullable（）；
参考（x=>x.BSN，“BSN\u Id”）
.Cascade.All（）；
参考（x=>x.REF，“REF\u Id”）
.Cascade.All（）
.Not.LazyLoad（）
.Fetch.Join（）；
参考（x=>x.Error，“ErrorId”）
.Cascade.All（）
.Nullable（）；
}
}

这是我的职责，我做了许多徒劳的尝试：

    public IList<REF> GetUnprocessedBols()
    {
            ISession DbSession = SessionFactory.OpenSession();

            //var x = from REF r in DbSession.Query<REF>()
            //        where r.Element01 == "MB" && r.BolContainer != null
            //        select r;

            //return x.ToList<REF>();

            //return DbSession.CreateCriteria<REF>()
            //        .Add(Restrictions.Where<REF>(r => r.Element01 == "MB"))
            //        //.Add(Restrictions.Where<REF>(r => r.BolContainer == null))
            //        .List<REF>();

            //REF bolAlias = null;
            //BolContainer bolContainerAlias = null;

            //var result = DbSession
            //        .QueryOver<REF>(() => bolAlias)
            //        .Where(r => r.Element01 == "MB")
            //        .WithSubquery
            //        .WhereNotExists<BolContainer>(
            //            QueryOver.Of<BolContainer>(() => bolContainerAlias)
            //            .Where(() => bolAlias.BolContainer == null)
            //            .Select(x => x.REF)
            //        );

            //return result.List();

            //return DbSession
            //        .QueryOver<BolContainer>()
            //        .Right.JoinQueryOver(x => x.REF)
            //        .Where(r => r.Element01 == "MB")
            //        .Where(r => r.BolContainer == null)
            //        .Select(bc => bc.REF)
            //        .List<REF>();

            return DbSession
                    .QueryOver<REF>()
                    .Where(r => r.Element01 == "MB")
                    .Left.JoinQueryOver(x => x.BolContainer)
                    .Where(bc => bc == null)
                    .List();
    }

public IList GetUnprocessedBols（）
{
ISession DbSession=SessionFactory.OpenSession（）；
//var x=来自DbSession.Query（）中的REF r
//其中r.Element01==“MB”&&r.BolContainer！=null
//选择r；
//返回x.ToList（）；
//返回DbSession.CreateCriteria（）
//.Add（Restrictions.Where（r=>r.Element01==“MB”））
////.Add（Restrictions.Where（r=>r.BolContainer==null））
//.List（）；
//REF-bolais=null；
//BolContainer bolcontainerarias=null；
//var结果=DbSession
//.QueryOver（（）=>bolAlias）
//.其中（r=>r.Element01==“MB”）
//.带subquery
//.哪里不存在(
//（（）=>bolContainerAlias）的查询版本
//.Where（（）=>bolAlias.BolContainer==null）
//.选择（x=>x.REF）
//        );
//返回result.List（）；
//返回数据会话
//.QueryOver（）
//.Right.JoinQueryOver（x=>x.REF）
//.其中（r=>r.Element01==“MB”）
//.Where（r=>r.BolContainer==null）
//.Select（bc=>bc.REF）
//.List（）；
返回数据会话
.QueryOver（）
.其中（r=>r.Element01==“MB”）
.Left.JoinQueryOver（x=>x.BolContainer）
.其中（bc=>bc==null）
.List（）；
}

我想让最底层的一个工作，但会满足于其中任何一个

我不想求助于HQL，也不想在之后过滤列表，但我不确定我是否能让它在其他情况下工作

谢谢你的帮助，

杰夫

在顽固地玩弄我尝试过的各种方法之后，我终于找到了一种可行的方法

            REF bolAlias = null;
            BolContainer bolContainerAlias = null;

            var result = DbSession
                    .QueryOver<REF>(() => bolAlias)
                    .Where(r => r.Element01 == "MB")
                    .WithSubquery
                    .WhereNotExists<BolContainer>(
                        QueryOver.Of<BolContainer>(() => bolContainerAlias)
                        .Where(() => bolAlias.Id == bolContainerAlias.REF.Id)
                        .Select(x => x.REF)
                    );

            return result.List();

REF-bolais=null；
BolContainer bolcontainerarias=null；
var结果=DbSession
.QueryOver（（）=>bolAlias）
.其中（r=>r.Element01==“MB”）
.带subquery
.哪里不存在(
（（）=>bolContainerAlias）的查询版本
.Where（（）=>bolAlias.Id==bolContainerAlias.REF.Id）
.选择（x=>x.REF）
);
返回result.List（）；

它没有回答“无法从中确定成员类型”的问题，但它确实解决了这个问题。也许答案可以帮助某人或至少提供一个例子。

在顽固地玩弄了我尝试过的各种方法后，我终于找到了一种可行的方法

            REF bolAlias = null;
            BolContainer bolContainerAlias = null;

            var result = DbSession
                    .QueryOver<REF>(() => bolAlias)
                    .Where(r => r.Element01 == "MB")
                    .WithSubquery
                    .WhereNotExists<BolContainer>(
                        QueryOver.Of<BolContainer>(() => bolContainerAlias)
                        .Where(() => bolAlias.Id == bolContainerAlias.REF.Id)
                        .Select(x => x.REF)
                    );

            return result.List();

REF-bolais=null；
BolContainer bolcontainerarias=null；
var结果=DbSession
.QueryOver（（）=>bolAlias）
.其中（r=>r.Element01==“MB”）
.带subquery
.哪里不存在(
（（）=>bolContainerAlias）的查询版本
.Where（（）=>bolAlias.Id==bolContainerAlias.REF.Id）
.选择（x=>x.REF）
);
返回result.List（）；

它没有回答“无法从中确定成员类型”的问题，但它确实解决了这个问题。也许答案可以帮助某人，或者至少提供一个例子