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