此SqlParameterCollection与计数无效指数 [英] Invalid index for this SqlParameterCollection with Count

问题描述

我需要访问父类的applicationID属性才能运行NHibernate的查询。运行测试此查询中的NUnit导致它失败这样：BusinessObjects.IntegrationTests.CMSEligibilityInfoRepositoryTest.FetchListByApplicationIDTest：System.IndexOutOfRangeException：无效的指数6此SqlParameterCollection以计数= 6

这样的代码集合试图收购的applicationID前工作的罚款。

最好的我的研究已经拿出了迄今为止的是，它是一个映射的问题

父类：

 公共抽象类MemberEligibilityInfo 
 {
＃地区访问属性
 
私人诠释_managedBenOpID; 
私人诠释_managedApplicationID; 
 
 ///<总结> 
 /// ID 
 ///< /总结> 
公共虚拟UINT ID {搞定;组; } 
 
 ///<总结> 
 /// MemberElig ID将与NHibernate 
 ///<工作; /总结> 
公共虚拟INT ManagedMemberEligID {搞定;组; } 
 
 ///<总结> 
 ///会员ID 
 ///< /总结> 
公共虚拟ULONG MEMBERID {搞定;组; } 
 
 ///<总结> 
 ///会员ID，将与NHibernate 
 ///<工作; /总结> 
公共虚拟长ManagedMemberID {搞定;组; } 
 
 ///<总结> 
 ///保障方案ID 
 ///< /总结> 
公共虚拟UINT BenefitOptionID {搞定;组; } 
 
公共虚拟INT ManagedBenOpID 
 {
 {返回_managedBenOpID; } 
组
 {
如果（_managedBenOpID ==值）
 {
 BenefitOptionID =（UINT）_managedBenOpID; 
的回报; 
} 
 
 _managedBenOpID =价值; 
 BenefitOptionID =（UINT）_managedBenOpID; 
} 
} 
 
 ///<总结> 
 ///保障方案
 ///< /总结> 
公共虚拟字符串UBOI {搞定;组; } 
 
 ///<总结> 
 ///应用程序ID 
 ///< /总结> 
公共虚拟UINT的applicationID {搞定;组; } 
 
公共虚拟INT ManagedApplicationID 
 {
 {返回_managedApplicationID; } 
 
组
 {
如果（_managedApplicationID ==值）
 {
的applicationID =（UINT）_managedApplicationID; 
的回报; 
} 
 
 _managedApplicationID =价值; 
的applicationID =（UINT）_managedApplicationID; 
} 
} 
 ///<总结> 
 ///应用计划年度的日期。 
 ///< /总结> 
公共虚拟的DateTime ApplicationPlanYear {搞定;组; } 
 
 ///<总结> 
 ///生效日期。 
 ///< /总结> 
公共虚拟的DateTime EFFECTIVEDATE {搞定;组; } 
 
 ///<总结> 
 ///终止日期。 
 ///< /总结> 
公共虚拟的DateTime TermDate {搞定;组; } 
 
 #endregion //访问属性
 
＃区域构造
 
 ///<总结> 
 ///默认构造函数。 
 ///< /总结> 
公共MemberEligibilityInfo（）
 {
 ID = 0; 
 MEMBERID = 0; 
 BenefitOptionID = 0; 
 UBOI =的String.Empty; 
的applicationID = 0; 
 ApplicationPlanYear = DateTime.MinValue; 
 EFFECTIVEDATE = DateTime.MinValue; 
 TermDate = DateTime.MinValue; 
} 
 
 #endregion //构造
} 
  

子类：

 公共类CMSEligibilityInfo：MemberEligibilityInfo 
 {
私人BenefitOptionInfo _managedBenefitOptionInfo; 
 
＃地区访问属性
 
 ///<总结> 
 ///优先
 ///< /总结> 
公共虚拟INT优先{搞定;组; } 
 
 ///<总结> 
 ///是主动
 ///< /总结> 
公共虚拟BOOL活跃{搞定;组; } 
 
 
公共虚拟BenefitOptionInfo ManagedBenefitOptionInfo 
 {
 {返回_managedBenefitOptionInfo; } 
组
 {
如果（_managedBenefitOptionInfo ==值）
 {
的回报; 
} 
 
 _managedBenefitOptionInfo =价值; 
 this.ManagedApplicationID = ManagedBenefitOptionInfo.ManagedApplicationID; 
} 
} 
 
公共虚拟的MemberInfo的MemberInfo 
 {
获得; 
组; 
} 
 
 #endregion //访问属性
 
＃区域构造
 
 ///<总结> 
 ///默认的构造函数
 ///< /总结> 
公共CMSEligibilityInfo（）：基地（）
 {
优先级= 0; 
活动= FALSE; 
} 
 
 #endregion //构造
} 
  

