1. roundcrisis
  2. Linq2Rest

Commits

Jacob Reimers  committed 9502f18

Fixed StyleCop violations.

  • Participants
  • Parent commits e5d5723
  • Branches default

Comments (0)

Files changed (20)

File Linq2Rest.Mvc/Linq2Rest.Mvc.csproj

View file
   <ItemGroup>
     <Compile Include="ModelFilterBinder.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Provider\AnonymousTypeSerializerHelper.cs" />
     <Compile Include="Provider\RuntimeAnonymousTypeSerializer.cs" />
   </ItemGroup>
   <ItemGroup>

File Linq2Rest.Mvc/Provider/AnonymousTypeSerializerHelper.cs

View file
+// (c) Copyright Reimers.dk.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://www.opensource.org/licenses/MS-PL] for details.
+// All other rights reserved.
+// Based on code from http://stackoverflow.com/questions/606104/how-to-create-linq-expression-tree-with-anonymous-type-in-it
+
+namespace Linq2Rest.Mvc.Provider
+{
+	using System;
+	using System.Reflection;
+
+	internal static class AnonymousTypeSerializerHelper
+	{
+		public static readonly MethodInfo InnerChangeTypeMethod = typeof(Convert).GetMethod("ChangeType", new[] { typeof(object), typeof(Type) });
+	}
+}

File Linq2Rest.Mvc/Provider/RuntimeAnonymousTypeSerializer.cs

View file
 	using System.Diagnostics.Contracts;
 	using System.Linq;
 	using System.Linq.Expressions;
-	using System.Reflection;
 	using System.Web.Script.Serialization;
 
 	using Linq2Rest.Provider;
 			Contract.Invariant(_elementType != null);
 		}
 	}
-
-	internal static class AnonymousTypeSerializerHelper
-	{
-		public static readonly MethodInfo InnerChangeTypeMethod = typeof(Convert).GetMethod("ChangeType", new[] { typeof(object), typeof(Type) });
-	}
 }

File Linq2Rest.Tests/FakeItem.cs

View file
 			{
 				return _stringValue;
 			}
+
 			set
 			{
 				_stringValue = value;

File Linq2Rest.Tests/Linq2Rest.Tests.csproj

View file
     <Compile Include="Parser\ExpressionTokenizerTests.cs" />
     <Compile Include="FakeItem.cs" />
     <Compile Include="Parser\FilterExpressionFactoryTests.cs" />
+    <Compile Include="Provider\ChildDto.cs" />
+    <Compile Include="Provider\ComplexDto.cs" />
     <Compile Include="Provider\ExpressionProcessorTests.cs" />
     <Compile Include="RuntimeTypeProviderTests.cs" />
     <Compile Include="Mvc\ModelFilterBinderTests.cs" />

File Linq2Rest.Tests/Provider/ChildDto.cs

View file
+// (c) Copyright Reimers.dk.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://www.opensource.org/licenses/MS-PL] for details.
+// All other rights reserved.
+// Based on code from http://stackoverflow.com/questions/606104/how-to-create-linq-expression-tree-with-anonymous-type-in-it
+
+namespace Linq2Rest.Tests.Provider
+{
+	public class ChildDto
+	{
+		public int ID { get; set; }
+
+		public string Name { get; set; }
+	}
+}

File Linq2Rest.Tests/Provider/ComplexDto.cs

View file
+// (c) Copyright Reimers.dk.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://www.opensource.org/licenses/MS-PL] for details.
+// All other rights reserved.
+// Based on code from http://stackoverflow.com/questions/606104/how-to-create-linq-expression-tree-with-anonymous-type-in-it
+
+namespace Linq2Rest.Tests.Provider
+{
+	using System;
+
+	public class ComplexDto
+	{
+		public int ID { get; set; }
+
+		public string Content { get; set; }
+
+		public double Value { get; set; }
+
+		public DateTime Date { get; set; }
+
+		public Choice Choice { get; set; }
+
+		public ChildDto Child { get; set; }
+	}
+}

File Linq2Rest.Tests/Provider/ExpressionProcessorTests.cs

View file
-// -----------------------------------------------------------------------
-// <copyright file="ExpressionProcessorTests.cs" company="">
-// TODO: Update copyright text.
-// </copyright>
-// -----------------------------------------------------------------------
+// (c) Copyright Reimers.dk.
+// This source is subject to the Microsoft Public License (Ms-PL).
+// Please see http://www.opensource.org/licenses/MS-PL] for details.
+// All other rights reserved.
+// Based on code from http://stackoverflow.com/questions/606104/how-to-create-linq-expression-tree-with-anonymous-type-in-it
 
 namespace Linq2Rest.Tests.Provider
 {

File Linq2Rest.Tests/Provider/RestContextTests.cs

View file
 				.Callback<Uri>(u => Console.WriteLine(u.ToString()))
 				.Returns("[{Value : 2, Content : \"blah\", Child : {ID : 2, Name : \"Foo\"}}]");
 
-
 			_complexProvider = new RestContext<ComplexDto>(_mockComplexClient.Object, serializerFactory);
 		}
 

File Linq2Rest.Tests/Provider/SimpleDto.cs

View file
 
 		public Choice Choice { get; set; }
 	}
