Question

我有一个懒惰实体的代理，它通过加载子实体在会话中创建。父实体上的后续提取仅返回NH代理。我需要实际的实例来检查类型（实体已经加入了子类）。我必须遗漏一些东西，但我找不到办法做到这一点。 Session.Refresh（代理）似乎没有帮助，也没有我尝试过的任何HQL风格。

有人可以帮忙吗？

Answer 1

在我看来，而不是解决这个问题，你应该重新考虑你的设计。您是否绝对肯定，在这种情况下您不能使用多态 - 要么直接让实体负责您尝试执行的操作，要么使用访问者模式。我几次遇到这个问题并且总是决定改变设计 - 它产生了更清晰的代码。我建议你这样做，除非你完全确定依靠类型是最好的解决方案。

问题

为了举例说明与现实世界至少有一些相似之处，让我们假设您有以下实体：

public abstract class Operation
{
    public virtual DateTime PerformedOn { get; set; }
    public virtual double Ammount { get; set; }
}

public class OutgoingTransfer : Operation
{
    public virtual string TargetAccount { get; set; }
}

public class AtmWithdrawal : Operation
{
    public virtual string AtmAddress { get; set; }
}

它自然只是更大型号的一小部分。现在你遇到了一个问题：对于每种具体类型的操作，都有不同的显示方式：

private static void PrintOperation(Operation operation)
{
    Console.WriteLine("{0} - {1}", operation.PerformedOn,
                      operation.Ammount);
}

private static void PrintOperation(OutgoingTransfer operation)
{
    Console.WriteLine("{0}: {1}, target account: {2}",
                      operation.PerformedOn, operation.Ammount,
                      operation.TargetAccount);
}

private static void PrintOperation(AtmWithdrawal operation)
{
    Console.WriteLine("{0}: {1}, atm's address: {2}",
                      operation.PerformedOn, operation.Ammount,
                      operation.AtmAddress);
}

简单的重载方法将在简单的情况下工作：

var transfer = new OutgoingTransfer
               {
                   Ammount = -1000,
                   PerformedOn = DateTime.Now.Date,
                   TargetAccount = "123123123"
               };

var withdrawal = new AtmWithdrawal
                 {
                     Ammount = -1000,
                     PerformedOn = DateTime.Now.Date,
                     AtmAddress = "Some address"
                 };

// works as intended
PrintOperation(transfer);
PrintOperation(withdrawal);

不幸的是，重载方法在编译时被绑定，因此只要引入数组/列表/任何操作，就会调用泛型（操作操作）重载。

Operation[] operations = { transfer, withdrawal };
foreach (var operation in operations)
{
    PrintOperation(operation);
}

这个问题有两种解决方案，两者都有缺点。您可以在“操作”中引入抽象/虚拟方法，以将信息打印到选定的流。但这会将UI问题混合到您的模型中，因此您无法接受（我将告诉您如何在一瞬间改进此解决方案以满足您的期望）。

您还可以通过以下形式创建大量ifs：

if(operation is (ConcreteType))
   PrintOperation((ConcreteType)operation);

此解决方案很丑陋且容易出错。每次添加/更改/删除操作类型时，您都必须遍历您使用这些黑客的每个地方并进行修改。如果你错过了一个地方，你可能只能捕获那个运行时 - 没有严格的编译时检查一些错误（比如缺少一个子类型）。

此外，只要您引入任何类型的代理，此解决方案就会失败。

代理如何工作

下面的代码是非常简单的代理（在此实现中它与装饰器模式相同 - 但这些模式通常不一样。需要一些额外的代码来区分这两种模式。）

public class OperationProxy : Operation
{
    private readonly Operation m_innerOperation;

    public OperationProxy(Operation innerOperation)
    {
        if (innerOperation == null)
            throw new ArgumentNullException("innerOperation");
        m_innerOperation = innerOperation;
    }


    public override double Ammount
    {
        get { return m_innerOperation.Ammount; }
        set { m_innerOperation.Ammount = value; }
    }

    public override DateTime PerformedOn
    {
        get { return m_innerOperation.PerformedOn; }
        set { m_innerOperation.PerformedOn = value; }
    }
}

如您所见 - 整个层次结构只有一个代理类。为什么？因为您应该以不依赖于具体类型的方式编写代码 - 仅限于提供的抽象。这个代理可以及时推迟实体加载 - 也许你根本不会使用它？也许你只会使用1000个实体中的2个？为什么要加载它们呢？

