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