-
-	public class ComplexDto
-	{
-		public int ID { get; set; }
-
-		public string Content { get; set; }
-
-		public double Value { get; set; }
-
-		public DateTime Date { get; set; }
-
-		public Choice Choice { get; set; }
-
-		public ChildDto Child { get; set; }
-	}
-
-	public class ChildDto
-	{
-		public int ID { get; set; }
-
-		public string Name { get; set; }
-	}
 }

File Linq2Rest/IRuntimeTypeProvider.cs

View file
 	}
 
 	[ContractClassFor(typeof(IRuntimeTypeProvider))]
-	internal abstract class RuntimeTypeProviderContracts:IRuntimeTypeProvider
+	internal abstract class RuntimeTypeProviderContracts : IRuntimeTypeProvider
 	{
 		public Type Get(Type sourceType, IEnumerable<MemberInfo> properties)
 		{

File Linq2Rest/Implementations/RestClientBase.cs

View file
 		private readonly string _acceptHeader;
 
 		/// <summary>
-		/// Initializes a new instance of the <see cref="JsonRestClient"/> class.
+		/// Initializes a new instance of the <see cref="RestClientBase"/> class.
 		/// </summary>
 		/// <param name="uri">The base <see cref="Uri"/> for the REST service.</param>
 		/// <param name="acceptHeader">The accept header to use in web requests.</param>

File Linq2Rest/Parser/ExpressionTokenizer.cs

View file
 					operationIndex = i;
 				}
 			}
+
 			return operationIndex;
 		}
 

File Linq2Rest/Parser/FilterExpressionFactory.cs

View file
 	using System.Text.RegularExpressions;
 
 	/// <summary>
-	/// Defines the FilterExpressionFactory
+	/// Defines the FilterExpressionFactory.
 	/// </summary>
 	public class FilterExpressionFactory : IFilterExpressionFactory
 	{

File Linq2Rest/Parser/SelectExpressionFactory.cs

View file
 	using System.Threading;
 
 	/// <summary>
-	/// Defines the SelectExpressionFactory
+	/// Defines the SelectExpressionFactory.
 	/// </summary>
 	/// <typeparam name="T">The <see cref="Type"/> of object to project.</typeparam>
 	public class SelectExpressionFactory<T> : ISelectExpressionFactory<T>

File Linq2Rest/Parser/SortExpressionFactory.cs

View file
 	using System.Web.UI.WebControls;
 
 	/// <summary>
-	/// Defines the SortExpressionFactory
+	/// Defines the SortExpressionFactory�.
 	/// </summary>
 	public class SortExpressionFactory : ISortExpressionFactory
 	{

File Linq2Rest/Provider/ExpressionProcessor.cs

View file
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						var newFilter = _visitor.Visit(methodCall.Arguments[1]);
 
 						builder.FilterParameter = string.IsNullOrWhiteSpace(builder.FilterParameter)
 													? newFilter
 													: string.Format("({0}) and ({1})", builder.FilterParameter, newFilter);
 					}
+
 					break;
 				case "Select":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						var unaryExpression = methodCall.Arguments[1] as UnaryExpression;
 						if (unaryExpression != null)
 						{
 										throw new InvalidOperationException("Projection into new member names is not supported.");
 									}
 
-									builder.SelectParameter = String.Join(",", args);
+									builder.SelectParameter = string.Join(",", args);
 								}
 							}
 						}
 					}
