C# NHibernate对象id返回的值不正确

我正在使用NHibernate，这不是家庭作业

假设我从数据库中检索出了一个类型为“代码>教师/代码>（假设XYZ大学工程系）的对象。它有5个子对象与之关联，类型为

Department

，根据数据库表，应该包含ID2、4、5、8和9

我的第一个问题是，我看到关联的对象总是将

ID

设置为

0

教员ID正在正确加载

我的第二个问题是，我需要将它们加载到组合框中，并希望选择ID为5的对象

如何解决ID设置为0的问题？我不知道为什么会这样

如何选择ID==5的对象

Faculty.hbm.xml b_系 编辑： 理工学院

---

这就是我的全部。一个极其疯狂的猜测。您是否可以尝试在不使用相等比较器和

Equals

实现的情况下运行代码，看看这是否有帮助，因此使用以下实现：

public abstract class BusinessObject<T> : IBusinessObject where T : BusinessObject<T>
{
    public int ID { get; set; }
}

---

看看效果如何。

关于

组合框问题，我将采取以下措施：

var faculty = GetFaculty();
int selectedID = 5;

int selectedIndex = -1;

comboBox1.BeginUpdate();

comboBox1.Items.Clear();

foreach (var department in faculty.DepartmentItems)
{
    int index = comboBox1.Items.Add(department);

    if (department.ID == selectedID)
        selectedIndex = index;
}

if (selectedIndex != -1)
    comboBox1.SelectedIndex = selectedIndex;

comboBox1.EndUpdate();

