public void convert_values_evaluates_expression_to_obtain_value() { var converter = new ExpressionConverter(); converter.Expression = "2 * {0} + {1} - {2}"; Assert.Equal(22, converter.Convert(new object[] { 10, 3, 1 }, null, null, null)); Assert.Equal(-22, converter.Convert(new object[] { -10, -3, -1 }, null, null, null)); Assert.Equal(22d, converter.Convert(new object[] { 10d, 3, 1 }, null, null, null)); }
public void convert_value_evaluates_expression_to_obtain_value() { var converter = new ExpressionConverter(); converter.Expression = "2 * {0}"; Assert.Equal(10, converter.Convert(5, null, null, null)); Assert.Equal(-10, converter.Convert(-5, null, null, null)); Assert.Equal(10d, converter.Convert(5d, null, null, null)); }
public void convert_value_evaluates_expression_to_obtain_value() { var converter = new ExpressionConverter(); converter.Expression = "2 * {0}"; Assert.Equal(10, converter.Convert(5, null, null, null)); Assert.Equal(-10, converter.Convert(-5, null, null, null)); Assert.Equal(10d, converter.Convert(5d, null, null, null)); }
public void convert_values_evaluates_expression_to_obtain_value() { var converter = new ExpressionConverter(); converter.Expression = "2 * {0} + {1} - {2}"; Assert.Equal(22, converter.Convert(new object[] { 10, 3, 1 }, null, null, null)); Assert.Equal(-22, converter.Convert(new object[] { -10, -3, -1 }, null, null, null)); Assert.Equal(22d, converter.Convert(new object[] { 10d, 3, 1 }, null, null, null)); }
public DalCategory GetByPredicate(Expression <Func <DalCategory, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalCategory, Category>(predicate); var category = _context.Set <Category>().FirstOrDefault(newExpression); return(category.ToDalCategory()); }
public DalUser GetByPredicate(Expression <Func <DalUser, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalUser, User>(predicate); var user = _context.Set <User>().FirstOrDefault(newExpression); return(user.ToDalUser()); }
public DalPurchase GetByPredicate(Expression <Func <DalPurchase, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalPurchase, Purchase>(predicate); var purchase = _context.Set <Purchase>().FirstOrDefault(newExpression); return(purchase.ToDalPurchase()); }
public DalBid GetByPredicate(Expression <Func <DalBid, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalBid, Bid>(predicate); var bid = _context.Set <Bid>().FirstOrDefault(newExpression); return(bid.ToDalBid()); }
public DalRole GetByPredicate(Expression <Func <DalRole, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalRole, Role>(predicate); var role = _context.Set <Role>().FirstOrDefault(newExpression); return(role.ToDalRole()); }
public void convert_values_throws_if_expression_is_null() { var converter = new ExpressionConverter(); var ex = Assert.Throws <InvalidOperationException>(() => converter.Convert(new object[] { 123, 89 }, null, null, null)); Assert.Equal("No Expression has been specified.", ex.Message); }
public DalComment GetByPredicate(Expression <Func <DalComment, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalComment, Comment>(predicate); var comment = _context.Set <Comment>().FirstOrDefault(newExpression); return(comment.ToDalComment()); }
/// <summary> /// Converts an expression to an expression node. /// </summary> /// <param name="expression">The expression.</param> /// <param name="factorySettings">The factory settings to use.</param> /// <returns></returns> public static ExpressionNode ToExpressionNode(this Expression expression, FactorySettings factorySettings = null) { var converter = new ExpressionConverter(); return(converter.Convert(expression, factorySettings)); }
public DalLot GetByPredicate(Expression <Func <DalLot, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalLot, Lot>(predicate); var lot = _context.Set <Lot>().FirstOrDefault(newExpression); return(lot.ToDalLot()); }
public DalExceptionInformation GetByPredicate(Expression <Func <DalExceptionInformation, bool> > predicate) { var newExpression = ExpressionConverter.Convert <DalExceptionInformation, ExceptionInformation>(predicate); var exeption = _context.Set <ExceptionInformation>().FirstOrDefault(newExpression); return(exeption.ToDalExceptionInformation()); }
public void TaskConverterEntityToModelWithStructureTest() { IJsonConverter jsonConverter = new JsonConverter(LoggerFactory); ICachedExpressionCompiler cachedExpressionCompiler = new CachedExpressionCompiler(LoggerFactory); IExpressionConverter expressionConverter = new ExpressionConverter(jsonConverter, cachedExpressionCompiler, LoggerFactory); ITaskConverter taskConverter = new TaskConverter(expressionConverter, jsonConverter, LoggerFactory); TestTaskConverterClass instance = new TestTaskConverterClass(); ActivationData activationData = expressionConverter.Convert(() => instance.MethodJustClass(TaskCancellationToken.Null)); TaskModel taskModel = new TaskModel(1, 2, 3, activationData, TaskStates.New, new ScheduleInformation(1)); TaskEntity taskEntity = taskConverter.Convert(taskModel); Assert.IsNotNull(taskEntity); TaskModel actual = taskConverter.Convert(taskEntity); Assert.IsNotNull(actual); Assert.AreEqual(taskEntity.Id, actual.Id); Assert.AreEqual(taskEntity.QueueId, actual.QueueId); Assert.AreEqual(taskEntity.TaskState, actual.TaskState); }
public void Set <TValue>(EntityField <T> schemaField, Expression <Func <T, TValue> > valueExpression) { var valueExpressionResult = ExpressionConverter.Convert(valueExpression); AddFieldAssignment( QueryExpression.Column(schemaField.Column.Name), valueExpressionResult.QueryExpression ); }
protected override TypeUsage GetResultType() { // Since this method is only called once, on demand, a full conversion pass // is performed to produce the DbExpression and return its result type. // This does not affect any cached execution plan or closure bindings that may be present. ExpressionConverter converter = this.CreateExpressionConverter(); return(converter.Convert().ResultType); }
public void Now_something_a_bit_more_advanced() { var convert = new ExpressionConverter(); var fieldService = new FieldService(); convert.MapToArray("fieldService.GetField", "felter"); Expression<Func<Field>> bodyExpr = () => fieldService.GetField(123); string javascript = convert.Convert(bodyExpr); File.WriteAllText(@"c:\temp\Now_something_a_bit_more_advanced.js", string.Format("var foo = {0};", javascript)); Assert.IsNotNull(javascript); }
public void Should_convert_simple_expression_to_javascript_function() { var convert = new ExpressionConverter(); int a, b, c; a = b = c = 5; Expression<Func<int>> expression = () => a + b - c * a / b; var result = expression.Compile()(); string javascript = convert.Convert(expression); Assert.AreEqual("function() {a+b-c*a/b}", javascript); }
/// <summary> /// Method GetByPredicate return DalCategoryPhoto by predicate. /// </summary> /// <param name="f">Predicate.</param> /// <returns>Return DalCategoryPhoto by predicate f.</returns> public DalCategoryPhoto GetByPredicate(Expression <Func <DalCategoryPhoto, bool> > f) { var convert = ExpressionConverter.Convert <DalCategoryPhoto, CategoryPhoto>(f); CategoryPhoto item = context.Set <CategoryPhoto>().SingleOrDefault(convert); return(new DalCategoryPhoto { Name = item.Name, Id = item.Id }); }
public bool DeleteDepartment(Expression <Func <DTO_TB_DEPARTMENT, bool> > selector = null) { if (selector == null) { return(false); } ExpressionConverter expressionConverter = new ExpressionConverter(); ExpressionNode expressionNode = expressionConverter.Convert(selector); return(oService.DeleteDeptByLamada(expressionNode)); }
public bool DeleteUser(Expression <Func <DTO_TB_USERS, bool> > selector = null) { if (selector == null) { return(false); } ExpressionConverter expressionConverter = new ExpressionConverter(); ExpressionNode expressionNode = expressionConverter.Convert(selector); return(oService.DeleteUserByLamada(expressionNode)); }
//将lamada表达式转换为可用于WCF传递的ExpressionNode类型 private ExpressionNode GetExpressionNode <Dto>(Expression <Func <Dto, bool> > selector) { if (selector == null) { return(null); } ExpressionConverter expressionConverter = new ExpressionConverter(); ExpressionNode expressionNode = expressionConverter.Convert(selector); return(expressionNode); }
public void OrElse(EntityField <T> schemaField, ComparisonOperator @operator, Expression <Func <T, bool> > valueExpression) { var valueExpressionResult = ExpressionConverter.Convert(valueExpression); OrElse(QueryExpression.Compare( QueryExpression.Column(schemaField.Column.Name, schemaField.Source.AliasIdentifierExpression), @operator, valueExpressionResult.QueryExpression )); AddJoin(schemaField.Source); }
private IList <ObjectModel.Contract> QueryData(Expression <Func <Contract, bool> > filter, Expression <Func <Contract, ObjectModel.Contract> > selector) { var newfilter = ExpressionConverter <Contract> .Convert(filter); var dao = new ContractRepository(); var dataList = dao.Query(newfilter, p => new ObjectModel.Contract { //write something }).ToList(); return(dataList); }
private IList <ObjectModel.Employee> QueryData(Expression <Func <Employee, bool> > filter, Expression <Func <Employee, ObjectModel.Employee> > selector) { var newfilter = ExpressionConverter <Employee> .Convert(filter); var dao = new EmployeeRepository(); var dataList = dao.Query(newfilter, p => new ObjectModel.Employee { //write something }).ToList(); return(dataList); }
private IList <ObjectModel.DataDictionary> QueryData(Expression <Func <DataDictionary, bool> > filter, Expression <Func <DataDictionary, ObjectModel.DataDictionary> > selector) { var newfilter = ExpressionConverter <DataDictionary> .Convert(filter); var dao = new DataDictionaryRepository(); var dataList = dao.Query(newfilter, p => new ObjectModel.DataDictionary { //write something }).ToList(); return(dataList); }
public void Set <TProperty>(Expression <Func <T, TProperty> > fieldSelector, QueryExpression queryExpression) { var selectorExpressionResult = ExpressionConverter.Convert(fieldSelector); if (selectorExpressionResult.QueryExpression is ColumnExpression columnExpression) { AddFieldAssignment( columnExpression, queryExpression ); return; } throw new ArgumentException("Field selector doesn't specify a valid column.", nameof(fieldSelector)); }
public ObjectModel.Contract GetSingleOrDefault(Expression <Func <ObjectModel.Contract, bool> > filter, string orderBy) { var newfilter = ExpressionConverter <Contract> .Convert(filter); var dao = new ContractRepository(); int recordCount = 0; var data = dao.QueryByPage(newfilter, orderBy, 1, 1, out recordCount).ToList().FirstOrDefault(); if (null == data) { return(null); } var list = new List <ObjectModel.Contract>(); var rmodel = new ConvertModel(); return(rmodel.ReturnModel <ObjectModel.Contract, Contract>(data)); }
public void ConvertExpression_UserDto_To_UserDb() { // arrange Expression <Func <UserDto, bool> > userDtoPredicate = dto => (dto.UserName.Contains("a") && dto.UserName.StartsWith("b")) || dto.Id == "id"; var expressionConverter = new ExpressionConverter <UserDto, UserDb>(); // act var result = expressionConverter.Convert(userDtoPredicate); // assert Expression <Func <UserDb, bool> > expectedPredicate = p => (p.UserName.Contains("a") && p.UserName.StartsWith("b")) || p.Id == "id"; result.Should().NotBeNull(); result.Should().BeEquivalentTo(expectedPredicate); }
public void ConvertExpression_RunDto_To_RunDb() { // arrange Expression <Func <RunDto, bool> > runDtoPredicate = dto => (dto.Distance > 4 && dto.Latitude < 10.10) || dto.Id == 5; var expressionConverter = new ExpressionConverter <RunDto, RunDb>(); // act var result = expressionConverter.Convert(runDtoPredicate); // assert Expression <Func <RunDb, bool> > expectedPredicate = p => (p.Distance > 4 && p.Latitude < 10.10) || p.Id == 5; result.Should().NotBeNull(); result.Should().BeEquivalentTo(expectedPredicate); }
private static void StaticQueryTest() { Console.WriteLine("StaticQueryTest"); var client = new WebApiClient(); var list = new List <CustomerDto>().AsQueryable(); var id = new ConstantPlaceHolder <long>() { Value = 1 }; var desc = new ConstantPlaceHolder <string>() { Value = "s" }; var query = list .Where( x => x.Id > id.Value && x.Firma11.Contains(desc.Value) && x.Contacts.Any(y => y.Id > id.Value && y.FirstName.Contains(desc.Value)) || x.Firma21.Contains("h")).Select(x => new Projection() { Id = x.Id, Firma1 = x.Firma11 }) .Expression; var c = new ExpressionConverter(); var root = c.Convert(query); var customers = client.GetTest <Projection>(new QDescriptor() { Root = root }); if (customers == null) { return; } foreach (var customer in customers) { Console.WriteLine("id={0} firma1={1}", customer.Id, customer.Firma1); } }
/// <summary> /// Generate the low-level assignments code from the low-level optimized macro code /// </summary> private void GenerateProcessingCode() { ExpressionConverter.ActiveCodeBlock = CodeBlock; //Iterate over optimized low-level computations foreach (var computedVar in CodeBlock.ComputedVariables) { //Convert the rhs text expression tree into target language code var rhsExprCode = ExpressionConverter.Convert(computedVar.RhsExpr); //Create the codeInfo object var codeInfo = new GMacComputationCodeInfo() { ComputedVariable = computedVar, RhsExpressionCode = rhsExprCode, GMacLanguage = GMacLanguage, EnableCodeGeneration = true }; //Generate the assignment target code based on the codeInfo object //Execute this action before generating computation code if (ReferenceEquals(ActionBeforeGenerateSingleComputation, null) == false) { ActionBeforeGenerateSingleComputation(SyntaxList, codeInfo); } //If the action prevented generation of code don't generating computation code if (codeInfo.EnableCodeGeneration) { GenerateSingleComputationCode(codeInfo); } //Execute this action after generating computation code if (ReferenceEquals(ActionAfterGenerateSingleComputation, null) == false) { ActionAfterGenerateSingleComputation(SyntaxList, codeInfo); } } SyntaxList.AddEmptyLine(); }
public IList <ObjectModel.Contract> Query(Expression <Func <ObjectModel.Contract, bool> > filter) { var newfilter = ExpressionConverter <Contract> .Convert(filter); var dao = new ContractRepository(); var rmodel = new ConvertModel(); var list = new List <ObjectModel.Contract>(); var dataList = dao.Query(newfilter).ToList(); if (null == dataList) { return(null); } foreach (var vartemp in dataList) { var omContract = rmodel.ReturnModel <ObjectModel.Contract, Contract>(vartemp); list.Add(omContract); } return(list); }
public void convert_values_throws_if_expression_is_null() { var converter = new ExpressionConverter(); var ex = Assert.Throws<InvalidOperationException>(() => converter.Convert(new object[] { 123, 89 }, null, null, null)); Assert.Equal("No Expression has been specified.", ex.Message); }