Question

Hi i have setup my SessionFactory to cache entities and queries:

private ISessionFactory CreateSessionFactory()
{
    var cfg = new Configuration().Proxy(
        properties => properties.ProxyFactoryFactory<DefaultProxyFactoryFactory>()).DataBaseIntegration(
            properties =>
            {
                properties.Driver<SqlClientDriver>();
                properties.ConnectionStringName = this.namedConnection;
                properties.Dialect<MsSql2005Dialect>();
            }).AddAssembly(this.resourceAssembly).Cache(
                properties =>
                {
                    properties.UseQueryCache = true;
                    properties.Provider<SysCacheProvider>();
                    properties.DefaultExpiration = 3600;
                });
    cfg.AddMapping(this.DomainMapping);

    new SchemaUpdate(cfg).Execute(true, true);
    return cfg.BuildSessionFactory();
}

This is my user mapping

public class UserMapping : EntityMapping<Guid, User>
{
    public UserMapping()
    {
        this.Table("USERS");
        this.Property(
            x => x.CorpId,
            mapper => mapper.Column(
                c =>
                {
                    c.Name("CorporateId");
                    c.UniqueKey("UKUserCorporateId");
                    c.NotNullable(true);
                }));
        this.Set(
            x => x.Desks,
            mapper =>
            {
                mapper.Table("DESKS2USERS");
                mapper.Key(km => km.Column("UserId"));
                mapper.Inverse(false);
                mapper.Cascade(Cascade.All | Cascade.DeleteOrphans | Cascade.Remove);
            },
            rel => rel.ManyToMany(mapper => mapper.Column("DeskId")));
        this.Cache(
            mapper =>
            {
                mapper.Usage(CacheUsage.ReadWrite);
                mapper.Include(CacheInclude.All);
            });
    }
}

What I want to do is get a user or query some users and add information to the domain object and cache the updated object.

public class User : Entity<Guid>, IUser
{
    public virtual string CorpId { get; set; }

    public virtual ISet<Desk> Desks { get; set; }

    public virtual MailAddress EmailAddress { get; set; }

    public virtual string Name
    {
        get
        {
            return string.Format(CultureInfo.CurrentCulture, "{0}, {1}", this.SurName, this.GivenName);
        }
    }

    public virtual string GivenName { get; set; }

    public virtual string SurName { get; set; }
}

something like this:

var users = this.session.Query<User>().Cacheable().ToList();

if (users.Any(user => user.EmailAddress == null))
{
    UserEditor.UpdateThroughActiveDirectoryData(users);
}

return this.View(new UserViewModel { Users = users.OrderBy(entity => entity.Name) });

or this:

var user = this.session.Get<User>(id);

if (user.EmailAddress == null)
{
    UserEditor.UpdateThroughActiveDirectoryData(user);
}

return this.View(user);

The UpdateThroughActiveDirectory methods work but are executed everytime i get data from the cache, the updated entities do not keep the additional data. Is there a way to also store this data in nhibernates 2nd level cache?

Answer 1

NHibernate doesn’t cache entire entity in second level cache. It caches only the state / data from the mapped properties. You can read more about it here: http://ayende.com/blog/3112/nhibernate-and-the-second-level-cache-tips

There’s an interesting discussion in comments of that post that explains this a little further:

Frans Bouma: Objects need to serializable, are they not? As we’re talking about multiple appdomains. I wonder what’s more
efficient: relying on the cache of the db server or transporting
objects back/forth using serialization layers.

Ayende Rahien: No, they don’t need that. This is because NHibernate doesn’t save the entity in the cache. Doing so would open
you to race conditions. NHibernate saves the entity data alone,
which is usually composed of primitive data (that is what the DB can
store, after all). In general, it is more efficient to hit a cache
server, because those are very easily scalable to high degrees, and
there is no I/O involved.