+
 					break;
 				case "OrderBy":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						var item = _visitor.Visit(methodCall.Arguments[1]);
 						builder.OrderByParameter.Add(item);
 					}
+
 					break;
 				case "OrderByDescending":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						var visit = _visitor.Visit(methodCall.Arguments[1]);
 						builder.OrderByParameter.Add(visit + " desc");
 					}
+
 					break;
 				case "ThenBy":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						var visit = _visitor.Visit(methodCall.Arguments[1]);
 						builder.OrderByParameter.Add(visit);
 					}
+
 					break;
 				case "ThenByDescending":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						var visit = _visitor.Visit(methodCall.Arguments[1]);
 						builder.OrderByParameter.Add(visit + " desc");
 					}
+
 					break;
 				case "Take":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						builder.TakeParameter = _visitor.Visit(methodCall.Arguments[1]);
 					}
+
 					break;
 				case "Skip":
 					Contract.Assume(methodCall.Arguments.Count >= 2);
 						{
 							return InvokeEager(methodCall, result);
 						}
+
 						builder.SkipParameter = _visitor.Visit(methodCall.Arguments[1]);
 					}
+
 					break;
 				default:
 					return ExecuteMethod(methodCall, builder, resultLoader, intermediateResultLoader);
 			return null;
 		}
 
+		private static object InvokeEager(MethodCallExpression methodCall, object source)
+		{
+			var parameters = ResolveInvocationParameters(source as IEnumerable, methodCall);
+			return methodCall.Method.Invoke(null, parameters);
+		}
+
+		private static object[] ResolveInvocationParameters(IEnumerable results, MethodCallExpression methodCall)
+		{
+			var parameters = new object[] { results.AsQueryable() }
+				.Concat(methodCall.Arguments.Where((x, i) => i > 0).Select(GetExpressionValue))
+				.Where(x => x != null)
+				.ToArray();
+			return parameters;
+		}
+
+		private static object GetExpressionValue(Expression expression)
+		{
+			if (expression is UnaryExpression)
+			{
+				return (expression as UnaryExpression).Operand;
+			}
+
+			if (expression is ConstantExpression)
+			{
+				return (expression as ConstantExpression).Value;
+			}
+
+			return null;
+		}
+
 		private object GetMethodResult<T>(MethodCallExpression methodCall, ParameterBuilder builder, Func<ParameterBuilder, IList<T>> resultLoader, Func<Type, ParameterBuilder, IEnumerable> intermediateResultLoader)
 		{
 			Contract.Assume(methodCall.Arguments.Count >= 2);
 			ProcessMethodCall(methodCall.Arguments[0] as MethodCallExpression, builder, resultLoader, intermediateResultLoader);
 
 			var processResult = _visitor.Visit(methodCall.Arguments[1]);
-			var currentParameter = String.IsNullOrWhiteSpace(builder.FilterParameter)
+			var currentParameter = string.IsNullOrWhiteSpace(builder.FilterParameter)
 									? processResult
-									: String.Format("({0}) and ({1})", builder.FilterParameter, processResult);
+									: string.Format("({0}) and ({1})", builder.FilterParameter, processResult);
 			builder.FilterParameter = currentParameter;
 
 			var genericArguments = methodCall.Method.GetGenericArguments();
 
 			return methodCall.Method.Invoke(null, arguments);
 		}