我遇到了一个类似的问题，在执行选择后，id返回为0。
我使用的是Fluent Nhibernate，在持久类和子类中都声明了id字段。
只需从子类中删除id。
您可能应该为combobox填充提出一个单独的问题。能否为该表提供某种模式转储，以及您的NHibernate映射？这将使此问题更易于调试。教员ID加载是否正确？是的，教员ID加载是否正确。能否提供实体映射到的类的代码？至少Id的定义和任何使用该Id的代码都会有所帮助。我已经解决了我的问题。在“BusinessObject.cs”中，我忘了将修饰符virtual添加到属性ID中。我一添加关键字virtual，它就可以正常工作了。因为NHibernate没有给出任何警告，所以我一直忽略它。这很奇怪，因为当你加载一个带有非虚拟属性的对象时，NHibernate会抛出。很高兴你找到了。如果我改变答案，我会得到赏金吗？开玩笑的：P.现在，为了得到50个悬赏点，你能解决我的组合框相关问题吗？也许我不理解这个问题，但上面的方法是我会采取的方法。如果这不是你要找的，你能扩大问题吗？这不起作用！我自己也在试。但不管怎样都指向你。是的，这种情况有时会发生。我已经更新了答案，改为使用
SelectedIndex
。顺便说一句，我认为你还没有颁发赏金。我相信您必须手动完成这项工作。请看：我认为这与您的平等实现有关。试一下你的另一个问题：）。
CREATE TABLE [dbo].[b_Faculty](
    [ID] [int] IDENTITY(1,1) NOT NULL,
    [Code] [varchar](50) NOT NULL,
    [Name] [varchar](50) NOT NULL,
    [IsActive] [bit] NOT NULL,
 CONSTRAINT [PK_b_Faculty] PRIMARY KEY CLUSTERED 
(
    [ID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

CREATE TABLE [dbo].[b_Department](
    [ID] [int] IDENTITY(1,1) NOT NULL,
    [FacultyID] [int] NOT NULL,
    [Code] [varchar](50) NOT NULL,
    [Name] [varchar](50) NOT NULL,
    [IsActive] [bit] NOT NULL,
 CONSTRAINT [PK_b_Department] PRIMARY KEY CLUSTERED 
(
    [ID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

public class Faculty : BusinessObject<Faculty>
    {
        public virtual string Code { get; set; }
        public virtual string Name { get; set; }
        public virtual bool IsActive { get; set; }

        public virtual IEnumerable<Department> DepartmentItems { get; set; }
    }

public class Department : BusinessObject<Department>
    {
        public virtual string Code { get; set; }
        public virtual string Name { get; set; }
        public virtual bool IsActive { get; set; }

        public virtual Faculty Faculty { get; set; }

        public virtual IEnumerable<Teacher> TeacherItems { get; set; }
    }

public abstract class BusinessObject<T> : IBusinessObject where T : BusinessObject<T>
    {
        public int ID { get; set; }

        public static bool operator ==(BusinessObject<T> item1, BusinessObject<T> item2)
        {
            bool same = false;

            if (!object.ReferenceEquals(item1, null) && !object.ReferenceEquals(item2, null))
            {
                if (item1.ID == item2.ID)
                {
                    same = true;
                }
            }

            else
            {
                if (object.ReferenceEquals(item1, null) && object.ReferenceEquals(item2, null))
                {
                    same = true;
                }
            }

            return same;
        }

        public static bool operator !=(BusinessObject<T> item1, BusinessObject<T> item2)
        {
            return !(item1 == item2);
        }

        public override bool Equals(object obj)
        {
            //If "obj" is null, they are obviously not equal.
            if (obj == null)
            {
                return false;
            }

            //If the objects are the same instance, they must be equal.
            if (Object.ReferenceEquals(this, obj))
            {
                return true;
            }

            //If the objects are not the same type, they cannot be equal.
            if (this.GetType() != obj.GetType())
            {
                return false;
            }

            T objCustomer = (T)obj;

            if (this.ID > 0 && objCustomer.ID > 0)
            {
                if (this.ID.Equals(objCustomer.ID))
                {
                    return true;
                }

            }
            return false;
        }

        public override int GetHashCode()
        {
            if (this.ID <= 0)
            {
                return base.GetHashCode();
            }
            else
            {
                return ID.GetHashCode();
            }
        }
    }

public class FacultyRepository : Repository<Faculty>
    {
    }

public class DepartmentRepository : Repository<Department>
    {
    }

public class Repository<T> : IRepository<T>
    {
        ISession _session;

        public Repository() 
        {
            _session = SessionFactory.GetOpenSession();
        }

        public T Get(object id)
        {
            T obj = default(T);

            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();
                    obj = (T)_session.Get<T>(id);
                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();
                _session.Clear();

                throw ex;
            }

            return obj;
        }

        public IEnumerable<T> Get(string fieldName, object fieldValue)
        {
            IEnumerable<T> list = null;

            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();
                    list = (IEnumerable<T>)_session.CreateCriteria(typeof(T))
                        .Add(new NHibernate.Expression.EqExpression(fieldName, fieldValue))
                        .List<T>();

                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();
                _session.Clear();

                throw ex;
            }

            return list;
        }

        public IEnumerable<T> Get()
        {
            IEnumerable<T> list = null;

            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();
                    list = (IEnumerable<T>)_session.CreateCriteria(typeof(T)).List<T>();
                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();
                _session.Clear();

                throw ex;
            }

            return list;
        }

        public void SaveOrUpdate(T obj)
        {
            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();
                    _session.SaveOrUpdateCopy(obj);
                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();
                _session.Clear();

                throw ex;
            }
        }

        public void SaveOrUpdate(IEnumerable<T> objs)
        {
            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();

                    foreach (T obj in objs)
                    {
                        _session.SaveOrUpdate(obj);
                    }

                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();
                _session.Clear();

                throw ex;
            }
        }

        public void Delete(T obj)
        {
            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();
                    _session.Delete(obj);
                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();                
                _session.Clear();

                throw ex;
            }
        }

        public void Delete(IEnumerable<T> objs)
        {
            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();

                    foreach (T obj in objs)
                    {
                        _session.Delete(obj);
                    }

                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();
                _session.Clear();

                throw ex;
            }
        }

        public void DeleteAll()
        {
            try
            {
                if (!_session.Transaction.IsActive)
                {
                    _session.BeginTransaction();

                    DetachedCriteria criterion = DetachedCriteria.For<T>();
                    IList<T> list = criterion.GetExecutableCriteria(_session).List<T>();

                    foreach (T item in list)
                    {
                        _session.Delete(item);
                    }

                    _session.Transaction.Commit();
                    _session.Flush();
                }
                else
                {
                    throw new Exception(CustomErrorMessage.TransactionAlreadyInProgress);
                }
            }
            catch (Exception ex)
            {
                _session.Transaction.Rollback();

                throw ex;
            }
        }

        public void Dispose()
        {
            if (_session != null)
            {
                _session.Clear();
                _session.Close();
                _session = null;
            }
        }
    }

public class SessionFactory
    {
        private static ISessionFactory _sessionFactory = null;
        private SessionFactory(){}

        static SessionFactory()
        {
            if (_sessionFactory == null)
            {
                Configuration configuration = new Configuration();
                configuration.Configure();
                _sessionFactory = configuration.BuildSessionFactory();
            }
        }

        public static ISession GetOpenSession()
        {
            return _sessionFactory.OpenSession();
        }
    }

public abstract class BusinessObject<T> : IBusinessObject where T : BusinessObject<T>
{
    public int ID { get; set; }
}

public abstract class BusinessObject<T> : IBusinessObject where T : BusinessObject<T>
{
    public int ID { get; private set; }
}

var faculty = GetFaculty();
int selectedID = 5;

int selectedIndex = -1;

comboBox1.BeginUpdate();

comboBox1.Items.Clear();

foreach (var department in faculty.DepartmentItems)
{
    int index = comboBox1.Items.Add(department);

    if (department.ID == selectedID)
        selectedIndex = index;
}

if (selectedIndex != -1)
    comboBox1.SelectedIndex = selectedIndex;

comboBox1.EndUpdate();