/// <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));
}