-
-		private static object InvokeEager(MethodCallExpression methodCall, object source)
-		{
-			var parameters = ResolveInvocationParameters(source as IEnumerable, methodCall);
-			return methodCall.Method.Invoke(null, parameters);
-		}
-
-		private static object[] ResolveInvocationParameters(IEnumerable results, MethodCallExpression methodCall)
-		{
-			var parameters = new object[] { results.AsQueryable() }
-				.Concat(methodCall.Arguments.Where((x, i) => i > 0).Select(GetExpressionValue))
-				.Where(x => x != null)
-				.ToArray();
-			return parameters;
-		}
-
-		private static object GetExpressionValue(Expression expression)
-		{
-			if (expression is UnaryExpression)
-			{
-				return (expression as UnaryExpression).Operand;
-			}
-
-			if (expression is ConstantExpression)
-			{
-				return (expression as ConstantExpression).Value;
-			}
-
-			return null;
-		}
 	}
 }

File Linq2Rest/Provider/ExpressionVisitor.cs

View file
 			return expression == null ? null : Visit(expression, expression.Type);
 		}
 
-		private string Visit(Expression expression, Type type)
-		{
-			Contract.Requires(expression != null);
-
-			if (expression is LambdaExpression)
-			{
-				return Visit((expression as LambdaExpression).Body);
-			}
-
-			var memberExpression = expression as MemberExpression;
-
-			if (memberExpression != null)
-			{
-				var pathPrefixes = new List<string>();
-				var currentMemberExpression = memberExpression;
-				while (currentMemberExpression != null)
-				{
-					pathPrefixes.Add(currentMemberExpression.Member.Name);
-					currentMemberExpression = currentMemberExpression.Expression as MemberExpression;
-				}
-				pathPrefixes.Reverse();
-				var prefix = string.Join("/", pathPrefixes);
-
-				if (!IsMemberOfParameter(memberExpression))
-				{
-					var collapsedExpression = CollapseCapturedOuterVariables(memberExpression);
-					if (!(collapsedExpression is MemberExpression))
-					{
-						Contract.Assume(collapsedExpression != null);
-
-						return Visit(collapsedExpression);
-					}
-
-					memberExpression = (MemberExpression)collapsedExpression;
-				}
-
-				var memberCall = GetMemberCall(memberExpression);
-
-				var innerExpression = memberExpression.Expression;
-
-				Contract.Assume(innerExpression != null);
-
-				return string.IsNullOrWhiteSpace(memberCall)
-						? prefix
-						: string.Format("{0}({1})", memberCall, Visit(innerExpression));
-			}
-
-			if (expression is ConstantExpression)
-			{
-				var value = (expression as ConstantExpression).Value;
-
-				Contract.Assume(type != null);
-
-				return string.Format(
-					Thread.CurrentThread.CurrentCulture,
-					"{0}{1}{0}",
-					value is string ? "'" : string.Empty,
-					value == null ? "null" : GetValue(Expression.Convert(expression, type)));
-			}
-
-			if (expression is UnaryExpression)
-			{
-				var unaryExpression = expression as UnaryExpression;
-				var operand = unaryExpression.Operand;
-				switch (unaryExpression.NodeType)
-				{
-					case ExpressionType.Not:
-					case ExpressionType.IsFalse:
-						return string.Format("not({0})", Visit(operand));
-					default:
-						return Visit(operand);
-				}
-			}
-
-			if (expression is BinaryExpression)
-			{
-				var binaryExpression = expression as BinaryExpression;
-				var operation = GetOperation(binaryExpression);
-
-				var isLeftComposite = CompositeExpressionTypes.Any(x => x == binaryExpression.Left.NodeType);
-				var isRightComposite = CompositeExpressionTypes.Any(x => x == binaryExpression.Right.NodeType);
-
-				var leftType = GetUnconvertedType(binaryExpression.Left);
-				var leftString = Visit(binaryExpression.Left);
-				var rightString = Visit(binaryExpression.Right, leftType);
-
-				return string.Format(
-					"{0} {1} {2}",
-					string.Format(isLeftComposite ? "({0})" : "{0}", leftString),
-					operation,
-					string.Format(isRightComposite ? "({0})" : "{0}", rightString));
-			}
-
-			if (expression is MethodCallExpression)
-			{
-				return GetMethodCall(expression as MethodCallExpression);
-			}
-
-			if (expression is NewExpression)
-			{
-				return GetValue(expression).ToString();
-			}
-
-			throw new InvalidOperationException("Expression is not recognized or supported");
-		}
-
 		private static Type GetUnconvertedType(Expression expression)
 		{
 			Contract.Requires(expression != null);
 			return nodeType == ExpressionType.Parameter;
 		}
 
