public static Expression DeserializeLinqExpression(string expressionString) { var serializer = new ExpressionSerializer(new JsonSerializer()); var expression = serializer.DeserializeText(expressionString); return(expression); }
private static void DoSerializeThenDeserialize <T>(Expression <Func <T, bool> > predicate) { var expressionSerializer = new ExpressionSerializer(new JsonSerializer()); var serialized = expressionSerializer.SerializeText(predicate); expressionSerializer.DeserializeText(serialized); }
private void TestExpression(Expression <Func <Test, bool> > expression, ReadFieldOn readFieldOn) { var initialValue = 42; var actualValue = -1; // Initialize fields SetFields(initialValue); // Serialize expression var settings = new FactorySettings { AllowPrivateFieldAccess = true }; var serializer = new ExpressionSerializer(new JsonSerializer()); var value = serializer.SerializeText(expression, settings); // Modify fields SetFields(actualValue); // Deserialize expression var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value, new ExpressionContext { AllowPrivateFieldAccess = true }); var func = actualExpression.Compile(); // Set expected value. int expectedValue = readFieldOn == ReadFieldOn.Serialization ? initialValue : actualValue; // Assert Assert.IsTrue(func(new Test { IntProperty = expectedValue })); }
public void SerializeLambdaWithNullableTest() { foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); var fish = new[] { new Fish { Count = 0 }, new Fish { Count = 1 }, new Fish(), new Fish { Count = 1 } }; int?count = 1; Expression <Func <Fish, bool> > expectedExpression = f => f.Count == count; var expected = fish.Where(expectedExpression.Compile()).Count(); var serialized = serializer.SerializeText(expectedExpression); var actualExpression = (Expression <Func <Fish, bool> >)serializer.DeserializeText(serialized); var actual = fish.Where(actualExpression.Compile()).Count(); Assert.Equal(expected, actual); } }
private static Expression SerializeDeserializeExpressionAsText(Expression expression, ISerializer serializer) { var expressionSerializer = new ExpressionSerializer(serializer); var serialized = expressionSerializer.SerializeText(expression); return(expressionSerializer.DeserializeText(serialized)); }
public void SerializeWithDateTimeLocalTest() { foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); var yarrs = new[] { new Yarr { Date = new DateTime(3000, 1, 1) }, new Yarr { Date = new DateTime(2000, 1, 1) }, new Yarr(), new Yarr { Date = DateTime.Now.AddYears(1) } }; var date = DateTime.Now; Expression <Func <Yarr, bool> > expectedExpression = f => f.Date > date; var expected = yarrs.Where(expectedExpression.Compile()).Count(); var serialized = serializer.SerializeText(expectedExpression); var actualExpression = (Expression <Func <Yarr, bool> >)serializer.DeserializeText(serialized); var actual = yarrs.Where(actualExpression.Compile()).Count(); Assert.Equal(expected, actual); } }
public void SerializeDeserializeListAsXml() { var guid1 = Guid.NewGuid(); var guid2 = Guid.NewGuid(); var guid3 = Guid.NewGuid(); var list = new List <Guid> { guid1, guid2 }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Id); var serializer = new ExpressionSerializer(new XmlSerializer()) { AutoAddKnownTypesAsListTypes = true }; var value = serializer.SerializeText(expression); var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value); var func = actualExpression.Compile(); Assert.IsTrue(func(new Test { Id = guid1 }), "one failed."); Assert.IsTrue(func(new Test { Id = guid2 }), "two failed."); Assert.IsFalse(func(new Test { Id = guid3 }), "three failed."); }
public void LetExpressionTests() { var expressions = new List <Expression>(); Expression <Func <IEnumerable <int>, IEnumerable <int> > > intExpr = c => from x in c let test = 8 where x == test select x; expressions.Add(intExpr); Expression <Func <IEnumerable <string>, IEnumerable <string> > > strExpr = c => from x in c let test = "bar" where x == test select x; expressions.Add(strExpr); foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); foreach (var expected in expressions) { var serialized = serializer.SerializeText(expected); var actual = serializer.DeserializeText(serialized); ExpressionAssert.AreEqual(expected, actual); } } }
public void SerializeLambdaWithEnumTest() { foreach (var serializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { serializer.AddKnownType(typeof(Gender)); var expressionSerializer = new ExpressionSerializer(serializer); var fish = new[] { new ItemWithEnum { Gender = Gender.Male }, new ItemWithEnum { Gender = Gender.Female }, new ItemWithEnum(), new ItemWithEnum { Gender = Gender.Female } }; var some = Gender.Female; Expression <Func <ItemWithEnum, bool> > expectedExpression = f => f.Gender == some; var expected = fish.Where(expectedExpression.Compile()).Count(); var serialized = expressionSerializer.SerializeText(expectedExpression); // throws SerializationException var actualExpression = (Expression <Func <ItemWithEnum, bool> >)expressionSerializer.DeserializeText(serialized); var actual = fish.Where(actualExpression.Compile()).Count(); Assert.Equal(expected, actual); } }
public BaseRepository(IHttpContextAccessor httpContextAccessor, IMemoryCache memoryCache, IPermissionCacheService permissionCacheService) { _context = httpContextAccessor.HttpContext.RequestServices.GetService <TDbContext>(); _dataSet = _context.Set <TEntity>(); var userName = httpContextAccessor.HttpContext.User.GetClaimValue(CustomClaimTypes.UserName); if (!string.IsNullOrEmpty(userName)) { // 表达式合集 var expressionList = new List <LambdaExpression>(); // 取得用户的数据规则 var permissions = permissionCacheService.GetRuleAsync(typeof(TDbContext).Name, typeof(TEntity).Name).Result; // 所有规则组 foreach (var groupRuleStr in permissions) { // 表达式反序列化 var serializer = new ExpressionSerializer(new JsonSerializer()); serializer.AddKnownType(typeof(Core.Expressions.ExpressionType)); var lambda = (LambdaExpression)serializer.DeserializeText(groupRuleStr); expressionList.Add(lambda); } // 连接lambda表达式生成统一条件 if (expressionList.Count > 0) { _condition = (Expression <Func <TEntity, bool> >)(new ExpressionUtil <TEntity>() .JoinLambdaExpression(expressionList, ExpressionCombineType.And)); } } }
public void SerializeDeserializeListAsJson() { var list = new List <string> { "one", "two" }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Code); var serializer = new ExpressionSerializer(new JsonSerializer()) { AutoAddKnownTypesAsListTypes = true }; var value = serializer.SerializeText(expression); var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value); var func = actualExpression.Compile(); Assert.IsTrue(func(new Test { Code = "one" }), "one failed."); Assert.IsTrue(func(new Test { Code = "two" }), "two failed."); Assert.IsFalse(func(new Test { Code = "three" }), "three failed."); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer) { var str = serializer.Deserialize <string>(reader); var expressionSerializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer()); var expression = expressionSerializer.DeserializeText(str); return(expression); }
public void DefaultExpressionsCanBeDeserialized() { var expected = Expression.Default(typeof(int)); var expressionSerializer = new ExpressionSerializer(new JsonSerializer()); var actual = expressionSerializer.DeserializeText(expressionSerializer.SerializeText(expected)); ExpressionAssert.AreEqual(expected, actual); }
public override object Execute(Expression expression) { var command = GetQueryText(expression); var deserializer = new ExpressionSerializer(new JsonSerializer()); var deserialized = deserializer.DeserializeText(command); return(Expression.Lambda(deserialized).Compile().DynamicInvoke()); }
private void SerialzeAndDeserializeDateTimeJson(DateTime dt) { Expression <Func <DateTime> > actual = () => dt; actual = actual.Update(Expression.Constant(dt), new List <ParameterExpression>()); var serialized = _jsonExpressionSerializer.SerializeText(actual); var expected = _jsonExpressionSerializer.DeserializeText(serialized); ExpressionAssert.AreEqual(expected, actual); }
internal object InvokeBooleanExpression(string typeFullName, string expressionNode) { var type = GetType(typeFullName); var serializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer()); var expression = serializer.DeserializeText(expressionNode).ToExpressionNode(); MethodInfo method = typeof(ExpressionNode).GetMethod("ToBooleanExpression"); MethodInfo generic = method.MakeGenericMethod(type); var booleanExpression = generic.Invoke(expression, new object[] { null }); return(booleanExpression); }
public void ExpressionTest() { Expression <Func <int, bool> > exp1 = v => (v > 0 && v > 100) || v != 0; var serializer = new ExpressionSerializer(new JsonSerializer()); var data = serializer.SerializeText(exp1); Console.WriteLine(data.Length); var exp2 = serializer.DeserializeText(data); Console.WriteLine("exp2:" + exp2.ToJson()); }
public override void Enqueue(IEnumerable <TexeraTuple> output) { if (selector == null) { var serializer = new ExpressionSerializer(new JsonSerializer()); var actualExpression = serializer.DeserializeText(selectorExpression); selector = ((Expression <Func <TexeraTuple, int> >)actualExpression).Compile(); } foreach (TexeraTuple tuple in output) { int idx = NonNegativeModular(selector(tuple), outputRows.Count); outputRows[idx].Enqueue(tuple); } }
public void NullableDecimalTest() { foreach (var textSerializer in CreateTextSerializers()) { var serializer = new ExpressionSerializer(textSerializer); var expected = Expression.Constant(0m, typeof(Decimal?)); var text = serializer.SerializeText(expected); TestContext.WriteLine("{0} serializes to text with length {1}: {2}", expected, text.Length, text); var actual = serializer.DeserializeText(text); Assert.IsNotNull(actual, "Input expression was {0}, but output is null for '{1}'", expected, textSerializer.GetType()); ExpressionAssert.AreEqual(expected, actual); } }
public void TestExpressionSerialization() { var serializer = new ExpressionSerializer(new Serialize.Linq.Serializers.JsonSerializer()); var @event = new MajorEventOccured() { Severity = Severity.Error, Message = "Oh no!" }; Expression <Func <MajorEventOccured, bool> > exp2 = (s) => true; var serialized = serializer.SerializeText(exp2); var exp = serializer.DeserializeText(serialized); var func = (exp as Expression <Func <MajorEventOccured, bool> >).Compile(); Assert.True(func(@event)); }
static void Main(string[] args) { // No need to do this : ExpressionExtensions.AssemblyLoader = new NetCoreAppAssemblyLoader(); Expression expression = Expression.Parameter(typeof(Person), "x"); // Serialize expression var serializer = new ExpressionSerializer(new JsonSerializer()); string value = serializer.SerializeText(expression); Console.WriteLine("value:" + value); // Deserialize expression var actualExpression = serializer.DeserializeText(value); Console.WriteLine("actualExpression:" + actualExpression.ToJson()); }
public override void Enqueue(List <TexeraTuple> output) { if (selector == null) { var serializer = new ExpressionSerializer(new JsonSerializer()); var actualExpression = serializer.DeserializeText(selectorExpression); selector = ((Expression <Func <TexeraTuple, int> >)actualExpression).Compile(); } int limit = output.Count; int modlimit = outputRows.Count; int i = 0; for (i = 0; i < limit; ++i) { int idx = NonNegativeModular(selector(output[i]), modlimit); outputRows[idx].Enqueue(output[i]); } }
static void Main(string[] args) { Expression expression = Expression.Parameter(typeof(Person), "x"); // Serialize expression var serializer = new ExpressionSerializer(new JsonSerializer()); string value = serializer.SerializeText(expression); Console.WriteLine("value:" + value); // This is needed for NETStandard 1.x and NETCoreApp 1.x var expressionContext = new ExpressionContext(new NetCoreAppAssemblyLoader()); // Deserialize expression var actualExpression = serializer.DeserializeText(value, expressionContext); Console.WriteLine("actualExpression:" + actualExpression.ToJson()); }
public static Expression <Func <T, bool> > DeserializeWhere(string json) { Expression <Func <T, bool> > expression = null; foreach (var textSerializer in new ITextSerializer[] { new Serialize.Linq.Serializers.JsonSerializer() }) { json = json.Replace("BrandFullMobile.Model", "WebServices.ViewModels"); try { var serializer = new ExpressionSerializer(textSerializer); expression = (Expression <Func <T, bool> >)serializer.DeserializeText(json); } catch (Exception e) { return(null); } } return(expression); }
public Task Initialize() { string currentDir = Environment.CurrentDirectory; sws = new StreamWriter[numBuckets]; if (!Directory.Exists(currentDir + "/" + id.ToString())) { Directory.CreateDirectory(currentDir + "/" + id.ToString()); } for (int i = 0; i < numBuckets; ++i) { string pathName = currentDir + "/" + id + "/" + idx + "_" + i + ".tmp"; sws[i] = new StreamWriter(pathName, false, new UTF8Encoding(false), 65536); } var serializer = new ExpressionSerializer(new JsonSerializer()); var actualExpression = serializer.DeserializeText(serializedHashFunc); hashFunc = ((Expression <Func <TexeraTuple, int> >)actualExpression).Compile(); return(Task.CompletedTask); }
public static Expression <Func <T, object> > DeserializeOrderBy(string json) { Expression <Func <T, object> > expression = null; foreach (var textSerializer in new ITextSerializer[] { new Serialize.Linq.Serializers.JsonSerializer() }) { json = json.Replace("WMS.Models.BaseTables", "BLL.Models"); json = json.Replace("WMS.Models", "WmsPosApi.Models"); try { var serializer = new ExpressionSerializer(textSerializer); expression = (Expression <Func <T, object> >)serializer.DeserializeText(json); } catch (Exception) { return(null); } } return(expression); }
public BaseRepository(IHttpContextAccessor httpContextAccessor, IMemoryCache memoryCache, IPermissionCacheService permissionCacheService) { _context = httpContextAccessor.HttpContext.RequestServices.GetService <TDbContext>(); _dataSet = _context.Set <TEntity>(); var userName = httpContextAccessor.HttpContext.User.Claims.FirstOrDefault(c => c.Type == CustomClaimTypes.UserName)?.Value; var userRoles = httpContextAccessor.HttpContext.User.GetClaimValue(CustomClaimTypes.Role).Split(',', StringSplitOptions.RemoveEmptyEntries); if (!string.IsNullOrEmpty(userName)) { // 表达式合集 var expressionList = new List <LambdaExpression>(); // 取得用户的数据规则 var permissions = permissionCacheService.GetUserRuleAsync(userName, userRoles).Result; // 所有规则组 foreach (var group in permissions) { // 找到符合当前实体的规则 var items = group.Split('|'); if (items[0] == typeof(TDbContext).Name && items[1] == typeof(TEntity).Name) { // 表达式反序列化 var serializer = new ExpressionSerializer(new JsonSerializer()); serializer.AddKnownType(typeof(Core.Expressions.ExpressionType)); var lambda = (LambdaExpression)serializer.DeserializeText(items[2]); expressionList.Add(lambda); } } // 连接lambda表达式生成统一条件 if (expressionList.Count > 0) { _condition = (Expression <Func <TEntity, bool> >)(new ExpressionUtil <TEntity>() .JoinLambdaExpression(expressionList, ExpressionCombineType.And)); } } }
public void SerializeDeserializeArrayAsJson() { var list = new[] { "one", "two" }; Expression <Func <Test, bool> > expression = test => list.Contains(test.Code); var serializer = new ExpressionSerializer(new JsonSerializer()); var value = serializer.SerializeText(expression); var actualExpression = (Expression <Func <Test, bool> >)serializer.DeserializeText(value); var func = actualExpression.Compile(); Assert.IsTrue(func(new Test { Code = "one" }), "one failed."); Assert.IsTrue(func(new Test { Code = "two" }), "two failed."); Assert.IsFalse(func(new Test { Code = "three" }), "three failed."); }
public static dynamic Retrieve(string serializedExpression, string targetType) { var people = new List <dynamic> { new { Name = "John", Email = "*****@*****.**" }, new { Name = "Jane", Email = "*****@*****.**" } }; // Try creating an object of the type hint passed to the server var typeInstance = Activator.CreateInstance(Type.GetType(targetType)); if (typeInstance.GetType() == typeof(Person)) { var serializer = new ExpressionSerializer(new JsonSerializer()); var deserializedExpression = (Expression <Func <Person, bool> >)serializer.DeserializeText(serializedExpression); var peopleCasted = (IEnumerable <Person>)people.ToNonAnonymousList(typeof(Person)); return(peopleCasted.Where(deserializedExpression.Compile()).SingleOrDefault()); } else { throw new ArgumentException("Type is unknown"); } }
public void DynamicsTests() { var expressions = new List <Expression>(); Expression <Func <Item, dynamic> > objectExp = item => new { item.Name, item.ProductId }; Expression <Func <string, dynamic> > stringExp = str => new { Text = str }; expressions.Add(objectExp); expressions.Add(stringExp); foreach (var textSerializer in new ITextSerializer[] { new JsonSerializer(), new XmlSerializer() }) { var serializer = new ExpressionSerializer(textSerializer); foreach (var expected in expressions) { var serialized = serializer.SerializeText(expected); var actual = serializer.DeserializeText(serialized); ExpressionAssert.AreEqual(expected, actual); } } }