protected When_using_GotoAndLabelExpressions_with_nested_BlockExpression(Func <RemoteLambdaExpression, RemoteLambdaExpression> serialize)
{
ParameterExpression writer = Expression.Parameter(typeof(StreamWriter));
ParameterExpression position = Expression.Variable(typeof(long));
MemberExpression positionProperty = Expression.PropertyOrField(Expression.PropertyOrField(writer, "BaseStream"), "Position");
LabelTarget returnLabel = Expression.Label(typeof(long));
var expression = Expression.Lambda <Func <StreamWriter, long> >(
Expression.Block(
new[] { position },
Expression.IfThen(
Expression.ReferenceEqual(Expression.Constant("SomeText"), Expression.Constant(null, typeof(string))),
Expression.Block(
Expression.Call(typeof(Console).GetMethod(nameof(Console.WriteLine), new[] { typeof(string) }), Expression.Constant("Text is null")),
Expression.Return(returnLabel, Expression.Constant(0L), typeof(long)))),
Expression.Assign(position, positionProperty),
Expression.Call(writer, typeof(TextWriter).GetMethod(nameof(TextWriter.WriteLine), new[] { typeof(string) }), Expression.Constant("SomeText")),
Expression.Return(returnLabel, Expression.Subtract(positionProperty, position), typeof(long)),
Expression.Label(returnLabel, Expression.Default(typeof(long)))), writer);
_originalExpression = expression;
_remoteExpression = expression.ToRemoteLinqExpression();
_serializedRemoteExpression = serialize(_remoteExpression);
}
protected When_using_BlockExpression(Func <RemoteLambdaExpression, RemoteLambdaExpression> serialize)
{
ParameterExpression decimalInputParameter = Expression.Parameter(typeof(decimal));
ParameterExpression formattedDecimalString = Expression.Variable(typeof(string));
Expression <Func <decimal, string> > expression = Expression.Lambda <Func <decimal, string> >(
Expression.Block(
new ParameterExpression[]
{
formattedDecimalString,
},
Expression.Assign(
decimalInputParameter,
Expression.Add(decimalInputParameter, Expression.Constant(1m))),
Expression.Assign(
formattedDecimalString,
Expression.Call(
decimalInputParameter,
typeof(decimal).GetMethod(nameof(decimal.ToString), Type.EmptyTypes))),
Expression.Call(
formattedDecimalString,
typeof(string).GetMethod(nameof(string.Replace), new[] { typeof(char), typeof(char) }),
Expression.Constant('.'),
Expression.Constant(','))),
decimalInputParameter);
_originalExpression = expression;
_remoteExpression = expression.ToRemoteLinqExpression();
_serializedRemoteExpression = serialize(_remoteExpression);
}
protected When_using_LoopExpressions(Func <RemoteLambdaExpression, RemoteLambdaExpression> serialize)
{
ParameterExpression maxRange = Expression.Parameter(typeof(int));
ParameterExpression sum = Expression.Variable(typeof(int));
ParameterExpression i = Expression.Variable(typeof(int));
LabelTarget breakLabel = Expression.Label();
var expression = Expression.Lambda <Func <int, int> >(
Expression.Block(
new[] { sum, i },
Expression.Assign(sum, Expression.Constant(0)),
Expression.Assign(i, Expression.Constant(-1)),
Expression.Loop(
Expression.IfThenElse(
Expression.LessThan(i, maxRange),
Expression.Block(
Expression.PreIncrementAssign(i),
Expression.IfThen(
Expression.Equal(Expression.Modulo(i, Expression.Constant(2)), Expression.Constant(0)),
Expression.AddAssign(sum, i))),
Expression.Break(breakLabel)),
breakLabel),
sum), maxRange);
_originalExpression = expression;
_remoteExpression = expression.ToRemoteLinqExpression();
_serializedRemoteExpression = serialize(_remoteExpression);
}
protected When_using_SwitchExpressions(Func <RemoteLambdaExpression, RemoteLambdaExpression> serialize)
{
ParameterExpression switchOver = Expression.Parameter(typeof(int));
ParameterExpression result = Expression.Variable(typeof(int));
var expression = Expression.Lambda <Func <int, int> >(
Expression.Block(
new[] { result },
Expression.Assign(result, Expression.Constant(0)),
Expression.Switch(
switchOver,
Expression.Assign(result, Expression.Constant(-1)),
Expression.SwitchCase(
Expression.Assign(result, Expression.Constant(1)),
Expression.Constant(0),
Expression.Constant(2)),
Expression.SwitchCase(
Expression.Assign(result, Expression.Constant(2)),
Expression.Constant(1),
Expression.Constant(3))),
result),
switchOver);
_originalExpression = expression;
_remoteExpression = expression.ToRemoteLinqExpression();
_serializedRemoteExpression = serialize(_remoteExpression);
}
protected When_using_TryCatchExpressions(Func <RemoteLambdaExpression, RemoteLambdaExpression> serialize)
{
ParameterExpression shouldFail = Expression.Parameter(typeof(bool));
ParameterExpression result = Expression.Variable(typeof(bool));
var expression = Expression.Lambda <Func <bool, bool> >(
Expression.Block(
new[] { result },
Expression.TryCatch(
Expression.Block(
Expression.IfThen(
Expression.Equal(Expression.Constant(true), shouldFail),
Expression.Throw(Expression.New(typeof(InvalidOperationException)))),
Expression.Assign(result, Expression.Constant(true))),
Expression.Catch(
typeof(InvalidOperationException),
Expression.Assign(result, Expression.Constant(false)))),
result),
shouldFail);
_originalExpression = expression;
_remoteExpression = expression.ToRemoteLinqExpression();
_serializedRemoteExpression = serialize(_remoteExpression);
}
protected When_using_InvokeExpression(Func <RemoteLambdaExpression, RemoteLambdaExpression> serialize)
{
Expression <Func <decimal, bool> > exp = x => x <= 0m;
var parameter = Expression.Parameter(typeof(decimal), "x");
var expression = Expression.Lambda <Func <decimal, bool> >(
Expression.Invoke(exp, parameter), parameter);
_originalExpression = expression;
_remoteExpression = expression.ToRemoteLinqExpression();
_serializedRemoteExpression = serialize(_remoteExpression);
}
private static void LinqQueryWithOpenType()
{
PrintHeader("c) QUERY AN OPEN TYPED DATA SERVICE THE LINQified WAY");
PrintNote("Retrieve orders for product 'Car' having an order quantity bigger than one:");
using var serviceProxy = new ServiceProxy <IRemoteLinqDataService>("net.tcp://localhost:8080/remotelinqdataservice");
System.Linq.Expressions.Expression <Func <Product, bool> > productFilterLinqExpression = product => product.Name == "Car";
Remote.Linq.Expressions.LambdaExpression productFilterRemoteExpression = productFilterLinqExpression.ToRemoteLinqExpression();
IQuery productQuery = new Query(typeof(Product)).Where(productFilterRemoteExpression);
IEnumerable <object> products = serviceProxy.Service.GetData(productQuery);
foreach (Product product in products)
{
PrintLine(_formatter, $" {product}");
System.Linq.Expressions.Expression <Func <Order, bool> > orderFilterLinqExpression =
order => order.Items
.Where(i => i.ProductId == product.Id)
.Sum(i => i.Quantity) > 1;
Remote.Linq.Expressions.LambdaExpression orderFilterRemoteExpression = orderFilterLinqExpression
.ToRemoteLinqExpression()
.ReplaceGenericQueryArgumentsByNonGenericArguments();
IQuery orderQuery = new Query(typeof(Order)).Where(orderFilterRemoteExpression);
IEnumerable <object> orders = serviceProxy.Service.GetData(orderQuery);
PrintLine($" Orders ({orders.Count()}):");
foreach (Order order in orders)
{
PrintLine(_formatter, $" {order}");
foreach (OrderItem item in order.Items)
{
PrintLine(_formatter, $" {item}");
}
}
PrintLine();
}
}
private static void LinqQueryWithOpenType()
{
Console.WriteLine();
Console.WriteLine("QUERY AN OPEN TYPE DATA SERVICE THE LINQified WAY :)");
Console.WriteLine("========================================================================");
using (var serviceProxy = new ServiceProxy <IRemoteLinqDataService>("RemoteLinqDataService"))
{
var service = serviceProxy.Channel;
System.Linq.Expressions.Expression <Func <Product, bool> > productFilterLinqExpression = product => product.Name == "Car";
Remote.Linq.Expressions.LambdaExpression productFilterRemoteExpression = productFilterLinqExpression.ToRemoteLinqExpression();
var productQuery = new Query(typeof(Product)).Where(productFilterRemoteExpression);
var products = service.GetData(productQuery);
Console.WriteLine("List orders for product 'Car' having an order quantity bigger than one:\n");
foreach (Product product in products)
{
Console.WriteLine("\t{0}", product);
System.Linq.Expressions.Expression <Func <Order, bool> > orderFilterLinqExpression = order => order.Items.Where(i => i.ProductId == product.Id).Sum(i => i.Quantity) > 1;
Remote.Linq.Expressions.LambdaExpression orderFilterRemoteExpression = orderFilterLinqExpression.ToRemoteLinqExpression().ReplaceGenericQueryArgumentsByNonGenericArguments();
var orderQuery = new Query(typeof(Order)).Where(orderFilterRemoteExpression);
var orders = service.GetData(orderQuery);
Console.WriteLine("\tOrders ({0}):", orders.Count());
foreach (Order order in orders)
{
Console.WriteLine("\t\t{0}", order);
foreach (var item in order.Items)
{
Console.WriteLine("\t\t\t{0}", item);
}
}
Console.WriteLine();
}
}
}
public Sort(Remote.Linq.Expressions.SortExpression exp)
{
_queryExpression = exp.Operand;
_orderingDirection = exp.SortDirection;
_lambdaExpression = null;
}
public Sort(Remote.Linq.Expressions.LambdaExpression exp, Remote.Linq.Expressions.SortDirection orderingDirection)
{
_queryExpression = exp;
_orderingDirection = orderingDirection;
_lambdaExpression = null;
}
public Filter(Remote.Linq.Expressions.LambdaExpression exp)
{
_queryExpression = exp;
_lambdaExpression = null;
}
private static Remote.Linq.Expressions.LambdaExpression GetOrCreateRemoteExpression(Remote.Linq.Expressions.LambdaExpression remoteExpression, System.Linq.Expressions.LambdaExpression systemExpression)
{
return(remoteExpression ?? ToRemoteExpression(systemExpression));
}
public Filter(System.Linq.Expressions.LambdaExpression exp)
{
_lambdaExpression = exp;
_queryExpression = null;
}
