//[PagingFilter]
public virtual IList <T> GetByExpression([FromBody] XElement x, [FromUri] int ps = 10, [FromUri] int pn = 1)
{
//TODO:后期回顾整理(重要)
var creator = new QueryCreator(this.FnGetDatabaseObjects);
var assemblies = new Assembly[]
{
typeof(PhyGeoDisaster).Assembly,
typeof(ExpressionType).Assembly,
typeof(IQueryable).Assembly,
typeof(Enum).Assembly,
typeof(DateTime).Assembly
};
var resolver = new TypeResolver(assemblies, new Type[]
{
typeof(PhyGeoDisaster), typeof(Enum), typeof(DateTime)
});
CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(creator, resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(resolver);
var serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { queryconverter, knowntypeconverter });
Expression e = serializer.Deserialize(x);
MethodCallExpression m = (MethodCallExpression)e;
LambdaExpression lambda = Expression.Lambda(m);
Delegate fn = lambda.Compile();
dynamic result = fn.DynamicInvoke(new object[0]);
//dynamic array = Enumerable.ToArray(result);
var array = Enumerable.ToArray(Enumerable.Cast <T>(result));
// IList<PhyGeoDisasterSimplify> phyModels = Mapper.Map<IEnumerable<PhyGeoDisaster>,
//IList<PhyGeoDisasterSimplify>>(array);
return(array);
}
public BaseTests()
{
this.assemblies = new Assembly[] { typeof(Customer).Assembly, typeof(BaseTests).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
this.resolver = new TypeResolver(assemblies, new Type[]
{
typeof(Customer), typeof(Order), typeof(Product),
typeof(Supplier), typeof(Shipper)
});
var creator = new QueryCreator(this.FnGetObjects);
CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(creator, this.resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(this.resolver);
this.serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { queryconverter, knowntypeconverter });
}
static ExpressionSerializer CreateSerializer()
{
var assemblies = new Assembly[] { typeof(Customer).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
var resolver = new TypeResolver(assemblies, new Type[]
{
typeof(Customer), typeof(Order), typeof(Product),
typeof(Supplier), typeof(Shipper)
});
//var creator = new QueryCreator();
CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(creator: null, resolver: resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(resolver);
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { queryconverter, knowntypeconverter });
return(serializer);
//ExpressionSerializer serializer = new ExpressionSerializer()
}
public NorthwindService()
{
var connectionStrings = System.Configuration.ConfigurationManager.ConnectionStrings;
this.connectionString = connectionStrings["northwind"].ConnectionString;
this.creator = new QueryCreator(this.FnGetDatabaseObjects);
this.assemblies = new Assembly[] { typeof(Customer).Assembly, typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly };
this.resolver = new TypeResolver(assemblies, new Type[]
{
typeof(Customer), typeof(Order), typeof(Product),
typeof(Supplier), typeof(Shipper)
});
CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(creator, this.resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(this.resolver);
this.serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { queryconverter, knowntypeconverter });
}
private static ExpressionSerializer CreateSerializer(IEnumerable <Type> knownTypes = null)
{
if (knownTypes == null || !knownTypes.Any())
{
return(new ExpressionSerializer());
}
var assemblies = new List <Assembly> {
typeof(ExpressionType).Assembly, typeof(IQueryable).Assembly
};
knownTypes.ToList().ForEach(type => assemblies.Add(type.Assembly));
var resolver = new TypeResolver(assemblies, knownTypes);
var knownTypeConverter = new KnownTypeExpressionXmlConverter(resolver);
var serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { knownTypeConverter });
return(serializer);
}
/// <summary>
/// Hey friends! If anyone is looking at this, they are probably wondering wat da eff is going on. This is a custom serializer for
/// expressions. I wish I was smart enough to build this, but about the extent of my skill set has me copying the code and debugging
/// through this bad bitch to try and figure out everything it needs. Since a lot of the xml deserialization relies on runtime reflection
/// of known types, you need to make damn sure every type which is going to be serialized/deserialized is loaded up into this mofo.
/// Otherwise, you get to be like me and step through the source code trying to reverse engineer something built by people smarter than you.
/// </summary>
/// <returns></returns>
public static ExpressionSerializer CreateSerializer()
{
var assemblies = new Assembly[] { typeof(ValidationRules).Assembly, typeof(ExpressionType).Assembly };
var resolver = new TypeResolver(assemblies, new Type[]
{
typeof(ValidationRules), typeof(ComparableType), typeof(ValidationMessage), typeof(ReportBase), typeof(SurfReport),
typeof(SnowReport), typeof(Ratings)//note: adding a nullable operator to a custom enum has the compiler inline a new type for you (I think), which doesn't seem to be accessible conventionally from the compile time known types and assemblies. fun fact!
});
//var creator = new QueryCreator();
//CustomExpressionXmlConverter queryconverter = new QueryExpressionXmlConverter(creator: null, resolver: resolver);
CustomExpressionXmlConverter knowntypeconverter = new KnownTypeExpressionXmlConverter(resolver);
//ExpressionSerializer serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { queryconverter, knowntypeconverter });
ExpressionSerializer serializer = new ExpressionSerializer(resolver, new CustomExpressionXmlConverter[] { knowntypeconverter });
return(serializer);
//ExpressionSerializer serializer = new ExpressionSerializer()
}
public void KnownTypeExpressionXmlConverterTest()
{
CustomExpressionXmlConverter knconverter = new KnownTypeExpressionXmlConverter(this.resolver);
XElement x;
ConstantExpression cx;
Expression e;
List <int> intlist = new List <int> {
0, 1, 3, 4, 5
};
cx = Expression.Constant(intlist);
knconverter.TrySerialize(cx, out x);
knconverter.TryDeserialize(x, out e);
Assert.IsTrue(((ConstantExpression)e).Value is List <int>);
Assert.IsTrue(((List <int>)((ConstantExpression)e).Value).SequenceEqual(intlist));
Customer c = Hans;
cx = Expression.Constant(c);
knconverter.TrySerialize(cx, out x);
knconverter.TryDeserialize(x, out e);
Assert.IsTrue(((ConstantExpression)e).Value is Customer);
}