+		private static string GetOperation(Expression expression)
+		{
+			Contract.Requires(expression != null);
+
+			switch (expression.NodeType)
+			{
+				case ExpressionType.Add:
+					return "add";
+				case ExpressionType.AddChecked:
+					break;
+				case ExpressionType.And:
+				case ExpressionType.AndAlso:
+					return "and";
+				case ExpressionType.Divide:
+					return "div";
+				case ExpressionType.Equal:
+					return "eq";
+				case ExpressionType.GreaterThan:
+					return "gt";
+				case ExpressionType.GreaterThanOrEqual:
+					return "ge";
+				case ExpressionType.LessThan:
+					return "lt";
+				case ExpressionType.LessThanOrEqual:
+					return "le";
+				case ExpressionType.Modulo:
+					return "mod";
+				case ExpressionType.Multiply:
+					return "mul";
+				case ExpressionType.Not:
+					return "not";
+				case ExpressionType.NotEqual:
+					return "ne";
+				case ExpressionType.Or:
+				case ExpressionType.OrElse:
+					return "or";
+				case ExpressionType.Subtract:
+					return "sub";
+			}
+
+			return string.Empty;
+		}
+
 		private string GetMethodCall(MethodCallExpression expression)
 		{
 			Contract.Requires(expression != null);
 			return string.Empty;
 		}
 
