private static CompoundNodeTypeProvider CreateNodeTypeProvider() { var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes .Select(ti => ti.AsType()) .ToList(); var methodInfoBasedNodeTypeRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes); methodInfoBasedNodeTypeRegistry .Register(AsNoTrackingExpressionNode.SupportedMethods, typeof(AsNoTrackingExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode)); var innerProviders = new INodeTypeProvider[] { methodInfoBasedNodeTypeRegistry, MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes) }; return(new CompoundNodeTypeProvider(innerProviders)); }
public void Test_UsesPublicStaticField() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(TestExpressionNode) }); Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(1)); Assert.That(registry.GetNodeType(typeof(TestExpressionNode).GetMethod("RegisteredMethod")), Is.SameAs(typeof(TestExpressionNode))); }
protected override Expression VisitMethodCallExpression(MethodCallExpression expression) { var method = expression.Method; Func <MethodCallExpression, IEnumerable> handler; if (method.IsSpecialName && method.Name == "get_Item" && expression.Arguments.Count == 1) { var arg = expression.Arguments[0]; if (arg.NodeType == ExpressionType.Constant && arg.Type == typeof(string)) { if (!(expression.Object is QuerySourceReferenceExpression || expression.Object is ParameterExpression)) { Append(expression.Object, "."); } Append((string)((ConstantExpression)arg).Value); return(expression); } } else if (new INodeTypeProvider[] { MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(ContainsExpressionNode) }), MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(ContainsExpressionNode) }) }.Any(provider => provider.IsRegistered(method))) { Expression source; Expression target; if (expression.Object != null) { source = expression.Object; target = expression.Arguments[0]; } else { source = expression.Arguments[0]; target = expression.Arguments[1]; } var constExpr = source as ConstantExpression; if (constExpr != null) { if (!(constExpr.Value is Array)) { source = Expression.Constant(((IEnumerable)constExpr.Value).Cast <object>().ToArray()); } Append("(", target, " in ", source, ")"); return(expression); } } if (!_methodMappings.TryGetValue(new MethodMappingKey(method.DeclaringType, method.Name), out handler)) { throw new NotSupportedException(string.Format("Method '{0}.{1}' not supported", method.DeclaringType, method.Name)); } Append(handler(expression)); return(expression); }
private static CompoundNodeTypeProvider CreateNodeTypeProvider() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(typeof(RelinqQueryParserFactory).Assembly.GetTypes()); var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider(); nodeTypeProvider.InnerProviders.Add(registry); return(nodeTypeProvider); }
public void Test_WithStaticFieldIgnoresStaticFieldFromBaseType() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(DerivedTestExpressionNode) }); Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(1)); Assert.That( registry.GetNodeType(typeof(DerivedTestExpressionNode).GetMethod("MethodOnDerivedNode")), Is.SameAs(typeof(DerivedTestExpressionNode))); }
public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider() { var types = typeof(MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes(); return(new CompoundNodeTypeProvider( new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromTypes(types), MethodNameBasedNodeTypeRegistry.CreateFromTypes(types) })); }
/// <summary> /// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered. Users can add inner providers to register their own expression node parsers. /// </summary> /// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered.</returns> public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider() { var searchedTypes = typeof(MethodInfoBasedNodeTypeRegistry).GetTypeInfo().Assembly.DefinedTypes.Select(ti => ti.AsType()).ToList(); var innerProviders = new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes), MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes) }; return(new CompoundNodeTypeProvider(innerProviders)); }
public void Test() { MethodInfoBasedNodeTypeRegistry registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes( new[] { typeof(SelectExpressionNode), typeof(WhereExpressionNode) }); Assert.That( registry.RegisteredMethodInfoCount, Is.EqualTo(SelectExpressionNode.SupportedMethods.Length + WhereExpressionNode.SupportedMethods.Length)); AssertAllMethodsRegistered(registry, typeof(SelectExpressionNode)); AssertAllMethodsRegistered(registry, typeof(WhereExpressionNode)); }
/// <summary> /// Creates a default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered. Users can add inner providers to register their own expression node parsers. /// </summary> /// <returns>A default <see cref="CompoundNodeTypeProvider"/> that already has all expression node parser defined by the re-linq assembly /// registered.</returns> public static CompoundNodeTypeProvider CreateDefaultNodeTypeProvider() { Type[] reflectedTypes; try { reflectedTypes = typeof(MethodInfoBasedNodeTypeRegistry).Assembly.GetTypes(); } catch (ReflectionTypeLoadException e) { reflectedTypes = e.Types; } var searchedTypes = reflectedTypes.Where(t => t != null).ToArray(); var innerProviders = new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromTypes(searchedTypes), MethodNameBasedNodeTypeRegistry.CreateFromTypes(searchedTypes) }; return(new CompoundNodeTypeProvider(innerProviders)); }
public void Test_WithoutStaticFieldIgnoresStaticFieldFromBaseType() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(DerivedTestExpressionNodeWithoutStaticField) }); Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(0)); }
public void Test_IgnoresNonPublicStaticField() { var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(TestExpressionNodeWithNonPublicStaticField) }); Assert.That(registry.RegisteredMethodInfoCount, Is.EqualTo(0)); }
public void SetUp() { _methodInfoBasedNodeTypeRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(typeof(SelectExpressionNode).Assembly.GetTypes()); }