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