/// <summary>
/// Creates a <see cref="IProjection" /> for the given <see cref="Expression" />.
/// </summary>
/// <param name="expression">
/// The expression.
/// </param>
/// <param name="context">
/// The context for the projection.
/// </param>
/// <returns>
/// The resolved <see cref="IProjection" /> instance.
/// </returns>
/// <exception cref="NotSupportedException">
/// The <see cref="Expression" /> could not be resolved as it may contain unsupported features or similar.
/// </exception>
public static IProjection GetProjection
(
Expression expression,
HelperContext context
)
{
IEnumerable <IExpressionHandler> handlers = FlowQueryHelper
.GetExpressionHandlers(expression.NodeType)
.Where(x => x.CanHandleProjectionOf(expression, context))
.ToArray();
if (handlers.Any())
{
return(GetProjectionUsing(handlers, expression, context));
}
if (expression.NodeType == ExpressionType.Parameter && expression.ToString() == context.RootAlias)
{
throw new NotSupportedException
(
"Unable to select the root entity like 'x => x', select without an expression instead"
);
}
return(GetValueProjection(expression));
}
public void CanClearCustomMethodCallHandlers()
{
var handler = new SimpleMethodCallHandler();
// add one and assert added
FlowQueryHelper.AddExpressionHandler(ExpressionType.Call, handler);
IEnumerable <IExpressionHandler> handlers = FlowQueryHelper
.GetExpressionHandlers(ExpressionType.Call);
Assert.That(handlers, Has.Member(handler));
// clear the list and assert empty
FlowQueryHelper.ClearExpressionHandlers();
handlers = FlowQueryHelper.GetExpressionHandlers(ExpressionType.Call);
Assert.That(handlers, Has.No.Member(handler));
// add again and assert added
FlowQueryHelper.AddExpressionHandler(ExpressionType.Call, handler);
handlers = FlowQueryHelper.GetExpressionHandlers(ExpressionType.Call);
Assert.That(handlers, Has.Member(handler));
}
public void CanUseFlowQueryHelperProject()
{
Expression <Func <UserEntity, UserDto> > expression = x => new UserDto
{
Fullname = x.Firstname + " " + x.Lastname,
Id = x.Id,
IsOnline = x.IsOnline,
SettingId = x.Setting.Id,
Username = x.Username
};
var helper = new FlowQueryHelper();
var users = Query <UserEntity>()
.Select(x => new
{
Value = helper.Project(x, expression)
});
Assert.That(users.Count(), Is.EqualTo(4));
foreach (var user in users)
{
Assert.That(user.Value, Is.Not.Null);
}
Assert.That(users.ElementAt(0).Value.Fullname, Is.EqualTo(Fullnames[0]));
Assert.That(users.ElementAt(1).Value.Fullname, Is.EqualTo(Fullnames[1]));
Assert.That(users.ElementAt(2).Value.Fullname, Is.EqualTo(Fullnames[2]));
Assert.That(users.ElementAt(3).Value.Fullname, Is.EqualTo(Fullnames[3]));
}
public virtual void Setup()
{
// to always start on a clean slate
FlowQueryHelper.ClearExpressionHandlers();
_sessionFactory = NHibernateConfigurer.GetSessionFactory();
OnSetup();
}
public void AddMethodCallHandlerThrowsIfResolverIsNull()
{
Assert
.That
(
() => FlowQueryHelper.AddExpressionHandler(ExpressionType.Call, null),
Throws.InstanceOf <ArgumentNullException>()
);
}
public void UsingFlowQueryHelperProjectWithNullExpressionThrows()
{
Expression <Func <UserEntity, UserDto> > expression = null;
var helper = new FlowQueryHelper();
Assert
.That
(
() => Query <UserEntity>().Select(x => helper.Project(x, expression)),
Throws.InstanceOf <NotSupportedException>()
);
}
public void UsingFlowQueryHelperProjectDirectlyThrows()
{
Expression <Func <UserEntity, UserDto> > expression = x => new UserDto();
UserEntity y = null;
var helper = new FlowQueryHelper();
Assert
.That
(
() => helper.Project(y, expression),
Throws.InstanceOf <NotImplementedException>()
);
}
public void CanAddCustomHandlerToOverrideDefaulImplementationWithConstruction()
{
FlowQueryHelper.AddExpressionHandler(ExpressionType.Call, new SimpleMethodCallHandler());
var users = Query <UserEntity>()
.Select(x => new
{
Value = x.Id.ToString()
});
Assert.That(users.Count(), Is.EqualTo(4));
foreach (var user in users)
{
Assert.That(user.Value, Is.EqualTo("Hello World"));
}
}
public void Example1()
{
// add the handler
FlowQueryHelper.AddExpressionHandler(ExpressionType.Call, new ToStringHandler());
var userIds = Session.FlowQuery <UserEntity>()
.Select(x => new
{
IdAsString = x.Id.ToString()
});
Assert.That(userIds.Count(), Is.EqualTo(4));
Assert.That(userIds.ElementAt(0).IdAsString, Is.EqualTo("1"));
Assert.That(userIds.ElementAt(1).IdAsString, Is.EqualTo("2"));
Assert.That(userIds.ElementAt(2).IdAsString, Is.EqualTo("3"));
Assert.That(userIds.ElementAt(3).IdAsString, Is.EqualTo("4"));
}
/// <summary>
/// Invokes the provided <see cref="Expression" /> with the provided arguments.
/// </summary>
/// <param name="expression">
/// The <see cref="Expression" /> expression.
/// </param>
/// <param name="arguments">
/// The constructor arguments.
/// </param>
/// <param name="value">
/// The generated instance.
/// </param>
/// <returns>
/// The number of arguments used.
/// </returns>
public static int Invoke
(
Expression expression,
object[] arguments,
out object value
)
{
IEnumerable <IExpressionHandler> handlers = FlowQueryHelper
.GetExpressionHandlers(expression.NodeType)
.Where(x => x.CanHandleConstructionOf(expression))
.ToArray();
if (handlers.Any())
{
return(ConstructUsing(handlers, expression, arguments, out value));
}
value = arguments[0];
return(1);
}
public void CanAddCustomHandlerToOverrideDefaulImplementationProjectionOnly()
{
var mockedResolver = new Mock <IExpressionHandler>(MockBehavior.Loose);
mockedResolver
.Setup
(
resolver =>
resolver
.Project(It.IsAny <MethodCallExpression>(), It.IsAny <HelperContext>())
)
.Returns(Projections.Constant(123));
mockedResolver
.Setup
(
resolver =>
resolver
.CanHandleProjectionOf(It.IsAny <MethodCallExpression>(), It.IsAny <HelperContext>())
)
.Returns(true);
FlowQueryHelper.AddExpressionHandler(ExpressionType.Call, mockedResolver.Object);
var users = Query <UserEntity>()
.Select(x => new
{
Hash = x.GetHashCode()
});
Assert.That(users.Count(), Is.EqualTo(4));
mockedResolver.VerifyAll();
foreach (var user in users)
{
Assert.That(user.Hash, Is.EqualTo(123));
}
}
public void Given_UnsupportedExpressionType_When_GettingExpressionHandlers_Then_ReturnsEmptySetOfHandlers()
{
var handlers = FlowQueryHelper.GetExpressionHandlers(ExpressionType.NewArrayBounds);
Assert.That(handlers.Count(), Is.EqualTo(0));
}
