Cascade.All() 没有删除级联，为什么？

Question

我需要删除映射到 SlotTransceivers 和端口上的 EndPoint 成员。过去，EndPoint 没有自己的表，这个时钟类是 SlotTransceiver 和 Port 的一部分。

问题是，因为创建连接，rhitch 引用了端点，所以我必须为端点创建自己的表。还有更多问题，但现在一切正常，除了 EndPoints 行的级联删除之外。

我相信我需要为 EndPoint 和 Connectioniions 编写重写类，或者更改端口或 SlotTransceivers 的此类。

你能给我任何指示吗？我不是原始类的作者，而且我对 Hibernate 也很菜鸟。

我认为Cascade.All()意味着当我删除任何SlotTransceiver或Port时，它会自动删除引用的EndPoint。

是否存在新表连接可能引用的问题？

有一些类：

public class EndPoint : Entity
    {
        private int _Position;
        private VLAN _VLAN;
        private string _Description;
        private Connection _Connection;

        [Min(0)]
        public virtual int Position
        {
            get
            {
                return _Position;
            }
            set
            {
                _Position = value;
            }
        }

        [NotNull]
        public virtual VLAN VLAN
        {
            get
            {
                return _VLAN;
            }
            set
            {
                _VLAN = value;
            }
        }

        [Length(500)]
        public virtual string Description
        {
            get
            {
                return _Description;
            }
            set
            {
                _Description = value;
            }
        }
    }

    public class SlotTransceiver : Entity
    {
        private EndPoint _EndPoint;
        private SlotTransceiverItem _InType;
        private Slot _Slot;

        [NotNull]
        public virtual EndPoint EndPoint
        {
            get
            {
                return _EndPoint;
            }
            set
            {
                _EndPoint = value;
            }
        }

        [NotNull]
        public virtual SlotTransceiverItem InType
        {
            get
            {
                return _InType;
            }
            set
            {
                _InType = value;
            }
        }

        [NotNull]
        public virtual Slot Slot
        {
            get
            {
                return _Slot;
            }
        }
    }

    public class Port : Item
    { // Item is inherited from Entity
        private EndPoint _EndPoint;
        [NotNull]
        public virtual EndPoint EndPoint
        {
            get
            {
                return _EndPoint;
            }
            set
            {
                _EndPoint = value;
            }
        }
    }

    public class Connection : Entity
    {
        private EndPoint _EndPointIn;
        private EndPoint _EndPointOut;

        [NotNull]
        public virtual EndPoint EndPointIn
        {

            get
            {
                return _EndPointIn;
            }
            set
            {
                _EndPointIn = value;
            }
        }
        [NotNull]
        public virtual EndPoint EndPointOut
        {

            get
            {
                return _EndPointOut;
            }
            set
            {
                _EndPointOut = value;
            }
        }

    }

它们是一些特殊的映射：

public class SlotTransceiverOverride : IAutoMappingOverride<SlotTransceiver>
    {
        public void Override(FluentNHibernate.Automapping.AutoMapping<SlotTransceiver> mapping)
        {
            // in past EndPoint columns are in SlotTrancievers resp. in Ports tables
            /*
            mapping.Component(x => x.EndPoint, m =>
            {
                m.Map(x => x.Position);
                m.Map(x => x.Description);
                m.References(x => x.VLAN).ForeignKey("SlotTransceiversEndPointVLANFkConstraint");
            });*/
            mapping.References(x => x.InType).Not.LazyLoad();
            mapping.References(x => x.EndPoint).Not.LazyLoad().Cascade.All();
        }
    }

        public void Override(FluentNHibernate.Automapping.AutoMapping<Port> mapping)
        {
            // in past EndPoint columns are in SlotTrancievers resp. in Ports tables
        /*
            mapping.Component(x => x.EndPoint, m =>
            {

                m.Map(x => x.Position);
                m.Map(x => x.Description);
                m.References(x => x.VLAN).ForeignKey("PortsEndPointVLANFkConstraint");
            });
                 */
            mapping.IgnoreProperty(x => x.AbsoluteIndex);
            mapping.References(x => x.EndPoint).Not.LazyLoad();
            mapping.References(x => x.EndPoint).Cascade.All();
        }

Answer 1

将 NH 属性和一些 FNH 自动映射内容结合起来看起来非常可怕。我根本不明白，但 IMO 经典的 ClassMap 更加透明。你必须用更多的击键来支付，但你的头疼得更少:)。

public class EndPointMap : ClassMap<EndPoint>
{
    public EndPointMap()
    {
        Id(x => x.Id);
        Map(x => x.Position);
        Map(x => x.Description);
    }
}

public class ConnectionMap : ClassMap<Connection>
{
    public ConnectionMap()
    {
        Id(x => x.Id);

        References(x => x.EndPointIn)
            .Cascade.All()
            .Not.LazyLoad();
        References(x => x.EndPointOut)
            .Cascade.All()
            .Not.LazyLoad();
    }
}

此代码还从数据库中删除连接和端点：

using (var session = OpenSession())
{
    var connection = session.Get<Connection>(connectionId);
    session.Delete(connection);
    session.Flush();
}