Lazy proxy initialization fails after entity detachment in NHibernate

Guaranteed Failure Behavior

Accessing an uninitialized lazy proxy on a detached entity in NHibernate always throws LazyInitializationException (or its NHibernate-specific equivalent NHibernate.LazyInitializationException). This is the defined contract across all supported proxy factories (ByteCode.LinFu, ByteCode.Castle, and the default ByteCode.Castle in modern versions). No version returns null or default values silently—custom interceptors can wrap or replace the exception, but the base behavior is an exception.

Second-Level Cache Does Not Change the Outcome

Enabling the second-level cache for the associated entity type does not allow a detached proxy to initialize. The cache stores entity data, not hydrated proxy instances. Proxy initialization requires an active ISession to:

1. Resolve the proxy's entity key
2. Check the cache for the associated entity
3. Materialize the instance and wire it into the proxy

Without a session, the proxy has no mechanism to reach the cache. The cache may satisfy the subsequent SELECT if a session is open, but it cannot substitute for the session itself.

Supported Patterns to Materialize Before Detachment

Use one of these approaches inside the session scope before the entity becomes detached:

1. NHibernateUtil.Initialize(proxy)

var order = session.Get<Order>(id);
NHibernateUtil.Initialize(order.Customer); // forces load
session.Close();
// order.Customer is now safe to access

2. Fetch in Query (Not Eager Fetching Globally)

var order = session.Query<Order>()
    .Fetch(o => o.Customer)
    .Single(o => o.Id == id);

This loads the association in the same query without marking the mapping as eager.

3. session.Load<T>(id) + Immediate Access

var customer = session.Load<Customer>(order.CustomerId);
var _ = customer.Name; // touches the proxy
session.Close();

Load returns a proxy; accessing any property initializes it within the open session.

One Diagnostic Detail

Are you using stateless sessions (ISessionFactory.OpenStatelessSession()) anywhere in the request pipeline? Stateless sessions do not support lazy loading at all and will throw immediately even before detachment.