儿童类的映射：

 公共类CMSEligibilityInfoMap：ClassMap< CMSEligibilityInfo> 
 {
公共CMSEligibilityInfoMap（）
 {
 //表
表（_ MEI_EligPeriods）; 
 
 //唯一标识符
 ID（X => x.ManagedMemberEligID，MemEligID）
 .GeneratedBy.Identity（）; 
 
 //会员ID，成功地掌握了BIGINT 
地图（X => x.ManagedMemberID，MEMBERID）
 .Not.Nullable（）; 
 
 //保障方案ID 
地图（X => x.ManagedBenOpID，BenOpID）
 .Not.Nullable（）; 
 
 ////生效日期
地图（X => x.EffectiveDate，Eff为）
 .Nullable（）; 
 
 //终止日期
地图（X => x.TermDate，期限）
 .Nullable（）; 
 
 //是合格的记录主动
地图（X => x.Active，活动）
 .Not.Nullable（）; 
 
地图（X => x.Precedence，优先级）
 .Nullable（）; 
 
引用（X => x.ManagedBenefitOptionInfo）
 .Column（BenOpID）
 .Not.LazyLoad（）
 .Cascade.None（）; 
 
 //引用回的MemberInfo 
引用（X => x.MemberInfo）
 .Column（MEMBERID）
 .Not.LazyLoad（）
 .Cascade.None（）; 
} 
} 
  

查询在导致错误的存储库方法：

  ///<总结> 
 ///基于应用程序ID 
 ///<获取资格信息列表; /总结> 
 ///< PARAM NAME =APPID>选定的应用程序ID< /参数> 
 ///<返回>将资格的信息474上的名单; /回报> 
公众的IList< CMSEligibilityInfo> FetchListByApplicationID（UINT？APPID）使用
 {
（VAR会话= SessionFactory.OpenSession（））使用
（VAR交易= session.BeginTransaction（））
 {
 VAR列表= session.CreateCriteria< CMSEligibilityInfo>（）
 .CreateAlias（ManagedBenefitOptionInfo，ManagedBenefitOptionInfo）。新增（Restrictions.Eq（Projections.Property（ManagedBenefitOptionInfo.ManagedApplicationID）的appid））
的.List< CMSEligibilityInfo>（）; 
 
 //提交事务
器transaction.commit（）; 
 
返回列表; 
} 
} 
  

解决方案

匝出，这种来自相同属性的错误的结果的约束两次，或者说，具有相同名称的两个属性被映射。我们删除了父对象（因为它从来没有使用过），并让孩子们的基类，并确保在 BenefitOptionInfo 对象是唯一通过 BenOpID映射。

I need access to the ApplicationID property of the parent class in order to run an Nhibernate query. Running a test for this query in NUnit causes it to fail as such: "BusinessObjects.IntegrationTests.CMSEligibilityInfoRepositoryTest.FetchListByApplicationIDTest: System.IndexOutOfRangeException : Invalid index 6 for this SqlParameterCollection with Count=6."

This collection of code worked fine before trying to acquire the ApplicationID.

The best my research has come up with so far is that it is a mapping issue.

Parent class:

public abstract class MemberEligibilityInfo
{
    #region Access Properties

    private int _managedBenOpID;
    private int _managedApplicationID;

    /// <summary>
    /// ID
    /// </summary>
    public virtual uint ID { get; set; }

    /// <summary>
    /// MemberElig ID that will work with NHibernate
    /// </summary>
    public virtual int ManagedMemberEligID { get; set; }

    /// <summary>
    /// Member ID
    /// </summary>
    public virtual ulong MemberID { get; set; }

    /// <summary>
    /// Member ID that will work with NHibernate
    /// </summary>
    public virtual long ManagedMemberID { get; set; }

    /// <summary>
    /// Benefit Option ID
    /// </summary>
    public virtual uint BenefitOptionID { get; set; }

    public virtual int ManagedBenOpID
    {
        get { return _managedBenOpID; }
        set
        {
            if (_managedBenOpID == value)
            {
                BenefitOptionID = (uint)_managedBenOpID;
                return;
            }

            _managedBenOpID = value;
            BenefitOptionID = (uint)_managedBenOpID;
        }
    }

    /// <summary>
    /// Benefit Option
    /// </summary>
    public virtual string UBOI { get; set; }

    /// <summary>
    /// Application ID
    /// </summary>
    public virtual uint ApplicationID { get; set; }

