NH-3693 - test cases and fix for alias to bean failures with Firebird

Author: amroel

src/NHibernate.Test/Criteria/Lambda/LambdaFixtureBase.cs

@@ -128,7 +128,9 @@ private void AssertObjectsAreEqual(object expected, object actual, string name)
 
 			if ((expectedType.IsValueType)
 				|| (expected is System.Type)
-				|| (expected is string))
+				|| (expected is string)
+				|| (expected is FieldInfo)
+				|| (expected is PropertyInfo))
 			{
 				Assert.AreEqual(expected, actual, fieldPath);
 				_fieldPath.Pop();

src/NHibernate.Test/TransformTests/AliasToBeanResultTransformerFixture.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections;
 using System.Collections.Generic;
 using NHibernate.Transform;
@@ -41,6 +40,43 @@ public struct TestStruct
 			public string Something { get; set; }
 		}
 
+		public class PublicPropertiesSimpleDTO
+		{
+			public object Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		public class PrivateFieldsSimpleDTO
+		{
+			private object id;
+			private string name;
+
+			public object Id { get { return id; } }
+			public string Name { get { return name; } }
+		}
+
+		public class BasePublicPropsSimpleDTO
+		{
+			public object Id { get; set; }
+		}
+
+		public class PublicInheritedPropertiesSimpleDTO : BasePublicPropsSimpleDTO
+		{
+			public string Name { get; set; }
+		}
+
+		public class BasePrivateFieldSimpleDTO
+		{
+			private object id;
+			public object Id { get { return id; } }
+		}
+
+		public class PrivateInheritedFieldsSimpleDTO : BasePrivateFieldSimpleDTO
+		{
+			private string name;
+			public string Name { get { return name; } }
+		}
+
 		#region Overrides of TestCase
 
 		protected override IList Mappings
@@ -77,6 +113,99 @@ public void WorkWithOutPublicParameterLessCtor()
 			}
 		}
 