-		private static string GetOperation(Expression expression)
+		private string Visit(Expression expression, Type type)
 		{
 			Contract.Requires(expression != null);
 
-			switch (expression.NodeType)
+			if (expression is LambdaExpression)
 			{
-				case ExpressionType.Add:
-					return "add";
-				case ExpressionType.AddChecked:
-					break;
-				case ExpressionType.And:
-				case ExpressionType.AndAlso:
-					return "and";
-				case ExpressionType.Divide:
-					return "div";
-				case ExpressionType.Equal:
-					return "eq";
-				case ExpressionType.GreaterThan:
-					return "gt";
-				case ExpressionType.GreaterThanOrEqual:
-					return "ge";
-				case ExpressionType.LessThan:
-					return "lt";
-				case ExpressionType.LessThanOrEqual:
-					return "le";
-				case ExpressionType.Modulo:
-					return "mod";
-				case ExpressionType.Multiply:
-					return "mul";
-				case ExpressionType.Not:
-					return "not";
-				case ExpressionType.NotEqual:
-					return "ne";
-				case ExpressionType.Or:
-				case ExpressionType.OrElse:
-					return "or";
-				case ExpressionType.Subtract:
-					return "sub";
+				return Visit((expression as LambdaExpression).Body);
 			}
 
-			return string.Empty;
+			var memberExpression = expression as MemberExpression;
+
+			if (memberExpression != null)
+			{
+				var pathPrefixes = new List<string>();
+				var currentMemberExpression = memberExpression;
+				while (currentMemberExpression != null)
+				{
+					pathPrefixes.Add(currentMemberExpression.Member.Name);
+					currentMemberExpression = currentMemberExpression.Expression as MemberExpression;
+				}
+
+				pathPrefixes.Reverse();
+				var prefix = string.Join("/", pathPrefixes);
+
+				if (!IsMemberOfParameter(memberExpression))
+				{
+					var collapsedExpression = CollapseCapturedOuterVariables(memberExpression);
+					if (!(collapsedExpression is MemberExpression))
+					{
+						Contract.Assume(collapsedExpression != null);
+
+						return Visit(collapsedExpression);
+					}
+
+					memberExpression = (MemberExpression)collapsedExpression;
+				}
+
+				var memberCall = GetMemberCall(memberExpression);
+
+				var innerExpression = memberExpression.Expression;
+
+				Contract.Assume(innerExpression != null);
+
+				return string.IsNullOrWhiteSpace(memberCall)
+						? prefix
+						: string.Format("{0}({1})", memberCall, Visit(innerExpression));
+			}
+
+			if (expression is ConstantExpression)
+			{
+				var value = (expression as ConstantExpression).Value;
+
+				Contract.Assume(type != null);
+
+				return string.Format(
+					Thread.CurrentThread.CurrentCulture,
+					"{0}{1}{0}",
+					value is string ? "'" : string.Empty,
+					value == null ? "null" : GetValue(Expression.Convert(expression, type)));
+			}
+
+			if (expression is UnaryExpression)
+			{
+				var unaryExpression = expression as UnaryExpression;
+				var operand = unaryExpression.Operand;
+				switch (unaryExpression.NodeType)
+				{
+					case ExpressionType.Not:
+					case ExpressionType.IsFalse:
+						return string.Format("not({0})", Visit(operand));
+					default:
+						return Visit(operand);
+				}
+			}
+
+			if (expression is BinaryExpression)
+			{
+				var binaryExpression = expression as BinaryExpression;
+				var operation = GetOperation(binaryExpression);
+
+				var isLeftComposite = CompositeExpressionTypes.Any(x => x == binaryExpression.Left.NodeType);
+				var isRightComposite = CompositeExpressionTypes.Any(x => x == binaryExpression.Right.NodeType);
+
+				var leftType = GetUnconvertedType(binaryExpression.Left);
+				var leftString = Visit(binaryExpression.Left);
+				var rightString = Visit(binaryExpression.Right, leftType);
+
+				return string.Format(
+					"{0} {1} {2}",
+					string.Format(isLeftComposite ? "({0})" : "{0}", leftString),
+					operation,
+					string.Format(isRightComposite ? "({0})" : "{0}", rightString));
+			}
+
+			if (expression is MethodCallExpression)
+			{
+				return GetMethodCall(expression as MethodCallExpression);
+			}
+
+			if (expression is NewExpression)
+			{
+				return GetValue(expression).ToString();
+			}
+
+			throw new InvalidOperationException("Expression is not recognized or supported");
 		}
 	}
 }

File Linq2Rest/Provider/RestQueryProvider.cs

View file
 			_parameterBuilder = new ParameterBuilder(client.ServiceBase);
 		}
 
-		[SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
+		[SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Cannot dispose here.")]
 		public override IQueryable CreateQuery(Expression expression)
 		{
 			if (expression == null)
 			return new RestQueryable<T>(_client, _serializerFactory, expression);
 		}
 
-		[SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope")]
+		[SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Cannot dispose here.")]
 		public override IQueryable<TResult> CreateQuery<TResult>(Expression expression)
 		{
 			if (expression == null)

File Linq2Rest/RuntimeTypeProvider.cs

View file
 		private const MethodAttributes GetSetAttr = MethodAttributes.Final | MethodAttributes.Public;
 		private readonly IMemberNameResolver _nameResolver;
 
+		static RuntimeTypeProvider()
+		{
+			ModuleBuilder = Thread
+				.GetDomain()
+				.DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run)
+				.DefineDynamicModule(AssemblyName.Name);
+		}
+
 		/// <summary>
 		/// Initializes a new instance of the <see cref="RuntimeTypeProvider"/> class.
 		/// </summary>
 			_nameResolver = nameResolver;
 		}
 
-		static RuntimeTypeProvider()
-		{
-			ModuleBuilder = Thread
-				.GetDomain()
-				.DefineDynamicAssembly(AssemblyName, AssemblyBuilderAccess.Run)
-				.DefineDynamicModule(AssemblyName.Name);
-		}
-
 		/// <summary>
 		/// Gets the <see cref="Type"/> matching the provided members.
 		/// </summary>