    public virtual int ManagedApplicationID
    {
        get { return _managedApplicationID; }

        set
        {
            if (_managedApplicationID == value)
            {
                ApplicationID = (uint)_managedApplicationID;
                return;
            }

            _managedApplicationID = value;
            ApplicationID = (uint)_managedApplicationID;
        }
    }
    /// <summary>
    /// Application Plan Year date.
    /// </summary>
    public virtual DateTime ApplicationPlanYear { get; set; }

    /// <summary>
    /// Effective Date.
    /// </summary>
    public virtual DateTime EffectiveDate { get; set; }

    /// <summary>
    /// Termination Date.
    /// </summary>
    public virtual DateTime TermDate { get; set; }

    #endregion // Access Properties

    #region Constructors

    /// <summary>
    /// Default constructor.
    /// </summary>
    public MemberEligibilityInfo()
    {
        ID = 0;
        MemberID = 0;
        BenefitOptionID = 0;
        UBOI = string.Empty;
        ApplicationID = 0;
        ApplicationPlanYear = DateTime.MinValue;
        EffectiveDate = DateTime.MinValue;
        TermDate = DateTime.MinValue;
    }

    #endregion // Constructors
}

Child class:

public class CMSEligibilityInfo : MemberEligibilityInfo
{
    private BenefitOptionInfo _managedBenefitOptionInfo;

    #region Access Properties

    /// <summary>
    /// Precedence
    /// </summary>
    public virtual int Precedence { get; set; }

    /// <summary>
    /// Is Active
    /// </summary>
    public virtual bool Active { get; set; }


    public virtual BenefitOptionInfo ManagedBenefitOptionInfo
    {
        get { return _managedBenefitOptionInfo; }
        set
        {
            if (_managedBenefitOptionInfo == value)
            {
                return;
            }

            _managedBenefitOptionInfo = value;
            this.ManagedApplicationID = ManagedBenefitOptionInfo.ManagedApplicationID;
        }
    }

    public virtual MemberInfo MemberInfo
    {
        get;
        set;
    }

    #endregion // Access Properties

    #region Constructors

    /// <summary>
    /// Default Constructor
    /// </summary>
    public CMSEligibilityInfo() : base()
    {
        Precedence = 0;
        Active = false;
    }

    #endregion // Constructors
}

Child class mapping:

public class CMSEligibilityInfoMap : ClassMap<CMSEligibilityInfo>
{
    public CMSEligibilityInfoMap()
    {
        // Table
        Table("_MEI_EligPeriods");

        // Unique Identifier
        Id(x => x.ManagedMemberEligID, "MemEligID")
            .GeneratedBy.Identity();

        // Member ID, Managed to handle the bigint
        Map(x => x.ManagedMemberID, "MemberID")
            .Not.Nullable();

        // Benefit Option ID
        Map(x => x.ManagedBenOpID, "BenOpID")
            .Not.Nullable();

        //// Effective Date
        Map(x => x.EffectiveDate, "Eff")
            .Nullable();

        // Termination Date
        Map(x => x.TermDate, "Term")
            .Nullable();

        // Is the eligibility record active
        Map(x => x.Active, "Active")
            .Not.Nullable();

        Map(x => x.Precedence, "Precedence")
            .Nullable();

        References(x => x.ManagedBenefitOptionInfo)
            .Column("BenOpID")
            .Not.LazyLoad()
            .Cascade.None();

        // References back to MemberInfo
        References(x => x.MemberInfo)
            .Column("MemberID")
            .Not.LazyLoad()
            .Cascade.None();
    }
}

Query in a repository method that is causing the error:

    /// <summary>
    /// Fetch a list of eligibility info based on Application ID
    /// </summary>
    /// <param name="appID">Selected Application ID</param>
    /// <returns>A list of eligibility information</returns>
    public IList<CMSEligibilityInfo> FetchListByApplicationID(uint? appID)
    {
        using (var session = SessionFactory.OpenSession())
        using (var transaction = session.BeginTransaction())
        {
            var list = session.CreateCriteria<CMSEligibilityInfo>()
                .CreateAlias("ManagedBenefitOptionInfo", "ManagedBenefitOptionInfo")                 .Add(Restrictions.Eq(Projections.Property("ManagedBenefitOptionInfo.ManagedApplicationID"), appID))
                .List<CMSEligibilityInfo>();

            // Commit the transaction
            transaction.Commit();

            return list;
        }
    }

解决方案

Turns out, this kind of error results from the same property being bound twice, or rather, two properties with the same name were mapped. We removed the parent object (as it was never used) and made the children base classes and made sure the BenefitOptionInfo object was the only thing mapped through BenOpID.

这篇关于此SqlParameterCollection与计数无效指数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！