+		[Test]
+		public void ToPublicProperties_WithoutAnyProjections()
+		{
+			try
+			{
+				Setup();
+
+				using (ISession s = OpenSession())
+				{
+					var transformer = Transformers.AliasToBean<PublicPropertiesSimpleDTO>();
+					IList<PublicPropertiesSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
+						.SetResultTransformer(transformer)
+						.List<PublicPropertiesSimpleDTO>();
+					Assert.That(l.Count, Is.EqualTo(2));
+					Assert.That(l, Has.All.Not.Null);
+				}
+			}
+			finally
+			{
+				Cleanup();
+			}			
+		}
+
+		[Test]
+		public void ToPrivateFields_WithoutAnyProjections()
+		{
+			try
+			{
+				Setup();
+
+				using (ISession s = OpenSession())
+				{
+					var transformer = Transformers.AliasToBean<PrivateFieldsSimpleDTO>();
+					IList<PrivateFieldsSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
+						.SetResultTransformer(transformer)
+						.List<PrivateFieldsSimpleDTO>();
+					Assert.That(l.Count, Is.EqualTo(2));
+					Assert.That(l, Has.All.Not.Null);
+				}
+			}
+			finally
+			{
+				Cleanup();
+			}
+		}
+
+		[Test]
+		public void ToInheritedPublicProperties_WithoutProjections()
+		{
+			try
+			{
+				Setup();
+
+				using (ISession s = OpenSession())
+				{
+					var transformer = Transformers.AliasToBean<PublicInheritedPropertiesSimpleDTO>();
+					IList<PublicInheritedPropertiesSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
+						.SetResultTransformer(transformer)
+						.List<PublicInheritedPropertiesSimpleDTO>();
+					Assert.That(l.Count, Is.EqualTo(2));
+					Assert.That(l, Has.All.Not.Null);
+				}
+			}
+			finally
+			{
+				Cleanup();
+			}
+		}
+
+		[Test]
+		public void ToInheritedPrivateFields_WithoutProjections()
+		{
+			try
+			{
+				Setup();
+
+				using (ISession s = OpenSession())
+				{
+					var transformer = Transformers.AliasToBean<PrivateInheritedFieldsSimpleDTO>();
+					IList<PrivateInheritedFieldsSimpleDTO> l = s.CreateSQLQuery("select * from Simple")
+						.SetResultTransformer(transformer)
+						.List<PrivateInheritedFieldsSimpleDTO>();
+					Assert.That(l.Count, Is.EqualTo(2));
+					Assert.That(l, Has.All.Not.Null);
+					Assert.That(l, Has.All.Property("Id").Not.Null);
+				}
+			}
+			finally
+			{
+				Cleanup();
+			}
+		}
+
 		[Test]
 		public void WorkWithPublicParameterLessCtor()
 		{

src/NHibernate/NHibernate.csproj

@@ -677,6 +677,7 @@
     <Compile Include="Transform\ITupleSubsetResultTransformer.cs" />
     <Compile Include="Transform\DistinctRootEntityResultTransformer.cs" />
     <Compile Include="Transform\IResultTransformer.cs" />
+    <Compile Include="Transform\QueryAliasToObjectPropertySetter.cs" />
     <Compile Include="Transform\RootEntityResultTransformer.cs" />
     <Compile Include="TransientObjectException.cs" />
     <Compile Include="Type\AbstractType.cs" />

src/NHibernate/Properties/BasicPropertyAccessor.cs

@@ -130,6 +130,12 @@ internal static BasicSetter GetSetterOrNull(System.Type type, string propertyNam
 				return null;
 			}
 
+			// According to http://msdn.microsoft.com/EN-US/library/kz0a8sxy%28v=VS.110,d=hv.2%29.aspx
+			// the assumption articulated in the comment following "if(type.IsValueType)" is wrong at least since .NET 2.0!
+			// This part of the code has beed changed twice to fix the following Issues in order: NH-1728 then NH-1904
+			// As it stands now the implementation prevents AliasToBeanTransformer from finding the correct property 
+			// on a class if the dialect returns column names in a different case than expected.
+
 			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly;
 
 			if (type.IsValueType)

src/NHibernate/Properties/ChainedPropertyAccessor.cs

@@ -2,7 +2,9 @@
 
 namespace NHibernate.Properties
 {
+	// To be removed in v6.0
 	[Serializable]
+	[Obsolete("This class has no more usages in NHibernate and will be removed in a future version.")]
 	public class ChainedPropertyAccessor : IPropertyAccessor
 	{
 		private readonly IPropertyAccessor[] chain;

src/NHibernate/Transform/AliasToBeanResultTransformer.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections;
 using System.Reflection;
-using NHibernate.Properties;
 
 namespace NHibernate.Transform
 {
@@ -27,10 +26,9 @@ namespace NHibernate.Transform
 	[Serializable]
 	public class AliasToBeanResultTransformer : AliasedTupleSubsetResultTransformer
 	{
+		private readonly QueryAliasToObjectPropertySetter _propertySetter;
 		private const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
 		private readonly System.Type resultClass;
-		private ISetter[] setters;
-		private readonly IPropertyAccessor propertyAccessor;
 		private readonly ConstructorInfo constructor;
 
 		public AliasToBeanResultTransformer(System.Type resultClass)
@@ -48,22 +46,17 @@ public AliasToBeanResultTransformer(System.Type resultClass)
 			if (constructor == null && resultClass.IsClass)
 			{
 				throw new ArgumentException("The target class of a AliasToBeanResultTransformer need a parameter-less constructor",
-				                            "resultClass");
+											"resultClass");
 			}
 
-			propertyAccessor =
-				new ChainedPropertyAccessor(new[]
-				                            	{
-				                            		PropertyAccessorFactory.GetPropertyAccessor(null),
-				                            		PropertyAccessorFactory.GetPropertyAccessor("field")
-				                            	});
+			_propertySetter = QueryAliasToObjectPropertySetter.MakeFor(resultClass);
 		}
 
 
 		public override bool IsTransformedValueATupleElement(String[] aliases, int tupleLength)
 		{
 			return false;
-		}	
+		}
 
 
 		public override object TransformTuple(object[] tuple, String[] aliases)
@@ -76,30 +69,13 @@ public override object TransformTuple(object[] tuple, String[] aliases)
 
 			try
 			{
-				if (setters == null)
-				{
-					setters = new ISetter[aliases.Length];
-					for (int i = 0; i < aliases.Length; i++)
-					{
-						string alias = aliases[i];
-						if (alias != null)
-						{
-							setters[i] = propertyAccessor.GetSetter(resultClass, alias);
-						}
-					}
-				}
-				
-				// if resultClass is not a class but a value type, we need to use Activator.CreateInstance
 				result = resultClass.IsClass
-				         	? constructor.Invoke(null)
-				         	: Cfg.Environment.BytecodeProvider.ObjectsFactory.CreateInstance(resultClass, true);
+							? constructor.Invoke(null)
+							: Cfg.Environment.BytecodeProvider.ObjectsFactory.CreateInstance(resultClass, true);
 
 				for (int i = 0; i < aliases.Length; i++)
 				{
-					if (setters[i] != null)
-					{
-						setters[i].Set(result, tuple[i]);
-					}
+					_propertySetter.SetProperty(aliases[i], tuple[i], result);
 				}
 			}
 			catch (InstantiationException e)

src/NHibernate/Transform/QueryAliasToObjectPropertySetter.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace NHibernate.Transform
+{
+	[Serializable]
+	public class QueryAliasToObjectPropertySetter
+	{
+		private readonly IEnumerable<FieldInfo> _fields;
+		private readonly IEnumerable<PropertyInfo> _properties;
+
+		private QueryAliasToObjectPropertySetter(FieldInfo[] fields, PropertyInfo[] properties)
+		{
+			_fields = fields;
+			_properties = properties;
+		}
+
+		public static QueryAliasToObjectPropertySetter MakeFor(System.Type objType)
+		{
+			var bindingFlags = BindingFlags.Instance |
+				BindingFlags.Public |
+				BindingFlags.NonPublic |
+				BindingFlags.IgnoreCase;
+			var fields = objType.GetFields(bindingFlags);
+			var properties = objType.GetProperties(bindingFlags);
+
+			return new QueryAliasToObjectPropertySetter(fields, properties);
+		}
+
+		public void SetProperty(string alias, object value, object resultObj)
+		{
+			var property = _properties.SingleOrDefault(prop => string.Equals(prop.Name, alias, StringComparison.OrdinalIgnoreCase));
+			var field = _fields.SingleOrDefault(prop => string.Equals(prop.Name, alias, StringComparison.OrdinalIgnoreCase));
+			if (field == null && property == null)
+				throw new PropertyNotFoundException(resultObj.GetType(), alias, "setter");
+
+			if (field != null)
+			{
+				field.SetValue(resultObj, value);
+				return;
+			}
+			if (property != null && property.CanWrite)
+				property.SetValue(resultObj, value, new object[0]);
+		}
+	}
+}