所以NHibernate使用上面的代理（虽然更复杂）来推迟实体加载。它可以为每个子类型创建1个代理，但它会破坏延迟加载的整个目的。如果你仔细观察NHibernate如何存储你将看到的子类，那么为了确定实体是什么类型，你必须加载它。所以不可能有具体的代理 - 你只能拥有最抽象的OperationProxy。

尽管这很丑陋，但这是一个解决方案。现在，当您为问题引入代理时 - 它已不再有效。因此，我们只使用多态方法，因为将UI责任混合到模型中，这是不可接受的。我们来解决这个问题。

依赖性反转和访问者模式

首先，让我们看一下虚拟方法的解决方案（仅添加代码）：

public abstract class Operation
{
    public abstract void PrintInformation();
}

public class OutgoingTransfer : Operation
{
    public override void PrintInformation()
    {
        Console.WriteLine("{0}: {1}, target account: {2}",
                      PerformedOn, Ammount, TargetAccount);
    }
}

public class AtmWithdrawal : Operation
{
    public override void PrintInformation()
    {
        Console.WriteLine("{0}: {1}, atm's address: {2}",
                          PerformedOn, Ammount, AtmAddress);
    }
}

public class OperationProxy : Operation
{
    public override void PrintInformation()
    {
        m_innerOperation.PrintInformation();
    }
}

现在，当你致电：

Operation[] operations = { transfer, withdrawal, proxy };
foreach (var operation in operations)
{
    operation.PrintInformation();
}

所有都是魅力。

为了在模型中删除这个UI依赖项，让我们创建一个接口：

public interface IOperationVisitor
{
    void Visit(AtmWithdrawal operation);
    void Visit(OutgoingTransfer operation);
}

让我们修改模型以依赖于这个界面：

现在创建一个实现 - ConsoleOutputOperationVisitor（我删除了PrintInformation方法）：

public abstract class Operation
{
    public abstract void Accept(IOperationVisitor visitor);
}

public class OutgoingTransfer : Operation
{
    public override void Accept(IOperationVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class AtmWithdrawal : Operation
{
    public override void Accept(IOperationVisitor visitor)
    {
        visitor.Visit(this);
    }
}

public class OperationProxy : Operation
{
    public override void Accept(IOperationVisitor visitor)
    {
        m_innerOperation.Accept(visitor);
    }
}

这里发生了什么？当您在操作上调用Accept并传递访问者时，将调用accept的实现，其中将调用Visit方法的适当重载（编译器可以确定“this”的类型）。因此，您将虚拟方法和重载的“强大”结合起来，以获得适当的方法。正如您所看到的 - 现在是UI引用，模型仅取决于接口，可以包含在模型层中。

现在，为了使这个工作，接口的实现：

 public class ConsoleOutputOperationVisitor : IOperationVisitor
 {
    #region IOperationVisitor Members
    public void Visit(AtmWithdrawal operation)
    {
        Console.WriteLine("{0}: {1}, atm's address: {2}",
                          operation.PerformedOn, operation.Ammount,
                          operation.AtmAddress);
    }

    public void Visit(OutgoingTransfer operation)
    {
        Console.WriteLine("{0}: {1}, target account: {2}",
                          operation.PerformedOn, operation.Ammount,
                          operation.TargetAccount);
    }

    #endregion
}

代码：

Operation[] operations = { transfer, withdrawal, proxy };
foreach (var operation in operations)
{
    operation.Accept(visitor);
}

我很清楚这不是一个完美的解决方案。在添加新类型时，您仍然需要修改界面和访问者。但是你得到编译时检查，永远不会错过任何东西。使用这种方法真正难以实现的一件事是获得可插拔的子类型 - 但我不相信这是一个有效的场景。您还必须修改此模式以满足您在具体方案中的需求，但我会留给您。

Answer 2

要强制从数据库中提取代理，您可以使用NHibernateUtil.Initialize(proxy)方法，或访问代理的方法/属性。

var foo = session.Get<Foo>(id);
NHibernateUtil.Initialize(foo.Bar);

要检查对象是否已初始化，您可以使用NHibernateUtil.IsInitialized(proxy)方法。

<强>更新

要从会话缓存中删除对象，请使用Session.Evict(obj)方法。

session.Evict(myEntity);

有关管理会话缓存的Evict和其他方法的信息可以在NHibernate docs的chapter 14.5中找到。

Answer 3

禁用延迟加载将强制返回实际实例而不是NHibernate代理。

例如..

mapping.Not.LazyLoad（）;

或

<class name="OrderLine" table="OrderLine" lazy="false" >

Answer 4

由于代理是从实体类派生的，因此您可以只检查entity.GetType（）。BaseType以获取您定义的类型。

强制延迟实体加载实例

4 个答案:

问题

代理如何工作

依赖性反转和访问者模式