additional case-insesitive field and/or property macthing

Author: amroel

src/NHibernate.Test/TransformTests/AliasToBeanResultTransformerFixture.cs

@@ -41,6 +41,21 @@ public struct TestStruct
 			public string Something { get; set; }
 		}
 
+		public class PublicPropertiesSimpleDTO
+		{
+			public int Id { get; set; }
+			public string Name { get; set; }
+		}
+
+		public class PrivateFieldsSimpleDTO
+		{
+			private int id;
+			private string name;
+
+			public int Id { get { return id; } }
+			public string Name { get { return name; } }
+		}
+
 		#region Overrides of TestCase
 
 		protected override IList Mappings
@@ -77,6 +92,52 @@ 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 WorkWithPublicParameterLessCtor()
 		{

src/NHibernate/NHibernate.csproj

@@ -670,6 +670,8 @@
     <Compile Include="Transform\AliasToEntityMapResultTransformer.cs" />
     <Compile Include="Transform\CacheableResultTransformer.cs" />
     <Compile Include="Transform\AliasedTupleSubsetResultTransformer.cs" />
+    <Compile Include="Transform\CaseInsensitiveFieldAccessor.cs" />
+    <Compile Include="Transform\CaseInsensitivePropertyAccessor.cs" />
     <Compile Include="Transform\ITupleSubsetResultTransformer.cs" />
     <Compile Include="Transform\DistinctRootEntityResultTransformer.cs" />
     <Compile Include="Transform\IResultTransformer.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/Transform/AliasToBeanResultTransformer.cs

@@ -48,22 +48,25 @@ 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")
-				                            	});
+			var accessors = new[]
+			{
+				PropertyAccessorFactory.GetPropertyAccessor(null),
+				PropertyAccessorFactory.GetPropertyAccessor("field"),
+				// The following are added to support dialects that returns column names in different casing
+				new CaseInsensitivePropertyAccessor(),
+				new CaseInsensitiveFieldAccessor()
+			};
+			propertyAccessor = new ChainedPropertyAccessor(accessors);
 		}
 
 
 		public override bool IsTransformedValueATupleElement(String[] aliases, int tupleLength)
 		{
 			return false;
-		}	
+		}
 
 
 		public override object TransformTuple(object[] tuple, String[] aliases)
@@ -88,11 +91,11 @@ public override object TransformTuple(object[] tuple, String[] aliases)
 						}
 					}
 				}
-				
+
 				// 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++)
 				{

src/NHibernate/Transform/CaseInsensitiveFieldAccessor.cs

@@ -0,0 +1,57 @@
+using System.Reflection;
+using NHibernate.Properties;
+
+namespace NHibernate.Transform
+{
+	/// <summary>
+	/// Access a private field found by ignoring case matching
+	/// </summary>
+	public class CaseInsensitiveFieldAccessor : IPropertyAccessor
+	{
+		#region IPropertyAccessor Members
+
+		public IGetter GetGetter(System.Type theClass, string propertyName)
+		{
+			return new FieldAccessor.FieldGetter(GetField(theClass, propertyName), theClass, propertyName);
+		}
+
+		public ISetter GetSetter(System.Type theClass, string propertyName)
+		{
+			return new FieldAccessor.FieldSetter(GetField(theClass, propertyName), theClass, propertyName);
+		}
+
+		public bool CanAccessThroughReflectionOptimizer
+		{
+			get { return true; }
+		}
+
+		#endregion
+
+		private static FieldInfo GetField(System.Type type, string fieldName)
+		{
+			return GetField(type, fieldName, type);
+		}
+
+		private static FieldInfo GetField(System.Type type, string fieldName, System.Type originalType)
+		{
+			if (type == null || type == typeof(object))
+			{
+				throw new PropertyNotFoundException(originalType, fieldName);
+			}
+
+			var bindingFlags = BindingFlags.Instance |
+				BindingFlags.Public |
+				BindingFlags.NonPublic |
+				BindingFlags.DeclaredOnly | 
+				BindingFlags.IgnoreCase;
+
+			var result = type.GetField(fieldName, bindingFlags);
+			if (result == null)
+			{
+				result = GetField(type.BaseType, fieldName, originalType);
+			}
+
+			return result;
+		}
+	}
+}

src/NHibernate/Transform/CaseInsensitivePropertyAccessor.cs

@@ -0,0 +1,63 @@
+using System.Linq;
+using System.Reflection;
+using NHibernate.Properties;
+
+namespace NHibernate.Transform
+{
+	/// <summary>
+	/// Access a Property found by ignoring case matching
+	/// </summary>
+	public class CaseInsensitivePropertyAccessor : IPropertyAccessor
+	{
+		#region IPropertyAccessor Members
+
+		public IGetter GetGetter(System.Type theClass, string propertyName)
+		{
+			var property = GetProperty(theClass, propertyName);
+			if (property == null)
+				throw new PropertyNotFoundException(theClass, propertyName);
+			return new BasicPropertyAccessor.BasicGetter(theClass, property, propertyName);
+		}
+
+		public ISetter GetSetter(System.Type theClass, string propertyName)
+		{
+			var property = GetProperty(theClass, propertyName);
+			if (property == null)
+				throw new PropertyNotFoundException(theClass, propertyName);
+			return new BasicPropertyAccessor.BasicSetter(theClass, property, propertyName);
+		}
+
+		public bool CanAccessThroughReflectionOptimizer
+		{
+			get { return true; }
+		}
+
+		#endregion
+
+		private static PropertyInfo GetProperty(System.Type type, string propertyName)
+		{
+			PropertyInfo result = null;
+			if (type == typeof(object) || type == null)
+			{
+				return result;
+			}
+
+			var bindingFlags = BindingFlags.Instance |
+				BindingFlags.Public |
+				BindingFlags.NonPublic |
+				BindingFlags.DeclaredOnly |
+				BindingFlags.IgnoreCase;
+
+			result = type.GetProperties(bindingFlags)
+				.FirstOrDefault(p => string.Compare(p.Name, propertyName, true) == 0);
+
+			if (result == null)
+				result = GetProperty(type.BaseType, propertyName);
+			else
+				if (!result.CanWrite)
+					result = null;
+
+			return result;
+		}
+	}
+}