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);
}
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.AreEqual(expected, actual);
}
}
internal static ExpressionSerializer NewExpressionSerializer(params Type[] knownTypes)
{
var expressionSerializer = new ExpressionSerializer(JsonSerializer);
expressionSerializer.AddKnownType(typeof(StringSplitOptions)); // TODO: Have this come in from above
return(expressionSerializer);
}
public override void Deserialize(IDeserializer deserializer)
{
base.Deserialize(deserializer);
var expression = new ExpressionSerializer(new BinarySerializer()).Deserialize(new MemoryStream(deserializer.ReadByteArray()));
SetExpression(expression);
}
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 Test12()
{
Order order1 = new Order {
Customer = Hans, ID = 302, Freight = 2001.99m, OrderDate = DateTime.Now.AddMonths(-20)
};
var assemblies = new Assembly[] { typeof(Order).Assembly, typeof(UnitTests).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new ExpressionSerializationTypeResolver(assemblies, new Type[] { typeof(Customer), typeof(Order), typeof(Product), typeof(Supplier), typeof(Shipper) });
ExpressionSerializer serializer = new ExpressionSerializer(resolver);
IEnumerable <Customer> customers = GetCustomers().ToArray();
Expression <Func <int, IEnumerable <Order[]> > > e12 =
n =>
from c in customers //instance == null : IEnumerable.Where/.Select
where c.ID < n
select c.Orders.ToArray();
e12 = (Expression <Func <int, IEnumerable <Order[]> > >)ObjectServices.Evaluator.PartialEval(e12);
MethodCallExpression m1 = ((MethodCallExpression)e12.Body).Arguments[0] as MethodCallExpression;
ConstantExpression cx = ((ConstantExpression)m1.Arguments[0]);
LambdaExpression lambdaarg = ((LambdaExpression)m1.Arguments[1]);
//Expression arg1 = ((MethodCallExpression)e12.Body).Arguments[1];
XElement xml12 = serializer.Serialize(e12);
Expression result12 = serializer.Deserialize(xml12);
Assert.AreEqual(e12.ToString(), result12.ToString());
Console.WriteLine(((result12 as Expression <Func <int, IEnumerable <Order[]> > >).Compile())(5));
}
/// <summary>
/// Reads out the expression from a BinaryReader.
/// </summary>
/// <param name="reader">The BinaryReader to read from.</param>
public override void Read(AssetBinaryReader reader)
{
SetProperty = ExpressionSerializer.ReadExpression(reader);
int numEntries = reader.ReadInt32(); // Number of elements
Elements = reader.ReadExpressionArray(EExprToken.EX_EndSet);
}
/// <summary>
/// Reads out the expression from a BinaryReader.
/// </summary>
/// <param name="reader">The BinaryReader to read from.</param>
public override void Read(AssetBinaryReader reader)
{
ObjectExpression = ExpressionSerializer.ReadExpression(reader);
Offset = reader.ReadUInt32();
RValuePointer = reader.XFER_PROP_POINTER();
ContextExpression = ExpressionSerializer.ReadExpression(reader);
}
public void DefaultExpressionsCanBeSerialized()
{
var defaultValue = Expression.Default(typeof(int));
var expressionSerializer = new ExpressionSerializer(new JsonSerializer());
expressionSerializer.SerializeText(defaultValue);
}
public Serialize()
{
_jsonSerializer = new CustomBonsaiSerializer();
_binarySerializer = new ExpressionSerializer(new BinaryObjectSerializer(), ExpressionFactory.Instance);
_expr = (Expression <Func <IEnumerable <int> > >)(() => Enumerable.Range(0, 10).Where(x => x > 0).Select(x => x * x));
}
public static Expression ReadExpression(byte[] data)
{
var expressionSerializer = new ExpressionSerializer(new Serialize.Linq.Serializers.BinarySerializer());
var expression = expressionSerializer.DeserializeBinary(data);
return(expression);
}
public T Get <T>(Expression <Func <dynamic, bool> > query)
{
var serializer = new ExpressionSerializer(new JsonSerializer());
var serializedExpression = serializer.SerializeText(query);
return((T)Server.Retrieve(serializedExpression, typeof(T).FullName));
}
static void Main(string[] args)
{
const string fileName = "sumRange.bin";
ExpressionSerializer serializer = new ExpressionSerializer(
new TypeResolver(new[] { Assembly.GetExecutingAssembly() })
);
serializer.Serialize(sumRange).Save(fileName);
Expression <Func <int, int, int> > deserializedSumRange =
serializer.Deserialize <Func <int, int, int> >(
XElement.Load(fileName)
);
Func <int, int, int> funcSumRange =
deserializedSumRange.Compile();
Console.WriteLine(
"Deserialized func returned: {0}",
funcSumRange(1, 4)
);
Console.ReadKey();
}
/// <summary>
/// 取得规则组的表达式
/// </summary>
/// <param name="ruleGroupId">规则组ID</param>
/// <returns></returns>
private string GetExpressionStr(Guid ruleGroupId, string userName, string groupId)
{
// 规则信息
var ruleGroup = _context.Set <RuleGroup>().Find(ruleGroupId);
var rules = _context.Set <Rule>().AsNoTracking().Where(rule => rule.RuleGroupId == ruleGroupId);
var ruleConditions = _context.Set <RuleCondition>().AsNoTracking().Where(condition => condition.RuleGroupId == ruleGroupId);
// 生成表达式
var topRule = rules.Where(rule => rule.UpRuleId.Equals(new Guid())).FirstOrDefault();
var entityType = EntityTypeFinder.FindEntityType(ruleGroup.DbContext, ruleGroup.Entity);
var expressionGroup = new ExpressionGroup(entityType);
var keyValuePairs = new Dictionary <string, string> {
};
keyValuePairs.Add("UserName", userName);
keyValuePairs.Add("GroupId", groupId);
MakeExpressionGroup(topRule, rules, ruleConditions, entityType, keyValuePairs, ref expressionGroup);
// 生成过滤表达式
Expression lambda = expressionGroup.GetLambda();
// 表达式序列化
var serializer = new ExpressionSerializer(new JsonSerializer())
{
AutoAddKnownTypesAsListTypes = true
};
serializer.AddKnownType(typeof(Core.Expressions.ExpressionType));
return(serializer.SerializeText(lambda));
}
void OnDeserialized(StreamingContext context)
{
var serializer = new ExpressionSerializer();
var xmlElement = XElement.Parse(serializedPredicate);
predicate = serializer.Deserialize <Func <T, bool> >(xmlElement);
}
private static void bench()
{
var sw = Stopwatch.StartNew();
for (var i = 0; i < 5_000_000; i++)
{
//Expression<Func<string, string, int>> exp = (x, y) => x.Length + y.Length;
//exp.Compile()("a", "b");
//Func<string, string, int> foo = (x, y) => x.Length + y.Length;
//foo("a", "b");
//new Context().Eval("(x,y) => x.length + y.length").As<Function>().Call(new Arguments { "a", "b" });
Expression <Func <string, string, long> > exp = (x, y) => x.Length + y.Length;
var serializer = new ExpressionSerializer();
var deserializer = new ExpressionDeserializer();
var serialized = serializer.Serialize(exp);
var deserialized = (LambdaExpression)deserializer.Deserialize(serialized);
var value = new ExpressionEvaluator().Eval(deserialized.Body,
new[] {
new Parameter(deserialized.Parameters[0], "a"),
new Parameter(deserialized.Parameters[1], "b"),
});
}
sw.Stop();
Console.WriteLine(sw.Elapsed);
}
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);
}
}
private static ExpressionSerializer GetSerializer()
{
var typeResolver = new TypeResolver(assemblies: AppDomain.CurrentDomain.GetAssemblies(), knownTypes: null);
var serializer = new ExpressionSerializer(typeResolver);
return(serializer);
}
private static Expression SerializeDeserializeExpressionAsBinary(Expression expression, ISerializer serializer)
{
var expressionSerializer = new ExpressionSerializer(serializer);
var serialized = expressionSerializer.SerializeBinary(expression);
return(expressionSerializer.DeserializeBinary(serialized));
}
public static long UpdateOne <T>(DBREQUESTTYPE type, Expression <Func <T, bool> > expression, Dictionary <string, object> update)
{
long updated = 0;
var serializer = new ExpressionSerializer(new BinarySerializer());
string json = JsonConvert.SerializeObject(update);
byte[] serializedFilter = serializer.SerializeBinary(expression);
byte[] serializedUpdate = Serialize(json);
ByteRef payload = new ByteRef(2 + 4 + serializedFilter.Length + 4 + serializedUpdate.Length);
payload.Set <byte>(0, type);
payload.Set <byte>(1, (byte)DBRESULTTYPE.UPDATEONE);
payload.Set <int>(2, serializedFilter.Length);
payload.Set <byte[]>(6, serializedFilter);
payload.Set <int>(6 + serializedFilter.Length, serializedUpdate.Length);
payload.Set <byte[]>(6 + serializedFilter.Length + 4, serializedUpdate);
ByteRef queryResult = new ByteRef(SendQuery(payload.Get()));
if (queryResult.Length >= 5 || (DBRESPONSETYPE)queryResult.GetByte(0) != DBRESPONSETYPE.FAILURE)
{
updated = queryResult.GetUInt32(1);
}
return(updated);
}
/// <summary>
/// Writes the expression to a BinaryWriter.
/// </summary>
/// <param name="writer">The BinaryWriter to write from.</param>
/// <returns>The iCode offset of the data that was written.</returns>
public override int Write(AssetBinaryWriter writer)
{
int offset = 0;
offset += ExpressionSerializer.WriteExpression(Delegate, writer);
offset += ExpressionSerializer.WriteExpression(DelegateToAdd, writer);
return(offset);
}
public override Task <ISendStrategy> GetInputSendStrategy()
{
int joinFieldIndex = ((HashRippleJoinPredicate)predicate).JoinFieldIndex;
Expression <Func <TexeraTuple, int> > exp = tuple => tuple.FieldList[joinFieldIndex].GetHashCode();
var serializer = new ExpressionSerializer(new JsonSerializer());
return(Task.FromResult(new Shuffle(inputGrains, serializer.SerializeText(exp)) as ISendStrategy));
}
/// <summary>
/// Writes the expression to a BinaryWriter.
/// </summary>
/// <param name="writer">The BinaryWriter to write from.</param>
/// <returns>The iCode offset of the data that was written.</returns>
public override int Write(AssetBinaryWriter writer)
{
int offset = 0;
offset += ExpressionSerializer.WriteExpression(VariableExpression, writer);
offset += ExpressionSerializer.WriteExpression(AssignmentExpression, writer);
return(offset);
}
public override void writeData(BinaryWriter bw)
{
bw.Write((UInt16)0); // Version
//bw.Write(value);
ExpressionSerializer.Write(expression, bw);
bw.Write(variableId);
}
public override void readData(BinaryReader br)
{
br.ReadUInt16();
//value = br.ReadString();
expression = ExpressionSerializer.Read(br);
variableId = br.ReadString();
}
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 async void Serialize(Expression <Func <Customer, bool> > lambda, string expectedResult)
{
var serializer = new ExpressionSerializer();
var result = await serializer.Serialize(lambda);
//Console.WriteLine(result);
Assert.Equal(expectedResult, result);
}
/// <summary>
/// Writes the expression to a BinaryWriter.
/// </summary>
/// <param name="writer">The BinaryWriter to write from.</param>
/// <returns>The iCode offset of the data that was written.</returns>
public override int Write(AssetBinaryWriter writer)
{
int offset = 0;
offset += writer.XFERPTR(StructMemberExpression);
offset += ExpressionSerializer.WriteExpression(StructExpression, writer);
return(offset);
}
private void OnSerializing(StreamingContext context)
{
var cleanedExpression = ExpressionUtility.Ensure(_predicate);
var serializer = new ExpressionSerializer();
var xmlElement = serializer.Serialize(cleanedExpression);
_serializedPredicate = xmlElement.ToString();
}
public static IQueryable DeserializeQuery(this DataContext dc, XElement rootXml)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(dc);
DLinqCustomExpressionXmlConverter customConverter = new DLinqCustomExpressionXmlConverter(dc, resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { customConverter } };
Expression queryExpr = serializer.Deserialize(rootXml);
// Query kind is populated by the ResolveXmlFromExpression method
if (customConverter.QueryKind == null)
throw new Exception(string.Format("CAnnot deserialize into DLinq query for datacontext {0} - no Table found", dc));
return customConverter.QueryKind.Provider.CreateQuery(queryExpr);
}
public static XElement SerializeQuery(this IQueryable query)
{
DLinqSerializationTypeResolver resolver = new DLinqSerializationTypeResolver(null);
ExpressionSerializer serializer = new ExpressionSerializer(resolver) { Converters = { new DLinqCustomExpressionXmlConverter(null, resolver) } };
return serializer.Serialize(query.Expression);
}
