NH-3488 - Adjusting xml comments, minor refactoring (c#7, white-spaces, use of new ReflectionCache, ...). To be squashed.

Author: fredericDelaporte

src/NHibernate/Hql/Ast/HqlTreeBuilder.cs

@@ -39,12 +39,12 @@ public HqlDelete Delete(HqlFrom @from)
 			return new HqlDelete(_factory, @from);
 		}
 
-		public HqlUpdate Update(HqlFrom @from,HqlSet set)
+		public HqlUpdate Update(HqlFrom @from, HqlSet set)
 		{
-			return new HqlUpdate(_factory, @from,set);
+			return new HqlUpdate(_factory, @from, set);
 		}
 
-		public HqlUpdate Update(HqlVersioned versioned,HqlFrom @from, HqlSet set)
+		public HqlUpdate Update(HqlVersioned versioned, HqlFrom @from, HqlSet set)
 		{
 			return new HqlUpdate(_factory, versioned, @from, set);
 		}
@@ -53,7 +53,6 @@ public HqlInsert Insert(HqlInto into, HqlQuery query)
 		{
 			return new HqlInsert(_factory, into, query);
 		}
-		
 
 		public HqlSelectFrom SelectFrom()
 		{

src/NHibernate/Linq/Assignment.cs

@@ -7,10 +7,16 @@ namespace NHibernate.Linq
 	/// </summary>
 	public class Assignment
 	{
+		/// <summary>
+		/// The assigned property.
+		/// </summary>
 		public string PropertyPath { get; set; }
+		/// <summary>
+		/// The value to assign.
+		/// </summary>
 		public Expression Expression { get; set; }
 
-		public Assignment(string propertyPath,Expression expression)
+		public Assignment(string propertyPath, Expression expression)
 		{
 			PropertyPath = propertyPath;
 			Expression = expression;

src/NHibernate/Linq/Assignments.cs

@@ -5,21 +5,22 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using NHibernate.Linq.Visitors;
+using NHibernate.Util;
 
 namespace NHibernate.Linq
 {
 	public abstract class Assignments
 	{
 		protected static readonly ConstructorInfo DictionaryConstructorInfo = typeof(Dictionary<string, object>).GetConstructor(new[] { typeof(int) });
-		protected static readonly MethodInfo DictionaryAddMethodInfo = typeof(Dictionary<string, object>).GetMethod("Add");
+		protected static readonly MethodInfo DictionaryAddMethodInfo = ReflectHelper.GetMethod<Dictionary<string, object>>(d => d.Add(null, null));
 	}
 
 	/// <summary>
-	/// Class to hold assignments used in updates and inserts
+	/// Class to hold assignments used in updates and inserts.
 	/// </summary>
-	/// <typeparam name="TInput">The type of the input.</typeparam>
-	/// <typeparam name="TOutput">The type of the output.</typeparam>
-	public class Assignments<TInput, TOutput> : Assignments
+	/// <typeparam name="TSource">The type of the entity source of the insert or to update.</typeparam>
+	/// <typeparam name="TTarget">The type of the entity to insert or to update.</typeparam>
+	public class Assignments<TSource, TTarget> : Assignments
 	{
 		private readonly List<Assignment> _sets = new List<Assignment>();
 
@@ -29,16 +30,12 @@ public class Assignments<TInput, TOutput> : Assignments
 		/// <typeparam name="TProp">The type of the property.</typeparam>
 		/// <param name="property">The property.</param>
 		/// <param name="expression">The expression that should be assigned to the property.</param>
-		/// <returns></returns>
-		public Assignments<TInput, TOutput> Set<TProp>(Expression<Func<TOutput, TProp>> property, Expression<Func<TInput, TProp>> expression)
+		/// <returns>The current assignments list.</returns>
+		public Assignments<TSource, TTarget> Set<TProp>(Expression<Func<TTarget, TProp>> property, Expression<Func<TSource, TProp>> expression)
 		{
-			if (property == null)
-				throw new ArgumentNullException(nameof(property));
 			if (expression == null)
 				throw new ArgumentNullException(nameof(expression));
-			var param = property.Parameters.Single();
-			var member = property.Body as MemberExpression ?? 
-				throw new ArgumentException("The property expression must refer to a property of " + param.Name + "("+ param.Type.Name + ")", nameof(property));
+			var member = GetMemberExpression(property);
 			_sets.Add(new Assignment(member.GetMemberPath(), expression));
 			return this;
 		}
@@ -49,25 +46,31 @@ public Assignments<TInput, TOutput> Set<TProp>(Expression<Func<TOutput, TProp>>
 		/// <typeparam name="TProp">The type of the property.</typeparam>
 		/// <param name="property">The property.</param>
 		/// <param name="value">The value.</param>
-		/// <returns></returns>
-		public Assignments<TInput, TOutput> Set<TProp>(Expression<Func<TOutput, TProp>> property, TProp value)
+		/// <returns>The current assignments list.</returns>
+		public Assignments<TSource, TTarget> Set<TProp>(Expression<Func<TTarget, TProp>> property, TProp value)
+		{
+			var member = GetMemberExpression(property);
+			_sets.Add(new Assignment(member.GetMemberPath(), Expression.Constant(value, typeof(TProp))));
+			return this;
+		}
+
+		private static MemberExpression GetMemberExpression<TProp>(Expression<Func<TTarget, TProp>> property)
 		{
 			if (property == null)
 				throw new ArgumentNullException(nameof(property));
 			var param = property.Parameters.Single();
 			var member = property.Body as MemberExpression ??
-				throw new ArgumentException("The property expression must refer to a property of " + param.Name + "(" + param.Type.Name + ")", nameof(property));
-			_sets.Add(new Assignment(member.GetMemberPath(), Expression.Constant(value, typeof(TProp))));
-			return this;
+				throw new ArgumentException($"The property expression must refer to a property of {param.Name}({param.Type.Name})", nameof(property));
+			return member;
 		}
 
 		/// <summary>
-		/// Converts the assignments into a to lambda expression, which creates a Dictionary&lt;string,object%gt;.
+		/// Converts the assignments into a lambda expression, which creates a Dictionary&lt;string,object%gt;.
 		/// </summary>
-		/// <returns></returns>
+		/// <returns>A lambda expression representing the assignments.</returns>
 		public LambdaExpression ConvertToDictionaryExpression()
 		{
-			var param = Expression.Parameter(typeof(TInput));
+			var param = Expression.Parameter(typeof(TSource));
 			var inits = new List<ElementInit>();
 			foreach (var set in _sets)
 			{
@@ -77,44 +80,43 @@ public LambdaExpression ConvertToDictionaryExpression()
 					setter = setterLambda.Body.Replace(setterLambda.Parameters.First(), param);
 				}
 				inits.Add(Expression.ElementInit(DictionaryAddMethodInfo, Expression.Constant(set.PropertyPath),
-															Expression.Convert(
-																setter,
-																typeof(object))));
-
+					Expression.Convert(setter, typeof(object))));
 			}
 
-
 			//The ListInit is intentionally "infected" with the lambda parameter (param), in the form of an IIF. 
 			//The only relevance is to make sure that the ListInit is not evaluated by the PartialEvaluatingExpressionTreeVisitor,
- 			//which could turn it into a Constant
+			//which could turn it into a Constant
 			var listInit = Expression.ListInit(
 				Expression.New(
 					DictionaryConstructorInfo,
 					Expression.Condition(
-						Expression.Equal(param, Expression.Constant(null, typeof(TInput))),
+						Expression.Equal(param, Expression.Constant(null, typeof(TSource))),
 						Expression.Constant(_sets.Count),
 						Expression.Constant(_sets.Count))),
 				inits);
 
-
-
 			return Expression.Lambda(listInit, param);
 		}
 
-		public static Assignments<TInput, TOutput> FromExpression(Expression<Func<TInput, TOutput>> expression)
+		/// <summary>
+		/// Converts a members initialization expression to assignments. Unset members are ignored and left untouched.
+		/// </summary>
+		/// <param name="expression">The expression to convert.</param>
+		/// <returns>The corresponding assignments.</returns>
+		public static Assignments<TSource, TTarget> FromExpression(Expression<Func<TSource, TTarget>> expression)
 		{
 			if (expression == null)
 				throw new ArgumentNullException(nameof(expression));
-			var instance = new Assignments<TInput, TOutput>();
+			var instance = new Assignments<TSource, TTarget>();
 			var memberInitExpression = expression.Body as MemberInitExpression ??
-				throw new ArgumentException("The expression must be member initialization, e.g. x => new Dog{Name = x.Name,Age = x.Age + 5}");
-			
+				throw new ArgumentException("The expression must be member initialization, e.g. x => new Dog { Name = x.Name, Age = x.Age + 5 }");
+
 			AddSetsFromBindings(memberInitExpression.Bindings, instance, "", expression.Parameters);
-			
+
 			return instance;
 		}
 
-		private static void AddSetsFromBindings(IEnumerable<MemberBinding> bindings, Assignments<TInput, TOutput> instance, string path, ReadOnlyCollection<ParameterExpression> parameters)
+		private static void AddSetsFromBindings(IEnumerable<MemberBinding> bindings, Assignments<TSource, TTarget> instance, string path, ReadOnlyCollection<ParameterExpression> parameters)
 		{
 			foreach (var binding in bindings)
 			{
@@ -124,12 +126,12 @@ private static void AddSetsFromBindings(IEnumerable<MemberBinding> bindings, Ass
 				}
 				else if (binding.BindingType == MemberBindingType.MemberBinding) // {Property={SubProperty="Value}}
 				{
-					AddSetsFromBindings(((MemberMemberBinding) binding).Bindings, instance, path + "." + binding.Member.Name, parameters);
+					AddSetsFromBindings(((MemberMemberBinding)binding).Bindings, instance, path + "." + binding.Member.Name, parameters);
 				}
 			}
 		}
 
-		private static void AddSetsFromAssignment(MemberAssignment assignment, Assignments<TInput, TOutput> instance, string path, ReadOnlyCollection<ParameterExpression> parameters)
+		private static void AddSetsFromAssignment(MemberAssignment assignment, Assignments<TSource, TTarget> instance, string path, ReadOnlyCollection<ParameterExpression> parameters)
 		{
 			// {Property=new Instance{SubProperty="Value"}}
 			if (assignment.Expression is MemberInitExpression memberInit)

src/NHibernate/Linq/InsertSyntax.cs

@@ -5,26 +5,30 @@
 
 namespace NHibernate.Linq
 {
-	public class InsertSyntax<TInput>
+	/// <summary>
+	/// An insert object on which entities to insert can be specified.
+	/// </summary>
+	/// <typeparam name="TSource">The type of the entities selected as source of the insert.</typeparam>
+	public class InsertSyntax<TSource>
 	{
-		private readonly IQueryable<TInput> _query;
+		private readonly IQueryable<TSource> _query;
 
-		internal InsertSyntax(IQueryable<TInput> query)
+		internal InsertSyntax(IQueryable<TSource> query)
 		{
 			_query = query;
 		}
 
 		/// <summary>
 		/// Executes the insert, using the specified assignments.
 		/// </summary>
-		/// <typeparam name="TOutput">The type of the output.</typeparam>
+		/// <typeparam name="TTarget">The type of the entities to insert.</typeparam>
 		/// <param name="assignmentActions">The assignments.</param>
-		/// <returns></returns>
-		public int Into<TOutput>(Action<Assignments<TInput, TOutput>> assignmentActions)
+		/// <returns>The number of inserted entities.</returns>
+		public int Into<TTarget>(Action<Assignments<TSource, TTarget>> assignmentActions)
 		{
 			if (assignmentActions == null)
 				throw new ArgumentNullException(nameof(assignmentActions));
-			var assignments = new Assignments<TInput, TOutput>();
+			var assignments = new Assignments<TSource, TTarget>();
 			assignmentActions.Invoke(assignments);
 			return InsertInto(_query, assignments);
 		}
@@ -34,21 +38,20 @@ public int Into<TOutput>(Action<Assignments<TInput, TOutput>> assignmentActions)
 		/// </summary>
 		/// <typeparam name="TOutput">The type of the output.</typeparam>
 		/// <param name="expression">The expression.</param>
-		/// <returns></returns>
-		public int As<TOutput>(Expression<Func<TInput, TOutput>> expression)
+		/// <returns>The number of inserted entities.</returns>
+		public int As<TOutput>(Expression<Func<TSource, TOutput>> expression)
 		{
-			var assignments = Assignments<TInput, TOutput>.FromExpression(expression);
+			var assignments = Assignments<TSource, TOutput>.FromExpression(expression);
 			return InsertInto(_query, assignments);
 		}
 
-		internal int InsertInto<TOutput>(IQueryable<TInput> query, Assignments<TInput, TOutput> assignments)
+		internal int InsertInto<TOutput>(IQueryable<TSource> query, Assignments<TSource, TOutput> assignments)
 		{
-			var nhQueryable = query as QueryableBase<TInput> ??
+			var nhQueryable = query as QueryableBase<TSource> ??
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
 			var provider = (DefaultQueryProvider)query.Provider;
 			return provider.ExecuteInsert(nhQueryable, assignments);
 		}
-
 	}
 }

src/NHibernate/Linq/LinqExtensionMethods.cs

@@ -83,9 +83,9 @@ public static IEnumerable<T> ToFuture<T>(this IQueryable<T> query)
 			if (nhQueryable == null)
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider = (INhQueryProvider) nhQueryable.Provider;
+			var provider = (INhQueryProvider)nhQueryable.Provider;
 			var future = provider.ExecuteFuture(nhQueryable.Expression);
-			return (IEnumerable<T>) future;
+			return (IEnumerable<T>)future;
 		}
 
 		public static IFutureValue<T> ToFutureValue<T>(this IQueryable<T> query)
@@ -94,14 +94,14 @@ public static IFutureValue<T> ToFutureValue<T>(this IQueryable<T> query)
 			if (nhQueryable == null)
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider = (INhQueryProvider) nhQueryable.Provider;
+			var provider = (INhQueryProvider)nhQueryable.Provider;
 			var future = provider.ExecuteFuture(nhQueryable.Expression);
 			if (future is IEnumerable<T>)
 			{
-				return new FutureValue<T>(() => ((IEnumerable<T>) future));
+				return new FutureValue<T>(() => ((IEnumerable<T>)future));
 			}
 
-			return (IFutureValue<T>) future;
+			return (IFutureValue<T>)future;
 		}
 
 		public static T MappedAs<T>(this T parameter, IType type)
@@ -115,53 +115,50 @@ public static IFutureValue<TResult> ToFutureValue<T, TResult>(this IQueryable<T>
 			if (nhQueryable == null)
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider = (INhQueryProvider) query.Provider;
+			var provider = (INhQueryProvider)query.Provider;
 
 			var expression = ReplacingExpressionTreeVisitor.Replace(selector.Parameters.Single(),
 																	query.Expression,
 																	selector.Body);
 
-			return (IFutureValue<TResult>) provider.ExecuteFuture(expression);
+			return (IFutureValue<TResult>)provider.ExecuteFuture(expression);
 		}
 
-		
 		/// <summary>
-		/// Deletes all entities in the specified query. The delete operation is performed in the database.
+		/// Deletes all entities selected by the specified query. The delete operation is performed in the database without reading the entities out of it.
 		/// </summary>
-		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="T">The type of the entities to delete.</typeparam>
 		/// <param name="query">The query.</param>
-		/// <returns></returns>
+		/// <returns>The number of deleted entities.</returns>
 		public static int Delete<T>(this IQueryable<T> query)
 		{
-			var nhQueryable = query as QueryableBase<T>;
-			if (nhQueryable == null)
+			var nhQueryable = query as QueryableBase<T> ??
 				throw new NotSupportedException("Query needs to be of type QueryableBase<T>");
 
-			var provider =nhQueryable.Provider as DefaultQueryProvider;
+			var provider = nhQueryable.Provider as DefaultQueryProvider;
 			return provider.ExecuteDelete(query.Expression);
 		}
 
 		/// <summary>
-		/// Updates the entities in the query, using the specified assignments. The update operation is performed in the database.
+		/// Initiate an update for the entities selected by the query. The update operation will be performed in the database without reading the entities out of it.
 		/// </summary>
-		/// <typeparam name="T"></typeparam>
+		/// <typeparam name="T">The type of the entities to update.</typeparam>
 		/// <param name="query">The query.</param>
-		/// <returns></returns>
+		/// <returns>An update object on which values to update can be specified.</returns>
 		public static UpdateSyntax<T> Update<T>(this IQueryable<T> query)
 		{
 			return new UpdateSyntax<T>(query);
 		}
 
 		/// <summary>
-		/// Inserts new entities into the database, using other stored entities as a source. Uses INSERT INTO [...] SELECT FROM [...] in the database.
+		/// Initiate an insert using selected entities as a source. Will use <c>INSERT INTO [...] SELECT FROM [...]</c> in the database.
 		/// </summary>
-		/// <typeparam name="TInput">The type of the input.</typeparam>
+		/// <typeparam name="TSource">The type of the selected entities.</typeparam>
 		/// <param name="query">The query.</param>
-		/// <returns></returns>
-		public static InsertSyntax<TInput> Insert<TInput>(this IQueryable<TInput> query)
+		/// <returns>An insert object on which entities to insert can be specified.</returns>
+		public static InsertSyntax<TSource> Insert<TSource>(this IQueryable<TSource> query)
 		{
-			return new InsertSyntax<TInput>(query);
+			return new InsertSyntax<TSource>(query);
 		}
-		
 	}
 }

src/NHibernate/Linq/NhLinqDeleteExpression.cs

@@ -16,7 +16,7 @@ public NhLinqDeleteExpression(Expression expression, ISessionFactoryImplementor
 		protected override ExpressionToHqlTranslationResults GenerateHqlQuery(QueryModel queryModel, VisitorParameters visitorParameters)
 		{
 			visitorParameters.EntityType = Type;
-			return QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true,QueryMode.Delete);
+			return QueryModelVisitor.GenerateHqlQuery(queryModel, visitorParameters, true, QueryMode.Delete);
 		}
 	}
 }