Question

I have been trying to create a calculated property in my persistence layer by follow
Hendry Luk’s solution for calculated properties.

I am able to select the values from the DB using a linq query:

var result  = from parcel in Repository.Query();

When I try to do a where on the selected result, I get a could not resolve property error.

Here is what my code looks like.

My Model:

 namespace ConsoleApplication14
    {
        using System;
        using System.Collections.Generic;
        using System.Linq;
        using System.Linq.Expressions;
        using System.Text;

        public class Common1 : ICommon
        {
            public virtual int Id { get; set; }

            public virtual string Name { get; set; }

            //public static readonly Expression<Func<Common1, string>> CalculatedDisplayExpression = x => ("Common 1 Display: " + x.Id + " - " + x.Name);
            public static readonly Expression<Func<Common1, string>> CalculatedDisplayExpression = x => (x.Id + "");

            private static readonly Func<Common1, string> CalculateDisplay = CalculatedDisplayExpression.Compile();

            public virtual string Display { get { return CalculateDisplay(this); } }
        }
    }

My Interface the model implementing:

namespace ConsoleApplication14
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;`enter code here`

    public interface ICommon
    {
        int Id { get; set; }
        string Name { get; set; }
        string Display { get;  }
    }
}

Model’s mapping

namespace ConsoleApplication14
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using NHibernate.Mapping.ByCode;
    using NHibernate.Mapping.ByCode.Conformist;

    public class Common1Map : ClassMapping<Common1>
    {
        public Common1Map()
        {
            Id(x => x.Id, map => map.Generator(Generators.Native));
            Property(x => x.Name);
        }
    }
}



namespace ConsoleApplication14
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.Text;
    using NHibernate.Hql.Ast;
    using NHibernate.Linq;
    using NHibernate.Linq.Functions;
    using NHibernate.Linq.Visitors;

    public class CalculatedPropertyGenerator<T, TResult> : BaseHqlGeneratorForProperty
    {
        public static void Register(ILinqToHqlGeneratorsRegistry registry, Expression<Func<T, TResult>> property, Expression<Func<T, TResult>> calculationExp)
        {
            registry.RegisterGenerator(ReflectionHelper.GetProperty(property), new CalculatedPropertyGenerator<T, TResult> { _calculationExp = calculationExp });
        }

        private CalculatedPropertyGenerator() { }

        private Expression<Func<T, TResult>> _calculationExp;

        public override HqlTreeNode BuildHql(MemberInfo member, Expression expression, HqlTreeBuilder treeBuilder, IHqlExpressionVisitor visitor)
        {
            return visitor.Visit(_calculationExp);
        }
    }
}


namespace ConsoleApplication14
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using NHibernate;
    using NHibernate.Cfg;
    using NHibernate.Cfg.MappingSchema;
    using NHibernate.Dialect;
    using NHibernate.Driver;
    using NHibernate.Tool.hbm2ddl;
    using NHibernate.Mapping.ByCode;
    using NHibernate.Mapping;
    using Iesi.Collections.Generic;
    using System.Reflection;
    using NHibernate.Linq.Functions;
    using NHibernate.Linq;

    public class SessionProvider
    {
        private static ISessionFactory sessionFactory;

        public static SessionProvider Instance { get; private set; }
        //DefaultLinqToHqlGeneratorsRegistry registry = new DefaultLinqToHqlGeneratorsRegistry();

        ILinqToHqlGeneratorsRegistry registry = new DefaultLinqToHqlGeneratorsRegistry();

        static SessionProvider()
        {
            var provider = new SessionProvider();
            provider.Initialize();
            Instance = provider;
        }

        private SessionProvider() { }

        private void Initialize()
        {
            const string connString = "server=(local)\\mssql2008;database=Common;integrated security=sspi";

            Configuration configuration = new Configuration();
            configuration
                .DataBaseIntegration(db =>
                {
                    db.ConnectionString = connString;
                    db.Dialect<MsSql2008Dialect>();
                    db.Driver<SqlClientDriver>();
                    db.LogSqlInConsole = true;
                    db.IsolationLevel = System.Data.IsolationLevel.ReadCommitted;
                })
                .AddDeserializedMapping(GetMappings(), null);


            CalculatedPropertyGenerator<Common1, string>.Register(registry, x => x.Display, Common1.CalculatedDisplayExpression);

//            registry.RegisterGenerator(ReflectionHelper.GetProperty<Common1, string>(x => x.Display), new CalculatedPropertyGenerator());




            var exporter = new SchemaExport(configuration);
            exporter.Execute(true, true, false); 
            sessionFactory = configuration.BuildSessionFactory();
        }

        private HbmMapping GetMappings()
        {
            ModelMapper mapper = new ModelMapper();
            mapper.AddMappings(Assembly.GetAssembly(typeof(Common1Map)).GetExportedTypes());
            HbmMapping mappings = mapper.CompileMappingForAllExplicitlyAddedEntities();

            return mappings;
        }

        public ISession OpenSession()
        {
            return sessionFactory.OpenSession();
        }
    }
}

Client:

namespace ConsoleApplication14
{
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using NHibernate;
    using NHibernate.Linq;
    using NHibernate.Linq.Functions;

    public class Tester
    {
        private ILinqToHqlGeneratorsRegistry registry = new DefaultLinqToHqlGeneratorsRegistry();
        public void Go()
        {
            using (ISession session = SessionProvider.Instance.OpenSession())
            {
                CreateData(session);

                IQueryable<ICommon> commons = session.Query<ICommon>();//.Where(x => x.Display.Contains("Common1 #7"));

                var common1 = session.Query<Common1>().Where(x => x.Display.Contains("Common1 #7"));

                foreach(var common in commons)
                {
                    Console.WriteLine(common.Display);
                }
            }
        }

        private void CreateData(ISession session)
        {
            using (ITransaction tx = session.BeginTransaction())
            {
                for (int i = 0; i < 10; i++)
                {
                    session.SaveOrUpdate(new Common1() { Name = "Common1 #" + i });
                }

                tx.Commit();
            }
        }
    }
}

Answer 1

Register in SessionProvider class, like

configuration.LinqToHqlGeneratorsRegistry<MyLinqToHqlGeneratorsRegistry>(); 

MyLinqToHQLGeneratorRegistry implementation looks like this

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NHibernate.Linq.Functions;
using NHibernate.Linq;

namespace ConsoleApplication14
{
    public class MyLinqToHqlGeneratorsRegistry : DefaultLinqToHqlGeneratorsRegistry
    {
        public MyLinqToHqlGeneratorsRegistry()
            : base()
        {

            CalculatedPropertyGenerator<Common1, string>.Register(this, x => x.Display, Common1.CalculatedDisplayExpression);
        }
    }
}