/// <summary> /// Creates a <see cref="INodeTypeProvider" />. /// </summary> /// <returns>The <see cref="INodeTypeProvider" />.</returns> public virtual INodeTypeProvider Create() { _methodInfoBasedNodeTypeRegistry .Register(TrackingExpressionNode.SupportedMethods, typeof(TrackingExpressionNode)); _methodInfoBasedNodeTypeRegistry .Register(TagExpressionNode.SupportedMethods, typeof(TagExpressionNode)); _methodInfoBasedNodeTypeRegistry .Register(IgnoreQueryFiltersExpressionNode.SupportedMethods, typeof(IgnoreQueryFiltersExpressionNode)); _methodInfoBasedNodeTypeRegistry .Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode)); _methodInfoBasedNodeTypeRegistry .Register(StringIncludeExpressionNode.SupportedMethods, typeof(StringIncludeExpressionNode)); _methodInfoBasedNodeTypeRegistry .Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode)); var innerProviders = new INodeTypeProvider[] { _methodInfoBasedNodeTypeRegistry, MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() }; return(new CompoundNodeTypeProvider(innerProviders)); }
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 CreateFromTypes_UsesPublicStaticField() { var registry = MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(TestExpressionNode) }); Assert.That(registry.RegisteredNamesCount, Is.EqualTo(2)); Assert.That(registry.GetNodeType(typeof(TestExpressionNode).GetMethod("Resolve")), 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); }
public void CreateFromTypes_WithStaticFieldIgnoresStaticFieldFromBaseType() { var registry = MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(DerivedTestExpressionNode) }); Assert.That(registry.RegisteredNamesCount, Is.EqualTo(1)); Assert.That( registry.GetNodeType(typeof(DerivedTestExpressionNode).GetMethod("MethodOnDerivedNode")), Is.SameAs(typeof(DerivedTestExpressionNode))); }
/// <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 innerProviders = new INodeTypeProvider[] { MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(), MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() }; return(new CompoundNodeTypeProvider(innerProviders)); }
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)); }
/// <inheritdoc /> public override INodeTypeProvider Create() { RegisterMethods(IncludeContainingBoundaryExpressionNode.SupportedMethods, typeof(IncludeContainingBoundaryExpressionNode)); var innerProviders = new[] { base.Create(), MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() }; return(new CompoundNodeTypeProvider(innerProviders)); }
/// <summary> /// Creates the node type provider. /// </summary> private static INodeTypeProvider CreateNodeTypeProvider() { var methodInfoRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(); methodInfoRegistry.Register(RemoveAllExpressionNode.GetSupportedMethods(), typeof(RemoveAllExpressionNode)); return(new CompoundNodeTypeProvider(new INodeTypeProvider[] { methodInfoRegistry, MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() })); }
protected void AssertNotSupportedMethods_ByName <T> (IEnumerable <NameBasedRegistrationInfo> supportedMethodNames, params Expression <Func <T> >[] methodExpressions) { var nameBasedRegistry = new MethodNameBasedNodeTypeRegistry(); nameBasedRegistry.Register(supportedMethodNames, typeof(object)); foreach (var methodExpression in methodExpressions) { var methodInfo = ((MethodCallExpression)methodExpression.Body).Method; Assert.That( nameBasedRegistry.GetNodeType(methodInfo), Is.Null, string.Format("Method '{0}.{1}' is supported.", methodInfo.DeclaringType.Name, methodInfo.Name)); } }
private static INodeTypeProvider CreateNodeTypeProvider( MethodInfoBasedNodeTypeRegistry methodInfoBasedNodeTypeRegistry) { methodInfoBasedNodeTypeRegistry .Register(TrackingExpressionNode.SupportedMethods, typeof(TrackingExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode)); var innerProviders = new INodeTypeProvider[] { methodInfoBasedNodeTypeRegistry, MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() }; return(new CompoundNodeTypeProvider(innerProviders)); }
/// <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)); }
private static ReadonlyNodeTypeProvider CreateNodeTypeProvider() { var methodInfoBasedNodeTypeRegistry = MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(); methodInfoBasedNodeTypeRegistry .Register(QueryAnnotationExpressionNode.SupportedMethods, typeof(QueryAnnotationExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(IncludeExpressionNode.SupportedMethods, typeof(IncludeExpressionNode)); methodInfoBasedNodeTypeRegistry .Register(ThenIncludeExpressionNode.SupportedMethods, typeof(ThenIncludeExpressionNode)); var innerProviders = new INodeTypeProvider[] { methodInfoBasedNodeTypeRegistry, MethodNameBasedNodeTypeRegistry.CreateFromRelinqAssembly() }; return(new ReadonlyNodeTypeProvider(new CompoundNodeTypeProvider(innerProviders))); }
public void SetUp() { _registry = new MethodNameBasedNodeTypeRegistry(); }
public void CreateFromTypes_WithoutStaticFieldIgnoresStaticFieldFromBaseType() { var registry = MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(DerivedTestExpressionNodeWithoutStaticField) }); Assert.That(registry.RegisteredNamesCount, Is.EqualTo(0)); }
public void CreateFromTypes_IgnoresNonPublicStaticField() { var registry = MethodNameBasedNodeTypeRegistry.CreateFromTypes(new[] { typeof(TestExpressionNodeWithNonPublicStaticField) }); Assert.That(registry.RegisteredNamesCount, Is.EqualTo(0)); }