Here are the examples of the csharp api System.Linq.Expressions.Expression.Parameter(System.Type, string) taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
1934 Examples
19
View Source File : ExpressionActivator.cs
License : Apache License 2.0
Project Creator : 1448376744
License : Apache License 2.0
Project Creator : 1448376744
public ExpressionContextResult<T> Create<T>(string expression)
{
expression = Initialization(expression);
var parameter = Expression.Parameter(typeof(T), "p");
var body = CreateExpression(parameter, expression);
var lambda = Expression.Lambda(body, parameter);
var func = lambda.Compile() as Func<T, bool>;
return new ExpressionContextResult<T>()
{
Func = func,
LambdaExpression = lambda
};
}
19
View Source File : ObjectFormatter.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
public void Serialize(ref BssomWriter writer, ref BssomSerializeContext context, object value)
{
if (value == null)
{
writer.WriteNull();
return;
}
Type realType = value.GetType();
if (realType == typeof(object))
{
writer.WriteArray1BuildInType(BssomType.Map2);
BssMapObjMarshal.WriteEmptyMapObject(ref writer);
return;
}
object formatter = context.Option.FormatterResolver.GetFormatterWithVerify(realType);
if (!SerializerDelegates.TryGetValue(realType, out SerializeMethod serializerDelegate))
{
Type formatterType = typeof(IBssomFormatter<>).MakeGenericType(realType);
ParameterExpression param0 = Expression.Parameter(typeof(object), "formatter");
ParameterExpression param1 = Expression.Parameter(typeof(BssomWriter).MakeByRefType(), "writer");
ParameterExpression param2 = Expression.Parameter(typeof(BssomSerializeContext).MakeByRefType(), "context");
ParameterExpression param3 = Expression.Parameter(typeof(object), "value");
MethodInfo serializeMethod = formatterType.GetRuntimeMethod(nameof(Serialize), new[] { typeof(BssomWriter).MakeByRefType(), typeof(BssomSerializeContext).MakeByRefType(), realType });
MethodCallExpression body = Expression.Call(
Expression.Convert(param0, formatterType),
serializeMethod,
param1, param2,
realType.IsValueType ? Expression.Unbox(param3, realType) : Expression.Convert(param3, realType)
);
serializerDelegate = Expression.Lambda<SerializeMethod>(body, param0, param1, param2, param3).Compile();
SerializerDelegates.TryAdd(realType, serializerDelegate);
}
serializerDelegate(formatter, ref writer, ref context, value);
}
19
View Source File : ObjectFormatter.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
public int Size(ref BssomSizeContext context, object value)
{
if (value == null)
{
return BssomBinaryPrimitives.NullSize;
}
Type realType = value.GetType();
if (realType == typeof(object))
{
return BssMapObjMarshal.Empty.Length + BssomBinaryPrimitives.BuildInTypeCodeSize;
}
object formatter = context.Option.FormatterResolver.GetFormatterWithVerify(realType);
if (!SizeDelegates.TryGetValue(realType, out SizeMethod sizeDelegate))
{
Type formatterType = typeof(IBssomFormatter<>).MakeGenericType(realType);
ParameterExpression param0 = Expression.Parameter(typeof(object), "formatter");
ParameterExpression param1 = Expression.Parameter(typeof(BssomSizeContext).MakeByRefType(), "context");
ParameterExpression param2 = Expression.Parameter(typeof(object), "value");
MethodInfo sizeMethod = formatterType.GetRuntimeMethod(nameof(Size), new[] { typeof(BssomSizeContext).MakeByRefType(), realType });
MethodCallExpression body = Expression.Call(
Expression.Convert(param0, formatterType),
sizeMethod, param1,
realType.IsValueType ? Expression.Unbox(param2, realType) : Expression.Convert(param2, realType)
);
sizeDelegate = Expression.Lambda<SizeMethod>(body, param0, param1, param2).Compile();
SizeDelegates.TryAdd(realType, sizeDelegate);
}
return sizeDelegate(formatter, ref context, value);
}
19
View Source File : ObjectFormatter.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
public static object Deserialize(Type type, ref BssomReader reader, ref BssomDeserializeContext context)
{
object formatter = context.Option.FormatterResolver.GetFormatterWithVerify(type);
if (!DeserializerDelegates.TryGetValue(type, out DeserializeMethod deserializerDelegate))
{
Type formatterType = typeof(IBssomFormatter<>).MakeGenericType(type);
ParameterExpression param0 = Expression.Parameter(typeof(object), "formatter");
ParameterExpression param1 = Expression.Parameter(typeof(BssomReader).MakeByRefType(), "reader");
ParameterExpression param2 = Expression.Parameter(typeof(BssomDeserializeContext).MakeByRefType(), "context");
MethodInfo deserializeMethod = formatterType.GetRuntimeMethod(nameof(Deserialize), new[] { typeof(BssomReader).MakeByRefType(), typeof(BssomDeserializeContext).MakeByRefType() });
//(object)IBssomFormatter<T>.Deserialize(ref reader,option);
UnaryExpression body = Expression.Convert(Expression.Call(
Expression.Convert(param0, formatterType),
deserializeMethod,
param1,
param2), typeof(object));
deserializerDelegate = Expression.Lambda<DeserializeMethod>(body, param0, param1, param2).Compile();
DeserializerDelegates.TryAdd(type, deserializerDelegate);
}
return deserializerDelegate(formatter, ref reader, ref context);
}
19
View Source File : Array3CodeGenResolver.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
private static Expression BuildDeserializeCore(Type t, ObjectSerializationInfo serializationInfo)
{
List<Expression> ary = new List<Expression>();
LabelTarget returnTarget = Expression.Label(t, "returnLable");
//int num;
ParameterExpression num = Expression.Variable(typeof(int), "num");
//int for-i;
ParameterExpression forVariable = Expression.Variable(typeof(int), "i");
//context.option.Security.DepthStep(ref reader);
ary.Add(CommonExpressionMeta.Call_DeserializeContext_Option_Security_DepthStep);
//if(reader.TryReadNullWithEnsureBuildInType(BssomType.Array3))
// return default(t);
ary.Add(Expression.IfThen(CommonExpressionMeta.Call_Reader_TryReadNullWithEnsureBuildInType(BssomType.Array3),
Expression.Return(returnTarget, Expression.Default(t))));
//T t = new T();
ParameterExpression instance = Expression.Parameter(t, "instance");
if (serializationInfo.IsDefaultNoArgsCtor)
{
ary.Add(Expression.replacedign(instance, Expression.New(t)));
}
else
{
ParameterInfo[] parInfos = serializationInfo.BestmatchConstructor.GetParameters();
Expression[] pars = new Expression[parInfos.Length];
if (serializationInfo.ConstructorParametersIsDefaultValue)
{
for (int i = 0; i < parInfos.Length; i++)
{
pars[i] = Expression.Default(parInfos[i].ParameterType);
}
ary.Add(Expression.replacedign(instance, Expression.New(serializationInfo.BestmatchConstructor, pars)));
}
else
{
object[] cps = serializationInfo.ConstructorParameters;
for (int i = 0; i < parInfos.Length; i++)
{
pars[i] = Expression.Constant(cps[i], parInfos[i].ParameterType);
}
ary.Add(Expression.replacedign(instance, Expression.New(serializationInfo.BestmatchConstructor, pars)));
}
}
//reader.SkipVariableNumber()
ary.Add(CommonExpressionMeta.Call_Reader_SkipVariableNumber);
//num = reader.ReadVariableNumber()
ary.Add(Expression.replacedign(num, CommonExpressionMeta.Call_Reader_ReadVariableNumber));
//i = 0;
ary.Add(Expression.replacedign(forVariable, Expression.Constant(0)));
var members = serializationInfo.SerializeMemberInfos;
if (members.Length > 0)
{
//reader.Buffer.Seek(offsetSegment, Current)
ary.Add(CommonExpressionMeta.Call_Reader_BufferSeek(Expression.Convert(Expression.Multiply(num, Expression.Constant(BssomBinaryPrimitives.FixUInt32NumberSize)), typeof(Int64)), BssomSeekOrgin.Current));
//switch(i)
// case 0: instance.Key0 = readValue();
// case 3: instance.Key1 = readValue();
// case 5: instance.Key2 = readValue();
// default: skipObj();
FieldInfo memFormatters = serializationInfo.StoreMemberFormatterInstances();
SwitchCase[] switchCases = new SwitchCase[members.Length];
for (int i = 0; i < members.Length; i++)
{
switchCases[i] = Expression.SwitchCase(SpecialCodeGenExpression.ReadValues(members[i], instance, memFormatters), Expression.Constant(members[i].KeyIndex));
}
Expression content = Expression.Switch(
typeof(void),
forVariable,
CommonExpressionMeta.Call_Reader_SkipObject,
null,
switchCases
);
ary.Add(For(forVariable, Expression.LessThan(forVariable, num), Expression.replacedign(forVariable, Expression.Add(forVariable, Expression.Constant(1))), content));
}
//context.Depth--;
ary.Add(CommonExpressionMeta.Call_DeserializeContext_Depth_Decrementreplacedign);
ary.Add(Expression.Return(returnTarget, instance));
ary.Add(Expression.Label(returnTarget, instance));
return Expression.Block(new ParameterExpression[] { instance, num, forVariable, }, ary);
}
19
View Source File : Array3CodeGenResolver.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
internal static void Factory(DynamicFormatterreplacedembly replacedembly, ObjectSerializationInfo objectSerializationInfo)
{
ParameterExpression instance = Expression.Parameter(objectSerializationInfo.Type, "value");
Expression<Serialize<T>> serializeExpression = Array3DynamicExpressionBuild.BuildSerializeLambda<T>(objectSerializationInfo, instance);
Expression<Size<T>> sizeExpression = Array3DynamicExpressionBuild.BuildSizeLambda<T>(objectSerializationInfo, instance);
Expression<Deserialize<T>> deserializeExpression = Array3DynamicExpressionBuild.BuildDeserializeLambda<T>(objectSerializationInfo);
Serialize = serializeExpression.Compile();
Size = sizeExpression.Compile();
Deserialize = deserializeExpression.Compile();
#if NETFRAMEWORK
TypeBuilder typeBuilder = replacedembly.DefineFormatterDelegateType(objectSerializationInfo.Type);
MethodBuilder serializeDelegate = TypeBuildHelper.DefineSerializeDelegate(typeBuilder, typeof(T));
serializeExpression.CompileToMethod(serializeDelegate);
MethodBuilder sizeDelegate = TypeBuildHelper.DefineSizeDelegate(typeBuilder, typeof(T));
sizeExpression.CompileToMethod(sizeDelegate);
MethodBuilder deserializeDelegate = TypeBuildHelper.DefineDeserializeDelegate(typeBuilder, typeof(T));
deserializeExpression.CompileToMethod(deserializeDelegate);
typeBuilder.CreateTypeInfo();
#endif
}
19
View Source File : IFormatterResolver.cs
License : MIT License
Project Creator : 1996v
License : MIT License
Project Creator : 1996v
public static IBssomFormatter GetFormatterWithVerify(this IFormatterResolver resolver, Type type)
{
if (resolver is null)
{
throw new ArgumentNullException(nameof(resolver));
}
if (type is null)
{
throw new ArgumentNullException(nameof(type));
}
if (!FormatterGetters.TryGetValue(type, out Func<IFormatterResolver, IBssomFormatter> formatterGetter))
{
MethodInfo genericMethod = GetFormatterMethodInfo.MakeGenericMethod(type);
ParameterExpression inputResolver = Expression.Parameter(typeof(IFormatterResolver), "inputResolver");
formatterGetter = Expression.Lambda<Func<IFormatterResolver, IBssomFormatter>>(
Expression.Call(inputResolver, genericMethod), inputResolver).Compile();
FormatterGetters.TryAdd(type, formatterGetter);
}
return formatterGetter(resolver);
}
19
View Source File : Serializer.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
static Func<Dictionary<string, string>, T> CompilePropertyDeserializer()
{
var o_t = typeof(T);
var o = Expression.Variable(o_t, "o");
var o_new = Expression.New(typeof(T));
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Parameter(d_t, "d");
var d_mi_try_get_value = d_t.GetMethod("TryGetValue");
var item_t = typeof(String);
var item = Expression.Variable(item_t, "item");
var tc_t = typeof(TypeConverter);
var tc = Expression.Variable(tc_t, "tc");
var tc_mi_can_convert_from = tc_t.GetMethod("CanConvertFrom", new[] { typeof(Type) });
var tc_mi_convert_from = tc_t.GetMethod("ConvertFrom", new[] { typeof(Object) });
var td_t = typeof(TypeDescriptor);
var td_mi_get_converter = td_t.GetMethod("GetConverter", new[] { typeof(Type) });
var binds = o_t.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(x => x.CanRead)
.Select(x =>
{
var value_t = x.PropertyType;
var value = Expression.Variable(value_t, "value");
var target = Expression.Label(x.PropertyType);
return Expression.Bind(x, Expression.Block(new[] { item, value },
Expression.replacedign(tc, Expression.Call(null, td_mi_get_converter, Expression.Constant(x.PropertyType))),
Expression.IfThen(
Expression.Call(d, d_mi_try_get_value, Expression.Constant(x.Name), item),
Expression.IfThen(
Expression.NotEqual(item, Expression.Constant(null)),
Expression.IfThen(
Expression.Call(tc, tc_mi_can_convert_from, Expression.Constant(typeof(String))),
Expression.Block(
Expression.replacedign(value, Expression.Convert(Expression.Call(tc, tc_mi_convert_from, item), x.PropertyType)),
Expression.Return(target, value, x.PropertyType))))),
Expression.Label(target, value)
));
}).ToArray();
var body = Expression.Block(new[] { o, tc },
Expression.MemberInit(o_new, binds)
);
return Expression.Lambda<Func<Dictionary<string, string>, T>>(body, d)
.Compile();
}
19
View Source File : Serializer.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
static Func<T, Dictionary<string, string>> CompileSerializer()
{
var o_t = typeof(T);
var o = Expression.Parameter(o_t, "original");
var o_get_object_data = o_t.GetMethod("GetObjectData");
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Variable(d_t, "d"); // define object variable
var d_init = Expression.MemberInit(Expression.New(d_t)); // object ctor
var d_add = d_t.GetMethod("Add"); // add method
var fc_t = typeof(IFormatterConverter);// typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(typeof(System.Runtime.Serialization.FormatterConverter))); //Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_get_enumerator = info_t.GetMethod("GetEnumerator");
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(SerializationInfoEnumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_name = Expression.Property(enumerator, "Name");
var enumerator_value = Expression.Property(enumerator, "Value");
var mi_to_string = typeof(Object).GetMethod("ToString", new Type[0]);
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { d, fc, info, ctx },
Expression.replacedign(d, d_init),
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.Call(o, o_get_object_data, info, ctx),
Expression.Block(new[] { enumerator },
Expression.replacedign(enumerator, Expression.Call(info, info_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_move_next), // test
Expression.IfThen(
Expression.NotEqual(enumerator_value, Expression.Constant(null)),
Expression.Call(d, d_add, enumerator_name, Expression.Call(enumerator_value, mi_to_string))
),
Expression.Break(exit_loop)), // if false
exit_loop)),
d); // return
// compile
return Expression.Lambda<Func<T, Dictionary<string, string>>>(body, o)
.Compile();
}
19
View Source File : Serializer.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
static Func<Dictionary<string, string>, T> CompileDeserializer()
{
var o_t = typeof(T);
var o_ctor = o_t.GetConstructor(new[] { typeof(SerializationInfo), typeof(StreamingContext) });
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Parameter(d_t, "d");
var d_mi_get_enumerator = d_t.GetMethod("GetEnumerator");
var fc_t = typeof(IFormatterConverter);// typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(typeof(System.Runtime.Serialization.FormatterConverter))); //Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_mi_add_value = info_t.GetMethod("AddValue", new[] { typeof(String), typeof(Object) });
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(Dictionary<string, string>.Enumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_mi_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_current = Expression.Property(enumerator, "Current");
var kvp_t = typeof(KeyValuePair<string, string>);
var kvp_pi_key = kvp_t.GetProperty("Key");
var kvp_pi_value = kvp_t.GetProperty("Value");
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { fc, info, ctx, enumerator },
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.replacedign(enumerator, Expression.Call(d, d_mi_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_mi_move_next),
Expression.Call(info, info_mi_add_value, Expression.Property(enumerator_current, kvp_pi_key), Expression.Property(enumerator_current, kvp_pi_value)),
Expression.Break(exit_loop)),
exit_loop),
Expression.MemberInit(Expression.New(o_ctor, info, ctx))
);
return Expression.Lambda<Func<Dictionary<string, string>, T>>(body, d)
.Compile();
}
19
View Source File : Serializer.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
static Func<T, Dictionary<string, string>> CompilePropertySerializer()
{
var o_t = typeof(T);
var o = Expression.Parameter(o_t, "o");
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Variable(d_t, "d");
var d_init = Expression.MemberInit(Expression.New(d_t));
var d_add = d_t.GetMethod("Add");
var d_setters = o_t.GetProperties(BindingFlags.Public | BindingFlags.Instance) // build setters via Add(k,v)
.Where(x => x.CanRead)
.Select(x =>
{
var prop = Expression.Property(o, x.Name);
var prop_mi_to_string = x.PropertyType.GetMethod("ToString", new Type[0]);
var add_to_dict = Expression.Call(d, d_add, Expression.Constant(x.Name), Expression.Call(prop, prop_mi_to_string));
if (!x.PropertyType.IsByRef)
return (Expression)add_to_dict;
else
return (Expression)Expression.IfThen(
Expression.Not(Expression.Equal(prop, Expression.Constant(null))),
add_to_dict);
});
// run this
var body = Expression.Block(new[] { d }, // scope variables
Expression.replacedign(d, d_init), // initialize
Expression.Block(d_setters), // set
d); // return
return Expression.Lambda<Func<T, Dictionary<string, string>>>(body, o)
.Compile();
}
19
View Source File : Admin.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
async public static Task<bool> Use(HttpContext context, IFreeSql fsql, string requestPathBase, Dictionary<string, Type> dicEnreplacedyTypes) {
HttpRequest req = context.Request;
HttpResponse res = context.Response;
var remUrl = req.Path.ToString().Substring(requestPathBase.Length).Trim(' ', '/').Split('/');
var enreplacedyName = remUrl.FirstOrDefault();
if (!string.IsNullOrEmpty(enreplacedyName)) {
if (dicEnreplacedyTypes.TryGetValue(enreplacedyName, out var enreplacedyType) == false) throw new Exception($"UseFreeAdminLtePreview 错误,找不到实体类型:{enreplacedyName}");
var tb = fsql.CodeFirst.GetTableByEnreplacedy(enreplacedyType);
if (tb == null) throw new Exception($"UseFreeAdminLtePreview 错误,实体类型无法映射:{enreplacedyType.FullName}");
var tpl = _tpl.Value;
switch (remUrl.ElementAtOrDefault(1)?.ToLower()) {
case null:
//首页
if (true) {
MakeTemplateFile($"{enreplacedyName}-list.html", Views.List);
//ManyToOne/OneToOne
var getlistFilter = new List<(TableRef, string, string, Dictionary<string, object>, List<Dictionary<string, object>>)>();
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getlistFilter.Add(await Utils.GetTableRefData(fsql, tbref));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
getlistFilter.Add(await Utils.GetTableRefData(fsql, tbref));
continue;
}
}
int.TryParse(req.Query["page"].FirstOrDefault(), out var getpage);
int.TryParse(req.Query["limit"].FirstOrDefault(), out var getlimit);
if (getpage <= 0) getpage = 1;
if (getlimit <= 0) getlimit = 20;
var getselect = fsql.Select<object>().AsType(enreplacedyType);
foreach (var getlistF in getlistFilter) {
var qv = req.Query[getlistF.Item3].ToArray();
if (qv.Any()) {
switch (getlistF.Item1.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getselect.Where(Utils.GetObjectWhereExpressionContains(tb, enreplacedyType, getlistF.Item1.Columns[0].CsName, qv));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
if (true) {
var midType = getlistF.Item1.RefMiddleEnreplacedyType;
var midTb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var midISelect = typeof(ISelect<>).MakeGenericType(midType);
var funcType = typeof(Func<,>).MakeGenericType(typeof(object), typeof(bool));
var expParam = Expression.Parameter(typeof(object), "a");
var midParam = Expression.Parameter(midType, "mdtp");
var anyMethod = midISelect.GetMethod("Any");
var selectExp = qv.Select(c => Expression.Convert(Expression.Constant(FreeSql.Internal.Utils.GetDataReaderValue(getlistF.Item1.MiddleColumns[1].CsType, c)), getlistF.Item1.MiddleColumns[1].CsType)).ToArray();
var expLambad = Expression.Lambda<Func<object, bool>>(
Expression.Call(
Expression.Call(
Expression.Call(
Expression.Constant(fsql),
typeof(IFreeSql).GetMethod("Select", new Type[0]).MakeGenericMethod(midType)
),
midISelect.GetMethod("Where", new[] { typeof(Expression<>).MakeGenericType(typeof(Func<,>).MakeGenericType(midType, typeof(bool))) }),
Expression.Lambda(
typeof(Func<,>).MakeGenericType(midType, typeof(bool)),
Expression.AndAlso(
Expression.Equal(
Expression.MakeMemberAccess(Expression.TypeAs(expParam, enreplacedyType), tb.Properties[getlistF.Item1.Columns[0].CsName]),
Expression.MakeMemberAccess(midParam, midTb.Properties[getlistF.Item1.MiddleColumns[0].CsName])
),
Expression.Call(
Utils.GetLinqContains(getlistF.Item1.MiddleColumns[1].CsType),
Expression.NewArrayInit(
getlistF.Item1.MiddleColumns[1].CsType,
selectExp
),
Expression.MakeMemberAccess(midParam, midTb.Properties[getlistF.Item1.MiddleColumns[1].CsName])
)
),
midParam
)
),
anyMethod,
Expression.Default(anyMethod.GetParameters().FirstOrDefault().ParameterType)
),
expParam);
getselect.Where(expLambad);
}
continue;
}
}
}
var getlistTotal = await getselect.CountAsync();
var getlist = await getselect.Page(getpage, getlimit).ToListAsync();
var gethashlists = new Dictionary<string, object>[getlist.Count];
var gethashlistsIndex = 0;
foreach (var getlisreplacedem in getlist) {
var gethashlist = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethashlist.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(getlisreplacedem));
}
gethashlists[gethashlistsIndex++] = gethashlist;
}
var options = new Dictionary<string, object>();
options["tb"] = tb;
options["getlist"] = gethashlists;
options["getlistTotal"] = getlistTotal;
options["getlistFilter"] = getlistFilter;
var str = _tpl.Value.RenderFile($"{enreplacedyName}-list.html", options);
await res.WriteAsync(str);
}
return true;
case "add":
case "edit":
//编辑页
object gereplacedem = null;
Dictionary<string, object> gethash = null;
if (req.Query.Any()) {
gereplacedem = Activator.CreateInstance(enreplacedyType);
foreach (var getpk in tb.Primarys) {
var reqv = req.Query[getpk.CsName].ToArray();
if (reqv.Any())
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getpk.CsName, reqv.Length == 1 ? (object)reqv.FirstOrDefault() : reqv);
}
gereplacedem = await fsql.Select<object>().AsType(enreplacedyType).WhereDynamic(gereplacedem).FirstAsync();
if (gereplacedem != null) {
gethash = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethash.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(gereplacedem));
}
}
}
if (req.Method.ToLower() == "get") {
MakeTemplateFile($"{enreplacedyName}-edit.html", Views.Edit);
//ManyToOne/OneToOne
var getlistFilter = new Dictionary<string, (TableRef, string, string, Dictionary<string, object>, List<Dictionary<string, object>>)>();
var getlistManyed = new Dictionary<string, IEnumerable<string>>();
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getlistFilter.Add(prop.Key, await Utils.GetTableRefData(fsql, tbref));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
getlistFilter.Add(prop.Key, await Utils.GetTableRefData(fsql, tbref));
if (gereplacedem != null) {
var midType = tbref.RefMiddleEnreplacedyType;
var midTb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var manyed = await fsql.Select<object>().AsType(midType)
.Where(Utils.GetObjectWhereExpression(midTb, midType, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]))
.ToListAsync();
getlistManyed.Add(prop.Key, manyed.Select(a => fsql.GetEnreplacedyValueWithPropertyName(midType, a, tbref.MiddleColumns[1].CsName).ToString()));
}
continue;
}
}
var options = new Dictionary<string, object>();
options["tb"] = tb;
options["gethash"] = gethash;
options["getlistFilter"] = getlistFilter;
options["getlistManyed"] = getlistManyed;
options["postaction"] = $"{requestPathBase}restful-api/{enreplacedyName}";
var str = _tpl.Value.RenderFile($"{enreplacedyName}-edit.html", options);
await res.WriteAsync(str);
} else {
if (gereplacedem == null) {
gereplacedem = Activator.CreateInstance(enreplacedyType);
foreach(var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "create_time", "createtime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, DateTime.Now);
}
}
var manySave = new List<(TableRef, object[], List<object>)>();
if (req.Form.Any()) {
foreach(var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "update_time", "updatetime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, DateTime.Now);
var reqv = req.Form[getcol.CsName].ToArray();
if (reqv.Any())
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, reqv.Length == 1 ? (object)reqv.FirstOrDefault() : reqv);
}
//ManyToMany
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
var midType = tbref.RefMiddleEnreplacedyType;
var mtb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var reqv = req.Form[$"mn_{prop.Key}"].ToArray();
var reqvIndex = 0;
var manyVals = new object[reqv.Length];
foreach (var rv in reqv) {
var miditem = Activator.CreateInstance(midType);
foreach (var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "create_time", "createtime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, getcol.CsName, DateTime.Now);
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "update_time", "updatetime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, getcol.CsName, DateTime.Now);
}
//fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]);
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, tbref.MiddleColumns[1].CsName, rv);
manyVals[reqvIndex++] = miditem;
}
var molds = await fsql.Select<object>().AsType(midType).Where(Utils.GetObjectWhereExpression(mtb, midType, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0])).ToListAsync();
manySave.Add((tbref, manyVals, molds));
continue;
}
}
}
using (var db = fsql.CreateDbContext()) {
var dbset = db.Set<object>();
dbset.AsType(enreplacedyType);
await dbset.AddOrUpdateAsync(gereplacedem);
foreach (var ms in manySave) {
var midType = ms.Item1.RefMiddleEnreplacedyType;
var moldsDic = ms.Item3.ToDictionary(a => fsql.GetEnreplacedyKeyString(midType, a, true));
var manyset = db.Set<object>();
manyset.AsType(midType);
foreach (var msVal in ms.Item2) {
fsql.SetEnreplacedyValueWithPropertyName(midType, msVal, ms.Item1.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]);
await manyset.AddOrUpdateAsync(msVal);
moldsDic.Remove(fsql.GetEnreplacedyKeyString(midType, msVal, true));
}
manyset.RemoveRange(moldsDic.Values);
}
await db.SaveChangesAsync();
}
gethash = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethash.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(gereplacedem));
}
await Utils.Jsonp(context, new { code = 0, success = true, message = "Success", data = gethash });
}
return true;
case "del":
if (req.Method.ToLower() == "post") {
var delitems = new List<object>();
var reqv = new List<string[]>();
foreach(var delpk in tb.Primarys) {
var reqvs = req.Form[delpk.CsName].ToArray();
if (reqv.Count > 0 && reqvs.Length != reqv[0].Length) throw new Exception("删除失败,联合主键参数传递不对等");
reqv.Add(reqvs);
}
if (reqv[0].Length == 0) return true;
using (var ctx = fsql.CreateDbContext()) {
var dbset = ctx.Set<object>();
dbset.AsType(enreplacedyType);
for (var a = 0; a < reqv[0].Length; a++) {
object delitem = Activator.CreateInstance(enreplacedyType);
var delpkindex = 0;
foreach (var delpk in tb.Primarys)
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, delitem, delpk.CsName, reqv[delpkindex++][a]);
dbset.Remove(delitem);
}
await ctx.SaveChangesAsync();
}
await Utils.Jsonp(context, new { code = 0, success = true, message = "Success" });
return true;
}
break;
}
}
return false;
}
19
View Source File : DataFilterUtil.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
internal static void SetRepositoryDataFilter(object repos, Action<FluentDataFilter> scopedDataFilter) {
if (scopedDataFilter != null) {
SetRepositoryDataFilter(repos, null);
}
if (scopedDataFilter == null) {
scopedDataFilter = _globalDataFilter;
}
if (scopedDataFilter == null) return;
using (var globalFilter = new FluentDataFilter()) {
scopedDataFilter(globalFilter);
var type = repos.GetType();
Type enreplacedyType = (repos as IBaseRepository).EnreplacedyType;
if (enreplacedyType == null) throw new Exception("FreeSql.Repository 设置过滤器失败,原因是对象不属于 IRepository");
var notExists = _dicSetRepositoryDataFilterConvertFilterNotExists.GetOrAdd(type, t => new ConcurrentDictionary<string, bool>());
var newFilter = new Dictionary<string, LambdaExpression>();
foreach (var gf in globalFilter._filters) {
if (notExists.ContainsKey(gf.name)) continue;
LambdaExpression newExp = null;
var filterParameter1 = Expression.Parameter(enreplacedyType, gf.exp.Parameters[0].Name);
try {
newExp = Expression.Lambda(
typeof(Func<,>).MakeGenericType(enreplacedyType, typeof(bool)),
new ReplaceVisitor().Modify(gf.exp.Body, filterParameter1),
filterParameter1
);
} catch {
notExists.TryAdd(gf.name, true); //防止第二次错误
continue;
}
newFilter.Add(gf.name, newExp);
}
if (newFilter.Any() == false) return;
var del = _dicSetRepositoryDataFilterApplyDataFilterFunc.GetOrAdd(type, t => {
var reposParameter = Expression.Parameter(type);
var nameParameter = Expression.Parameter(typeof(string));
var expressionParameter = Expression.Parameter(
typeof(Expression<>).MakeGenericType(typeof(Func<,>).MakeGenericType(enreplacedyType, typeof(bool)))
);
return Expression.Lambda(
Expression.Block(
Expression.Call(reposParameter, type.GetMethod("ApplyDataFilter", BindingFlags.Instance | BindingFlags.NonPublic), nameParameter, expressionParameter)
),
new[] {
reposParameter, nameParameter, expressionParameter
}
).Compile();
});
foreach (var nf in newFilter) {
del.DynamicInvoke(repos, nf.Key, nf.Value);
}
newFilter.Clear();
}
}
19
View Source File : DynamicProxyMeta.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
public static void CopyData(Type sourceType, object source, object target)
{
if (source == null) return;
if (target == null) return;
_copyDataFunc.GetOrAdd(sourceType, type =>
{
var sourceParamExp = Expression.Parameter(typeof(object), "sourceObject");
var targetParamExp = Expression.Parameter(typeof(object), "targetObject");
var sourceExp = Expression.Variable(type, "source");
var targetExp = Expression.Variable(type, "target");
var copyExps = new List<Expression>();
var sourceFields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var field in sourceFields)
copyExps.Add(Expression.replacedign(Expression.MakeMemberAccess(targetExp, field), Expression.MakeMemberAccess(sourceExp, field)));
if (copyExps.Any() == false) return _copyDataFuncEmpty;
var bodyExp = Expression.Block(
new[] {
sourceExp, targetExp
},
new[] {
Expression.IfThen(
Expression.NotEqual(sourceParamExp, Expression.Constant(null)),
Expression.IfThen(
Expression.NotEqual(targetParamExp, Expression.Constant(null)),
Expression.Block(
Expression.replacedign(sourceExp, Expression.TypeAs(sourceParamExp, sourceType)),
Expression.replacedign(targetExp, Expression.TypeAs(targetParamExp, sourceType)),
Expression.IfThen(
Expression.NotEqual(sourceExp, Expression.Constant(null)),
Expression.IfThen(
Expression.NotEqual(sourceExp, Expression.Constant(null)),
Expression.Block(
copyExps.ToArray()
)
)
)
)
)
)
}
);
return Expression.Lambda<Action<object, object>>(bodyExp, sourceParamExp, targetParamExp).Compile();
})(source, target);
}
19
View Source File : Admin.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
async public static Task<bool> Use(HttpContext context, IFreeSql fsql, string requestPathBase, Dictionary<string, Type> dicEnreplacedyTypes) {
HttpRequest req = context.Request;
HttpResponse res = context.Response;
var remUrl = req.Path.ToString().Substring(requestPathBase.Length).Trim(' ', '/').Split('/');
var enreplacedyName = remUrl.FirstOrDefault();
if (!string.IsNullOrEmpty(enreplacedyName)) {
if (dicEnreplacedyTypes.TryGetValue(enreplacedyName, out var enreplacedyType) == false) throw new Exception($"UseFreeAdminLtePreview 错误,找不到实体类型:{enreplacedyName}");
var tb = fsql.CodeFirst.GetTableByEnreplacedy(enreplacedyType);
if (tb == null) throw new Exception($"UseFreeAdminLtePreview 错误,实体类型无法映射:{enreplacedyType.FullName}");
var tpl = _tpl.Value;
switch (remUrl.ElementAtOrDefault(1)?.ToLower()) {
case null:
//首页
if (true) {
MakeTemplateFile($"{enreplacedyName}-list.html", Views.List);
//ManyToOne/OneToOne
var getlistFilter = new List<(TableRef, string, string, Dictionary<string, object>, List<Dictionary<string, object>>)>();
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getlistFilter.Add(await Utils.GetTableRefData(fsql, tbref));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
getlistFilter.Add(await Utils.GetTableRefData(fsql, tbref));
continue;
}
}
int.TryParse(req.Query["page"].FirstOrDefault(), out var getpage);
int.TryParse(req.Query["limit"].FirstOrDefault(), out var getlimit);
if (getpage <= 0) getpage = 1;
if (getlimit <= 0) getlimit = 20;
var getselect = fsql.Select<object>().AsType(enreplacedyType);
foreach (var getlistF in getlistFilter) {
var qv = req.Query[getlistF.Item3].ToArray();
if (qv.Any()) {
switch (getlistF.Item1.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getselect.Where(Utils.GetObjectWhereExpressionContains(tb, enreplacedyType, getlistF.Item1.Columns[0].CsName, qv));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
if (true) {
var midType = getlistF.Item1.RefMiddleEnreplacedyType;
var midTb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var midISelect = typeof(ISelect<>).MakeGenericType(midType);
var funcType = typeof(Func<,>).MakeGenericType(typeof(object), typeof(bool));
var expParam = Expression.Parameter(typeof(object), "a");
var midParam = Expression.Parameter(midType, "mdtp");
var anyMethod = midISelect.GetMethod("Any");
var selectExp = qv.Select(c => Expression.Convert(Expression.Constant(FreeSql.Internal.Utils.GetDataReaderValue(getlistF.Item1.MiddleColumns[1].CsType, c)), getlistF.Item1.MiddleColumns[1].CsType)).ToArray();
var expLambad = Expression.Lambda<Func<object, bool>>(
Expression.Call(
Expression.Call(
Expression.Call(
Expression.Constant(fsql),
typeof(IFreeSql).GetMethod("Select", new Type[0]).MakeGenericMethod(midType)
),
midISelect.GetMethod("Where", new[] { typeof(Expression<>).MakeGenericType(typeof(Func<,>).MakeGenericType(midType, typeof(bool))) }),
Expression.Lambda(
typeof(Func<,>).MakeGenericType(midType, typeof(bool)),
Expression.AndAlso(
Expression.Equal(
Expression.MakeMemberAccess(Expression.TypeAs(expParam, enreplacedyType), tb.Properties[getlistF.Item1.Columns[0].CsName]),
Expression.MakeMemberAccess(midParam, midTb.Properties[getlistF.Item1.MiddleColumns[0].CsName])
),
Expression.Call(
Utils.GetLinqContains(getlistF.Item1.MiddleColumns[1].CsType),
Expression.NewArrayInit(
getlistF.Item1.MiddleColumns[1].CsType,
selectExp
),
Expression.MakeMemberAccess(midParam, midTb.Properties[getlistF.Item1.MiddleColumns[1].CsName])
)
),
midParam
)
),
anyMethod,
Expression.Default(anyMethod.GetParameters().FirstOrDefault().ParameterType)
),
expParam);
getselect.Where(expLambad);
}
continue;
}
}
}
var getlistTotal = await getselect.CountAsync();
var getlist = await getselect.Page(getpage, getlimit).ToListAsync();
var gethashlists = new Dictionary<string, object>[getlist.Count];
var gethashlistsIndex = 0;
foreach (var getlisreplacedem in getlist) {
var gethashlist = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethashlist.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(getlisreplacedem));
}
gethashlists[gethashlistsIndex++] = gethashlist;
}
var options = new Dictionary<string, object>();
options["tb"] = tb;
options["getlist"] = gethashlists;
options["getlistTotal"] = getlistTotal;
options["getlistFilter"] = getlistFilter;
var str = _tpl.Value.RenderFile($"{enreplacedyName}-list.html", options);
await res.WriteAsync(str);
}
return true;
case "add":
case "edit":
//编辑页
object gereplacedem = null;
Dictionary<string, object> gethash = null;
if (req.Query.Any()) {
gereplacedem = Activator.CreateInstance(enreplacedyType);
foreach (var getpk in tb.Primarys) {
var reqv = req.Query[getpk.CsName].ToArray();
if (reqv.Any())
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getpk.CsName, reqv.Length == 1 ? (object)reqv.FirstOrDefault() : reqv);
}
gereplacedem = await fsql.Select<object>().AsType(enreplacedyType).WhereDynamic(gereplacedem).FirstAsync();
if (gereplacedem != null) {
gethash = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethash.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(gereplacedem));
}
}
}
if (req.Method.ToLower() == "get") {
MakeTemplateFile($"{enreplacedyName}-edit.html", Views.Edit);
//ManyToOne/OneToOne
var getlistFilter = new Dictionary<string, (TableRef, string, string, Dictionary<string, object>, List<Dictionary<string, object>>)>();
var getlistManyed = new Dictionary<string, IEnumerable<string>>();
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
getlistFilter.Add(prop.Key, await Utils.GetTableRefData(fsql, tbref));
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
getlistFilter.Add(prop.Key, await Utils.GetTableRefData(fsql, tbref));
if (gereplacedem != null) {
var midType = tbref.RefMiddleEnreplacedyType;
var midTb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var manyed = await fsql.Select<object>().AsType(midType)
.Where(Utils.GetObjectWhereExpression(midTb, midType, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]))
.ToListAsync();
getlistManyed.Add(prop.Key, manyed.Select(a => fsql.GetEnreplacedyValueWithPropertyName(midType, a, tbref.MiddleColumns[1].CsName).ToString()));
}
continue;
}
}
var options = new Dictionary<string, object>();
options["tb"] = tb;
options["gethash"] = gethash;
options["getlistFilter"] = getlistFilter;
options["getlistManyed"] = getlistManyed;
options["postaction"] = $"{requestPathBase}restful-api/{enreplacedyName}";
var str = _tpl.Value.RenderFile($"{enreplacedyName}-edit.html", options);
await res.WriteAsync(str);
} else {
if (gereplacedem == null) {
gereplacedem = Activator.CreateInstance(enreplacedyType);
foreach(var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "create_time", "createtime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, DateTime.Now);
}
}
var manySave = new List<(TableRef, object[], List<object>)>();
if (req.Form.Any()) {
foreach(var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "update_time", "updatetime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, DateTime.Now);
var reqv = req.Form[getcol.CsName].ToArray();
if (reqv.Any())
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, gereplacedem, getcol.CsName, reqv.Length == 1 ? (object)reqv.FirstOrDefault() : reqv);
}
//ManyToMany
foreach (var prop in tb.Properties) {
if (tb.ColumnsByCs.ContainsKey(prop.Key)) continue;
var tbref = tb.GetTableRef(prop.Key, false);
if (tbref == null) continue;
switch (tbref.RefType) {
case TableRefType.OneToMany: continue;
case TableRefType.ManyToOne:
continue;
case TableRefType.OneToOne:
continue;
case TableRefType.ManyToMany:
var midType = tbref.RefMiddleEnreplacedyType;
var mtb = fsql.CodeFirst.GetTableByEnreplacedy(midType);
var reqv = req.Form[$"mn_{prop.Key}"].ToArray();
var reqvIndex = 0;
var manyVals = new object[reqv.Length];
foreach (var rv in reqv) {
var miditem = Activator.CreateInstance(midType);
foreach (var getcol in tb.Columns.Values) {
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "create_time", "createtime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, getcol.CsName, DateTime.Now);
if (new[] { typeof(DateTime), typeof(DateTime?) }.Contains(getcol.CsType) && new[] { "update_time", "updatetime" }.Contains(getcol.CsName.ToLower()))
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, getcol.CsName, DateTime.Now);
}
//fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]);
fsql.SetEnreplacedyValueWithPropertyName(midType, miditem, tbref.MiddleColumns[1].CsName, rv);
manyVals[reqvIndex++] = miditem;
}
var molds = await fsql.Select<object>().AsType(midType).Where(Utils.GetObjectWhereExpression(mtb, midType, tbref.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0])).ToListAsync();
manySave.Add((tbref, manyVals, molds));
continue;
}
}
}
using (var db = fsql.CreateDbContext()) {
var dbset = db.Set<object>();
dbset.AsType(enreplacedyType);
await dbset.AddOrUpdateAsync(gereplacedem);
foreach (var ms in manySave) {
var midType = ms.Item1.RefMiddleEnreplacedyType;
var moldsDic = ms.Item3.ToDictionary(a => fsql.GetEnreplacedyKeyString(midType, a, true));
var manyset = db.Set<object>();
manyset.AsType(midType);
foreach (var msVal in ms.Item2) {
fsql.SetEnreplacedyValueWithPropertyName(midType, msVal, ms.Item1.MiddleColumns[0].CsName, fsql.GetEnreplacedyKeyValues(enreplacedyType, gereplacedem)[0]);
await manyset.AddOrUpdateAsync(msVal);
moldsDic.Remove(fsql.GetEnreplacedyKeyString(midType, msVal, true));
}
manyset.RemoveRange(moldsDic.Values);
}
await db.SaveChangesAsync();
}
gethash = new Dictionary<string, object>();
foreach (var getcol in tb.ColumnsByCs) {
gethash.Add(getcol.Key, tb.Properties[getcol.Key].GetValue(gereplacedem));
}
await Utils.Jsonp(context, new { code = 0, success = true, message = "Success", data = gethash });
}
return true;
case "del":
if (req.Method.ToLower() == "post") {
var delitems = new List<object>();
var reqv = new List<string[]>();
foreach(var delpk in tb.Primarys) {
var reqvs = req.Form[delpk.CsName].ToArray();
if (reqv.Count > 0 && reqvs.Length != reqv[0].Length) throw new Exception("删除失败,联合主键参数传递不对等");
reqv.Add(reqvs);
}
if (reqv[0].Length == 0) return true;
using (var ctx = fsql.CreateDbContext()) {
var dbset = ctx.Set<object>();
dbset.AsType(enreplacedyType);
for (var a = 0; a < reqv[0].Length; a++) {
object delitem = Activator.CreateInstance(enreplacedyType);
var delpkindex = 0;
foreach (var delpk in tb.Primarys)
fsql.SetEnreplacedyValueWithPropertyName(enreplacedyType, delitem, delpk.CsName, reqv[delpkindex++][a]);
dbset.Remove(delitem);
}
await ctx.SaveChangesAsync();
}
await Utils.Jsonp(context, new { code = 0, success = true, message = "Success" });
return true;
}
break;
}
}
return false;
}
19
View Source File : Utils.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
public static Expression<Func<object, bool>> GetObjectWhereExpressionContains(TableInfo tb, Type enreplacedyType, string csName, object[] arrayValue) {
var mwhereParamExp = Expression.Parameter(typeof(object), "a");
var selectExp = arrayValue.Select(c => Expression.Convert(Expression.Constant(FreeSql.Internal.Utils.GetDataReaderValue(tb.Columns[csName].CsType, c)), tb.Columns[csName].CsType)).ToArray();
var mwhereExp = Expression.Lambda<Func<object, bool>>(
Expression.Call(
Utils.GetLinqContains(tb.Columns[csName].CsType),
Expression.NewArrayInit(
tb.Columns[csName].CsType,
selectExp
),
Expression.MakeMemberAccess(Expression.TypeAs(mwhereParamExp, enreplacedyType), tb.Properties[csName])
),
mwhereParamExp);
return mwhereExp;
}
19
View Source File : Utils.cs
License : MIT License
Project Creator : 2881099
License : MIT License
Project Creator : 2881099
public static Expression<Func<object, bool>> GetObjectWhereExpression(TableInfo tb, Type enreplacedyType, string csName, object constValue) {
var mwhereParamExp = Expression.Parameter(typeof(object), "a");
var mwhereExp = Expression.Lambda<Func<object, bool>>(
Expression.Equal(
Expression.MakeMemberAccess(
Expression.TypeAs(mwhereParamExp, enreplacedyType),
tb.Properties[csName]
),
Expression.Constant(constValue)
),
mwhereParamExp
);
return mwhereExp;
}
19
View Source File : ExpressionVisitor`1.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
protected void EnableDynamicVisiting()
{
if (dynamicVisit != null)
return;
Type returnType = typeof(T);
ParameterExpression exprParam = Expression.Parameter(typeof(Expression), "node");
Expression body = Expression.Call(Expression.Constant(this), nameof(DefaultVisit), null, exprParam);
foreach (MethodInfo method in this.GetType().GetTypeInfo().DeclaredMethods)
{
if (method.ReturnType != returnType || !method.Name.StartsWith("Visit"))
continue;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 1)
continue;
ParameterInfo parameter = parameters[0];
if (!parameter.ParameterType.IsreplacedignableTo(typeof(Expression)))
continue;
// We got this far, it's a valid Visit*() method.
ParameterExpression exprVar = Expression.Parameter(parameter.ParameterType, parameter.Name);
// expr is TExpr newExpr ? newExpr : body
body = Expression.Block(new[] { exprVar },
Expression.replacedign(exprVar, Expression.TypeAs(exprParam, parameter.ParameterType)),
Expression.Condition(
Expression.ReferenceNotEqual(exprVar, Expression.Constant(null)),
exprVar,
body
)
);
}
dynamicVisit = Expression.Lambda<Func<Expression, T>>(body, exprParam).Compile();
}
19
View Source File : StateMachineExpression.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
protected void SetType(Type lambdaType, Type smType)
{
Requires.NotNull(lambdaType, nameof(lambdaType));
Requires.NotNull(smType, nameof(smType));
_type = lambdaType;
_end = Label(lambdaType, "end");
_state = Parameter(smType, "state");
_vsmCtor = smType.GetTypeInfo().DeclaredConstructors.First(x => x.GetParameters().Length == 0);
}
19
View Source File : Loops.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
[Fact]
public void ShouldRespectWhile()
{
ParameterExpression nbr = Expression.Variable(typeof(int), nameof(nbr));
ParameterExpression output = Expression.Parameter(typeof(List<int>), "output");
List<int> addedItems = new List<int>();
WhileExpression loop = X.While(
Expression.LessThan(Expression.PostIncrementreplacedign(nbr), Expression.Constant(10)),
Expression.Call(output, nameof(List<int>.Add), null, nbr)
);
Expression
.Lambda<Action<List<int>>>(Expression.Block(new[] { nbr }, loop), output)
.Compile()(addedItems);
addedItems.Count.ShouldBe(10);
int index = 0;
while (index++ < 10)
addedItems[index - 1].ShouldBe(index);
}
19
View Source File : StateMachines.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
[Fact]
public void ShouldCreateComplexIterator()
{
ParameterExpression i = Expression.Parameter(typeof(int), "i");
IteratorExpression enumerable = X.Enumerable(
X.While(Expression.LessThan(i, 20.AsExpression()),
X.Yield(Expression.PostIncrementreplacedign(i))
)
);
enumerable
.Compile<int>()
.SequenceEqual(Enumerable.Range(0, 20))
.ShouldBeTrue();
}
19
View Source File : LinkedExpression.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
private static Action<T> GetCompiledSetter(Expression<Func<T>> lambda)
{
ParameterExpression parameter = Parameter(typeof(T), "value");
return Lambda<Action<T>>(replacedign(lambda.Body, parameter), parameter).Compile();
}
19
View Source File : Loops.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
[Fact]
public void ShouldIterateArray()
{
ParameterExpression output = Expression.Parameter(typeof(List<string>), "output");
ParameterExpression item = Expression.Variable(typeof(string), "item");
ConstantExpression items = Expression.Constant(new[] { "hello", "world" });
List<string> addedItems = new List<string>();
ForEachExpression loop = X.ForEach(item, items,
Expression.Call(output, nameof(List<string>.Add), null, item)
);
Expression
.Lambda<Action<List<string>>>(loop, output)
.Compile()(addedItems);
addedItems.Count.ShouldBe(2);
addedItems[0].ShouldBe("hello");
addedItems[1].ShouldBe("world");
}
19
View Source File : Loops.cs
License : MIT License
Project Creator : 71
License : MIT License
Project Creator : 71
[Fact]
public void ShouldIterateEnumerable()
{
ParameterExpression output = Expression.Parameter(typeof(List<string>), "output");
ParameterExpression item = Expression.Variable(typeof(string), "item");
ConstantExpression items = Expression.Constant(Enumerable.Repeat("hello world", 10));
List<string> addedItems = new List<string>();
ForEachExpression loop = X.ForEach(item, items,
Expression.Call(output, nameof(List<string>.Add), null, item)
);
Expression
.Lambda<Action<List<string>>>(loop, output)
.Compile()(addedItems);
addedItems.Count.ShouldBe(10);
addedItems[0].ShouldBe("hello world");
}
19
View Source File : GameAttackTrigger.cs
License : Apache License 2.0
Project Creator : AantCoder
License : Apache License 2.0
Project Creator : AantCoder
public static Pawn GetPawn(this Pawn_JobTracker keeper)
{
/*
FieldInfo fieldInfo = typeof(Pawn_JobTracker).GetField("pawn", BindingFlags.Instance | BindingFlags.NonPublic);
Pawn result = (Pawn)fieldInfo.GetValue(keeper);
return result;
*/
if (GetPawnFromPawn_JobTracker == null)
{
ParameterExpression keeperArg = Expression.Parameter(typeof(Pawn_JobTracker), "keeper"); // SecretKeeper keeper argument
Expression secretAccessor = Expression.Field(keeperArg, "pawn"); // keeper._secret
var lambda = Expression.Lambda<Func<Pawn_JobTracker, Pawn>>(secretAccessor, keeperArg);
GetPawnFromPawn_JobTracker = lambda.Compile(); // Получается функция return result = keeper._secret;
}
return GetPawnFromPawn_JobTracker(keeper);
}
19
View Source File : FdbConverters.cs
License : MIT License
Project Creator : abdullin
License : MIT License
Project Creator : abdullin
private static Delegate CreateCaster(Type type)
{
var prm = Expression.Parameter(typeof(object), "value");
//TODO: valuetype vs ref type ?
var body = Expression.Convert(prm, type);
var lambda = Expression.Lambda(body, true, prm);
return lambda.Compile();
}
19
View Source File : FdbTuplePackers.cs
License : MIT License
Project Creator : abdullin
License : MIT License
Project Creator : abdullin
private static Delegate MakeNullableDeserializer([NotNull] Type nullableType, [NotNull] Type type, [NotNull] Delegate decoder)
{
Contract.Requires(nullableType != null && type != null && decoder != null);
// We have a Decoder of T, but we have to transform it into a Decoder for Nullable<T>, which returns null if the slice is "nil", or falls back to the underlying decoder if the slice contains something
var prmSlice = Expression.Parameter(typeof(Slice), "slice");
var body = Expression.Condition(
// IsNilSegment(slice) ?
Expression.Call(typeof(FdbTuplePackers).GetMethod("IsNilSegment", BindingFlags.Static | BindingFlags.NonPublic), prmSlice),
// True => default(Nullable<T>)
Expression.Default(nullableType),
// False => decoder(slice)
Expression.Convert(Expression.Invoke(Expression.Constant(decoder), prmSlice), nullableType)
);
return Expression.Lambda(body, prmSlice).Compile();
}
19
View Source File : TokenTypes.Keywords.cs
License : MIT License
Project Creator : adamant
License : MIT License
Project Creator : adamant
private static Func<TextSpan, T> CompileFactory<T>(Type tokenType)
where T : IToken
{
var spanParam = Expression.Parameter(typeof(TextSpan), "span");
var newExpression = Expression.New(tokenType.GetConstructor(new[] { typeof(TextSpan) }), spanParam);
var factory =
Expression.Lambda<Func<TextSpan, T>>(
newExpression, spanParam);
return factory.Compile();
}
19
View Source File : PluralExpressionCompiler.cs
License : MIT License
Project Creator : adams85
License : MIT License
Project Creator : adams85
public Func<int, int> Compile()
{
_param = Expression.Parameter(typeof(int), "n");
Expression expression = Visit(_syntaxTree);
var lambda = Expression.Lambda<Func<int, int>>(expression, _param);
return lambda.Compile();
}
19
View Source File : IssueForumDataAdapter.cs
License : MIT License
Project Creator : Adoxio
License : MIT License
Project Creator : Adoxio
public virtual IEnumerable<IIssue> SelectIssues(int startRowIndex = 0, int maximumRows = -1)
{
if (startRowIndex < 0)
{
throw new ArgumentException("Value must be a positive integer.", "startRowIndex");
}
if (maximumRows == 0)
{
return new IIssue[] { };
}
var serviceContext = Dependencies.GetServiceContext();
var includeUnapprovedIssues = TryreplacedertIssuePreviewPermission(serviceContext);
var query = serviceContext.CreateQuery("adx_issue")
.Where(issue => issue.GetAttributeValue<EnreplacedyReference>("adx_issueforumid") == IssueForum
&& issue.GetAttributeValue<OptionSetValue>("statecode") != null && issue.GetAttributeValue<OptionSetValue>("statecode").Value == 0);
if (!includeUnapprovedIssues)
{
query = query.Where(issue => issue.GetAttributeValue<bool?>("adx_approved").GetValueOrDefault(false));
}
if (Priority.HasValue)
{
query = query.Where(issue => issue.GetAttributeValue<OptionSetValue>("adx_priority") != null && issue.GetAttributeValue<OptionSetValue>("adx_priority").Value == Priority.Value);
}
if (Status.Any())
{
var param = Expression.Parameter(typeof(Enreplacedy), "issue");
var left =
Expression.Call(
param,
"GetAttributeValue",
new[] { typeof(int) },
Expression.Constant("statuscode"));
var statusEquals = Status.Aggregate<int, Expression>(null, (current, status) =>
current == null
? Expression.Equal(left, Expression.Constant(status))
: Expression.OrElse(current, Expression.Equal(left, Expression.Constant(status))));
var statusPredicate = Expression.Lambda(statusEquals, param) as Expression<Func<Enreplacedy, bool>>;
query = query.Where(statusPredicate);
}
query = query.OrderByDescending(issue => issue.GetAttributeValue<DateTime?>("adx_date"));
if (startRowIndex > 0)
{
query = query.Skip(startRowIndex);
}
if (maximumRows > 0)
{
query = query.Take(maximumRows);
}
return new IssueFactory(serviceContext, Dependencies.GetHttpContext()).Create(query);
}
19
View Source File : CrmContactRoleProvider.cs
License : MIT License
Project Creator : Adoxio
License : MIT License
Project Creator : Adoxio
private static Expression<Func<TParameter, bool>> ContainsPropertyValueEqual<TParameter>(string crmPropertyName, IEnumerable<object> values)
{
var parameterType = typeof(TParameter);
var parameter = Expression.Parameter(parameterType, parameterType.Name.ToLowerInvariant());
var expression = ContainsPropertyValueEqual(crmPropertyName, values, parameter);
return Expression.Lambda<Func<TParameter, bool>>(expression, parameter);
}
19
View Source File : XrmQueryExtensions.cs
License : MIT License
Project Creator : Adoxio
License : MIT License
Project Creator : Adoxio
private static Expression<Func<TParameter, bool>> ContainsPropertyValueEqual<TParameter>(string propertyName1,
string propertyName2, IEnumerable<Tuple<string, string>> values)
{
var parameterType = typeof(TParameter);
var parameter = Expression.Parameter(parameterType, parameterType.Name.ToLowerInvariant());
var expression = ContainsPropertyValueEqual(propertyName1, propertyName2, values, parameter);
return Expression.Lambda<Func<TParameter, bool>>(expression, parameter);
}
19
View Source File : MapController.cs
License : MIT License
Project Creator : Adoxio
License : MIT License
Project Creator : Adoxio
private static Expression<Func<TParameter, bool>> ContainsPropertyValueEqual<TParameter>(string crmPropertyName, IEnumerable<Guid> values)
{
var parameterType = typeof(TParameter);
var parameter = Expression.Parameter(parameterType, parameterType.Name.ToLowerInvariant());
var expression = ContainsPropertyValueEqual(crmPropertyName, values, parameter);
return Expression.Lambda<Func<TParameter, bool>>(expression, parameter);
}
19
View Source File : Serializer.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
static Func<Dictionary<string, string>, T> CompileDeserializer()
{
var o_t = typeof(T);
var o_ctor = o_t.GetConstructor(new[] { typeof(SerializationInfo), typeof(StreamingContext) });
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Parameter(d_t, "d");
var d_mi_get_enumerator = d_t.GetMethod("GetEnumerator");
var fc_t = typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_mi_add_value = info_t.GetMethod("AddValue", new[] { typeof(String), typeof(Object) });
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(Dictionary<string, string>.Enumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_mi_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_current = Expression.Property(enumerator, "Current");
var kvp_t = typeof(KeyValuePair<string, string>);
var kvp_pi_key = kvp_t.GetProperty("Key");
var kvp_pi_value = kvp_t.GetProperty("Value");
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { fc, info, ctx, enumerator },
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.replacedign(enumerator, Expression.Call(d, d_mi_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_mi_move_next),
Expression.Call(info, info_mi_add_value, Expression.Property(enumerator_current, kvp_pi_key), Expression.Property(enumerator_current, kvp_pi_value)),
Expression.Break(exit_loop)),
exit_loop),
Expression.MemberInit(Expression.New(o_ctor, info, ctx))
);
return Expression.Lambda<Func<Dictionary<string, string>, T>>(body, d)
.Compile();
}
19
View Source File : Serializer.cs
License : Mozilla Public License 2.0
Project Creator : agebullhu
License : Mozilla Public License 2.0
Project Creator : agebullhu
static Func<T, Dictionary<string, string>> CompileSerializer()
{
var o_t = typeof(T);
var o = Expression.Parameter(o_t, "original");
var o_get_object_data = o_t.GetMethod("GetObjectData");
var d_t = typeof(Dictionary<string, string>);
var d = Expression.Variable(d_t, "d"); // define object variable
var d_init = Expression.MemberInit(Expression.New(d_t)); // object ctor
var d_add = d_t.GetMethod("Add"); // add method
var fc_t = typeof(LocalVariableInfo);
var fc = Expression.Variable(fc_t, "fc");
var fc_init = Expression.MemberInit(Expression.New(fc_t));
var info_t = typeof(SerializationInfo);
var info = Expression.Variable(info_t, "info");
var info_ctor = info_t.GetConstructor(new[] { typeof(Type), fc_t });
var info_init = Expression.MemberInit(Expression.New(info_ctor, Expression.Constant(o_t), fc));
var info_get_enumerator = info_t.GetMethod("GetEnumerator");
var ctx_t = typeof(StreamingContext);
var ctx = Expression.Variable(ctx_t, "ctx");
var ctx_init = Expression.MemberInit(Expression.New(ctx_t));
var enumerator_t = typeof(SerializationInfoEnumerator);
var enumerator = Expression.Variable(enumerator_t, "enumerator");
var enumerator_move_next = enumerator_t.GetMethod("MoveNext");
var enumerator_name = Expression.Property(enumerator, "Name");
var enumerator_value = Expression.Property(enumerator, "Value");
var mi_to_string = typeof(Object).GetMethod("ToString", new Type[0]);
var exit_loop = Expression.Label("exit_loop");
var body = Expression.Block(new[] { d, fc, info, ctx },
Expression.replacedign(d, d_init),
Expression.replacedign(fc, fc_init),
Expression.replacedign(info, info_init),
Expression.replacedign(ctx, ctx_init),
Expression.Call(o, o_get_object_data, info, ctx),
Expression.Block(new[] { enumerator },
Expression.replacedign(enumerator, Expression.Call(info, info_get_enumerator)),
Expression.Loop(
Expression.IfThenElse(
Expression.Call(enumerator, enumerator_move_next), // test
Expression.IfThen(
Expression.NotEqual(enumerator_value, Expression.Constant(null)),
Expression.Call(d, d_add, enumerator_name, Expression.Call(enumerator_value, mi_to_string))
),
Expression.Break(exit_loop)), // if false
exit_loop)),
d); // return
// compile
return Expression.Lambda<Func<T, Dictionary<string, string>>>(body, o)
.Compile();
}
19
View Source File : QueryableExtensions.cs
License : Apache License 2.0
Project Creator : Aguafrommars
License : Apache License 2.0
Project Creator : Aguafrommars
public static IOrderedQueryable<T> CallOrderedQueryable<T>(this IQueryable<T> query, string methodName, string propertyName,
IComparer<object> comparer = null)
{
var param = Expression.Parameter(typeof(T), "x");
var body = propertyName.Split('.').Aggregate<string, Expression>(param, Expression.PropertyOrField);
return comparer != null
? (IOrderedQueryable<T>)query.Provider.CreateQuery(
Expression.Call(
typeof(Queryable),
methodName,
new[] { typeof(T), body.Type },
query.Expression,
Expression.Lambda(body, param),
Expression.Constant(comparer)
)
)
: (IOrderedQueryable<T>)query.Provider.CreateQuery(
Expression.Call(
typeof(Queryable),
methodName,
new[] { typeof(T), body.Type },
query.Expression,
Expression.Lambda(body, param)
)
);
}
19
View Source File : ExpressionReflectionDelegateFactory.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
public override Func<T, object> CreateGet<T>(FieldInfo fieldInfo)
{
ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
ParameterExpression sourceParameter = Expression.Parameter(typeof(T), "source");
Expression fieldExpression;
if (fieldInfo.IsStatic)
{
fieldExpression = Expression.Field(null, fieldInfo);
}
else
{
Expression sourceExpression = EnsureCastExpression(sourceParameter, fieldInfo.DeclaringType);
fieldExpression = Expression.Field(sourceExpression, fieldInfo);
}
fieldExpression = EnsureCastExpression(fieldExpression, typeof(object));
Func<T, object> compiled = Expression.Lambda<Func<T, object>>(fieldExpression, sourceParameter).Compile();
return compiled;
}
19
View Source File : ExpressionReflectionDelegateFactory.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
public override Action<T, object> CreateSet<T>(FieldInfo fieldInfo)
{
ValidationUtils.ArgumentNotNull(fieldInfo, nameof(fieldInfo));
// use reflection for structs
// expression doesn't correctly set value
if (fieldInfo.DeclaringType.IsValueType() || fieldInfo.IsInitOnly)
{
return LateBoundReflectionDelegateFactory.Instance.CreateSet<T>(fieldInfo);
}
ParameterExpression sourceParameterExpression = Expression.Parameter(typeof(T), "source");
ParameterExpression valueParameterExpression = Expression.Parameter(typeof(object), "value");
Expression fieldExpression;
if (fieldInfo.IsStatic)
{
fieldExpression = Expression.Field(null, fieldInfo);
}
else
{
Expression sourceExpression = EnsureCastExpression(sourceParameterExpression, fieldInfo.DeclaringType);
fieldExpression = Expression.Field(sourceExpression, fieldInfo);
}
Expression valueExpression = EnsureCastExpression(valueParameterExpression, fieldExpression.Type);
BinaryExpression replacedignExpression = Expression.replacedign(fieldExpression, valueExpression);
LambdaExpression lambdaExpression = Expression.Lambda(typeof(Action<T, object>), replacedignExpression, sourceParameterExpression, valueParameterExpression);
Action<T, object> compiled = (Action<T, object>)lambdaExpression.Compile();
return compiled;
}
19
View Source File : ExpressionReflectionDelegateFactory.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
public override Action<T, object> CreateSet<T>(PropertyInfo propertyInfo)
{
ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
// use reflection for structs
// expression doesn't correctly set value
if (propertyInfo.DeclaringType.IsValueType())
{
return LateBoundReflectionDelegateFactory.Instance.CreateSet<T>(propertyInfo);
}
Type instanceType = typeof(T);
Type valueType = typeof(object);
ParameterExpression instanceParameter = Expression.Parameter(instanceType, "instance");
ParameterExpression valueParameter = Expression.Parameter(valueType, "value");
Expression readValueParameter = EnsureCastExpression(valueParameter, propertyInfo.PropertyType);
MethodInfo setMethod = propertyInfo.GetSetMethod(true);
Expression setExpression;
if (setMethod.IsStatic)
{
setExpression = Expression.Call(setMethod, readValueParameter);
}
else
{
Expression readInstanceParameter = EnsureCastExpression(instanceParameter, propertyInfo.DeclaringType);
setExpression = Expression.Call(readInstanceParameter, setMethod, readValueParameter);
}
LambdaExpression lambdaExpression = Expression.Lambda(typeof(Action<T, object>), setExpression, instanceParameter, valueParameter);
Action<T, object> compiled = (Action<T, object>)lambdaExpression.Compile();
return compiled;
}
19
View Source File : DynamicProxyMetaObject.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
private DynamicMetaObject BuildCallMethodWithResult(string methodName, DynamicMetaObjectBinder binder, Expression[] args, DynamicMetaObject fallbackResult, Fallback fallbackInvoke)
{
//
// Build a new expression like:
// {
// object result;
// TryGetMember(payload, out result) ? fallbackInvoke(result) : fallbackResult
// }
//
ParameterExpression result = Expression.Parameter(typeof(object), null);
IList<Expression> callArgs = new List<Expression>();
callArgs.Add(Expression.Convert(Expression, typeof(T)));
callArgs.Add(Constant(binder));
callArgs.AddRange(args);
callArgs.Add(result);
DynamicMetaObject resultMetaObject = new DynamicMetaObject(result, BindingRestrictions.Empty);
// Need to add a conversion if calling TryConvert
if (binder.ReturnType != typeof(object))
{
UnaryExpression convert = Expression.Convert(resultMetaObject.Expression, binder.ReturnType);
// will always be a cast or unbox
resultMetaObject = new DynamicMetaObject(convert, resultMetaObject.Restrictions);
}
if (fallbackInvoke != null)
{
resultMetaObject = fallbackInvoke(resultMetaObject);
}
DynamicMetaObject callDynamic = new DynamicMetaObject(
Expression.Block(
new[] { result },
Expression.Condition(
Expression.Call(
Expression.Constant(_proxy),
typeof(DynamicProxy<T>).GetMethod(methodName),
callArgs
),
resultMetaObject.Expression,
fallbackResult.Expression,
binder.ReturnType
)
),
GetRestrictions().Merge(resultMetaObject.Restrictions).Merge(fallbackResult.Restrictions)
);
return callDynamic;
}
19
View Source File : DynamicProxyMetaObject.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
private DynamicMetaObject CallMethodReturnLast(string methodName, DynamicMetaObjectBinder binder, Expression[] args, Fallback fallback)
{
//
// First, call fallback to do default binding
// This produces either an error or a call to a .NET member
//
DynamicMetaObject fallbackResult = fallback(null);
//
// Build a new expression like:
// {
// object result;
// TrySetMember(payload, result = value) ? result : fallbackResult
// }
//
ParameterExpression result = Expression.Parameter(typeof(object), null);
IList<Expression> callArgs = new List<Expression>();
callArgs.Add(Expression.Convert(Expression, typeof(T)));
callArgs.Add(Constant(binder));
callArgs.AddRange(args);
callArgs[args.Length + 1] = Expression.replacedign(result, callArgs[args.Length + 1]);
DynamicMetaObject callDynamic = new DynamicMetaObject(
Expression.Block(
new[] { result },
Expression.Condition(
Expression.Call(
Expression.Constant(_proxy),
typeof(DynamicProxy<T>).GetMethod(methodName),
callArgs
),
result,
fallbackResult.Expression,
typeof(object)
)
),
GetRestrictions().Merge(fallbackResult.Restrictions)
);
//
// Now, call fallback again using our new MO as the error
// When we do this, one of two things can happen:
// 1. Binding will succeed, and it will ignore our call to
// the dynamic method, OR
// 2. Binding will fail, and it will use the MO we created
// above.
//
return _dontFallbackFirst ? callDynamic : fallback(callDynamic);
}
19
View Source File : ExpressionReflectionDelegateFactory.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
public override Func<T, object> CreateGet<T>(PropertyInfo propertyInfo)
{
ValidationUtils.ArgumentNotNull(propertyInfo, nameof(propertyInfo));
Type instanceType = typeof(T);
Type resultType = typeof(object);
ParameterExpression parameterExpression = Expression.Parameter(instanceType, "instance");
Expression resultExpression;
MethodInfo getMethod = propertyInfo.GetGetMethod(true);
if (getMethod.IsStatic)
{
resultExpression = Expression.MakeMemberAccess(null, propertyInfo);
}
else
{
Expression readParameter = EnsureCastExpression(parameterExpression, propertyInfo.DeclaringType);
resultExpression = Expression.MakeMemberAccess(readParameter, propertyInfo);
}
resultExpression = EnsureCastExpression(resultExpression, resultType);
LambdaExpression lambdaExpression = Expression.Lambda(typeof(Func<T, object>), resultExpression, parameterExpression);
Func<T, object> compiled = (Func<T, object>)lambdaExpression.Compile();
return compiled;
}
19
View Source File : ExpressionReflectionDelegateFactory.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
public override ObjectConstructor<object> CreateParameterizedConstructor(MethodBase method)
{
ValidationUtils.ArgumentNotNull(method, nameof(method));
Type type = typeof(object);
ParameterExpression argsParameterExpression = Expression.Parameter(typeof(object[]), "args");
Expression callExpression = BuildMethodCall(method, type, null, argsParameterExpression);
LambdaExpression lambdaExpression = Expression.Lambda(typeof(ObjectConstructor<object>), callExpression, argsParameterExpression);
ObjectConstructor<object> compiled = (ObjectConstructor<object>)lambdaExpression.Compile();
return compiled;
}
19
View Source File : ExpressionReflectionDelegateFactory.cs
License : MIT License
Project Creator : akaskela
License : MIT License
Project Creator : akaskela
public override MethodCall<T, object> CreateMethodCall<T>(MethodBase method)
{
ValidationUtils.ArgumentNotNull(method, nameof(method));
Type type = typeof(object);
ParameterExpression targetParameterExpression = Expression.Parameter(type, "target");
ParameterExpression argsParameterExpression = Expression.Parameter(typeof(object[]), "args");
Expression callExpression = BuildMethodCall(method, type, targetParameterExpression, argsParameterExpression);
LambdaExpression lambdaExpression = Expression.Lambda(typeof(MethodCall<T, object>), callExpression, targetParameterExpression, argsParameterExpression);
MethodCall<T, object> compiled = (MethodCall<T, object>)lambdaExpression.Compile();
return compiled;
}
19
View Source File : ExpressionHelper.cs
License : MIT License
Project Creator : Akinzekeel
License : MIT License
Project Creator : Akinzekeel
public static LambdaExpression CreatePropertyExpression<T>(string PropertyName)
{
var enreplacedyType = typeof(T);
ParameterExpression arg = Expression.Parameter(enreplacedyType, "x");
// The property name might be a nested expression like a.b.c
var path = PropertyName.Split('.');
MemberExpression currentPath = null;
foreach (var p in path)
{
if (currentPath == null)
{
currentPath = Expression.Property(arg, p);
}
else
{
currentPath = Expression.Property(currentPath, p);
}
}
var selector = Expression.Lambda(currentPath, new ParameterExpression[] { arg });
return selector;
}
19
View Source File : GreedyMetaDynamic.cs
License : MIT License
Project Creator : albahari
License : MIT License
Project Creator : albahari
private DynamicMetaObject BuildCallMethodWithResult<TBinder> (MethodInfo method, TBinder binder, Expression[] args, DynamicMetaObject fallbackResult, Fallback<TBinder> fallbackInvoke)
where TBinder : DynamicMetaObjectBinder
{
if (!IsOverridden (method))
{
return fallbackResult;
}
//
// Build a new expression like:
// {
// object result;
// TryGetMember(payload, out result) ? fallbackInvoke(result) : fallbackResult
// }
//
ParameterExpression result = Expression.Parameter (typeof (object), null);
ParameterExpression callArgs = method != DynamicObject_TryBinaryOperation ? Expression.Parameter (typeof (object[]), null) : Expression.Parameter (typeof (object), null);
ReadOnlyCollection<Expression> callArgsValue = GetConvertedArgs (args);
var resultMO = new DynamicMetaObject (result, BindingRestrictions.Empty);
// Need to add a conversion if calling TryConvert
if (binder.ReturnType != typeof (object))
{
Debug.replacedert (binder is ConvertBinder && fallbackInvoke == null);
UnaryExpression convert = Expression.Convert (resultMO.Expression, binder.ReturnType);
// will always be a cast or unbox
Debug.replacedert (convert.Method == null);
// Prepare a good exception message in case the convert will fail
// JJA - we don't have access to the Strings type:
//string convertFailed = System.Linq.Expressions.Strings.DynamicObjectResultNotreplacedignable (
// "{0}",
// this.Value.GetType(),
// binder.GetType(),
// binder.ReturnType
//);
string convertFailed = $"Dynamic conversion failed: Could not convert type '{Value.WrappedType}' to '{binder.ReturnType}'.";
Expression condition;
// If the return type can not be replacedigned null then just check for type replacedignability otherwise allow null.
if (binder.ReturnType.IsValueType && Nullable.GetUnderlyingType (binder.ReturnType) == null)
{
condition = Expression.TypeIs (resultMO.Expression, binder.ReturnType);
}
else
{
condition = Expression.OrElse (
Expression.Equal (resultMO.Expression, AstUtils.Null),
Expression.TypeIs (resultMO.Expression, binder.ReturnType));
}
Expression checkedConvert = Expression.Condition (
condition,
convert,
Expression.Throw (
Expression.New (
InvalidCastException_Ctor_String,
new TrueReadOnlyCollection<Expression> (
Expression.Call (
String_Format_String_ObjectArray,
Expression.Constant (convertFailed),
Expression.NewArrayInit (
typeof (object),
new TrueReadOnlyCollection<Expression> (
Expression.Condition (
Expression.Equal (resultMO.Expression, AstUtils.Null),
Expression.Constant ("null"),
Expression.Call (
resultMO.Expression,
Object_GetType
),
typeof (object)
)
)
)
)
)
),
binder.ReturnType
),
binder.ReturnType
);
resultMO = new DynamicMetaObject (checkedConvert, resultMO.Restrictions);
}
if (fallbackInvoke != null)
{
resultMO = fallbackInvoke (this, binder, resultMO);
}
var callDynamic = new DynamicMetaObject (
Expression.Block (
new TrueReadOnlyCollection<ParameterExpression> (result, callArgs),
new TrueReadOnlyCollection<Expression> (
method != DynamicObject_TryBinaryOperation ? Expression.replacedign (callArgs, Expression.NewArrayInit (typeof (object), callArgsValue)) : Expression.replacedign (callArgs, callArgsValue[0]),
Expression.Condition (
Expression.Call (
GetLimitedSelf (),
method,
BuildCallArgs (
binder,
method.Name == "TryInvokeMember", // JJA
args,
callArgs,
result
)
),
Expression.Block (
method != DynamicObject_TryBinaryOperation ? ReferenceArgreplacedign (callArgs, args) : AstUtils.Empty,
resultMO.Expression
),
fallbackResult.Expression,
binder.ReturnType
)
)
),
GetRestrictions ().Merge (resultMO.Restrictions).Merge (fallbackResult.Restrictions)
);
return callDynamic;
}
19
View Source File : GreedyMetaDynamic.cs
License : MIT License
Project Creator : albahari
License : MIT License
Project Creator : albahari
private DynamicMetaObject CallMethodReturnLast<TBinder> (MethodInfo method, TBinder binder, Expression[] args, Expression value, Fallback<TBinder> fallback)
where TBinder : DynamicMetaObjectBinder
{
//
// First, call fallback to do default binding
// This produces either an error or a call to a .NET member
//
DynamicMetaObject fallbackResult = fallback (this, binder, null);
//
// Build a new expression like:
// {
// object result;
// TrySetMember(payload, result = value) ? result : fallbackResult
// }
//
ParameterExpression result = Expression.Parameter (typeof (object), null);
ParameterExpression callArgs = Expression.Parameter (typeof (object[]), null);
ReadOnlyCollection<Expression> callArgsValue = GetConvertedArgs (args);
var callDynamic = new DynamicMetaObject (
Expression.Block (
new TrueReadOnlyCollection<ParameterExpression> (result, callArgs),
new TrueReadOnlyCollection<Expression> (
Expression.replacedign (callArgs, Expression.NewArrayInit (typeof (object), callArgsValue)),
Expression.Condition (
Expression.Call (
GetLimitedSelf (),
method,
BuildCallArgs (
binder,
method.Name == "TryInvokeMember", // JJA
args,
callArgs,
Expression.replacedign (result, Expression.Convert (value, typeof (object)))
)
),
Expression.Block (
ReferenceArgreplacedign (callArgs, args),
result
),
fallbackResult.Expression,
typeof (object)
)
)
),
GetRestrictions ().Merge (fallbackResult.Restrictions)
);
//
// Now, call fallback again using our new MO as the error
// When we do this, one of two things can happen:
// 1. Binding will succeed, and it will ignore our call to
// the dynamic method, OR
// 2. Binding will fail, and it will use the MO we created
// above.
//
return fallback (this, binder, callDynamic);
}
19
View Source File : GreedyMetaDynamic.cs
License : MIT License
Project Creator : albahari
License : MIT License
Project Creator : albahari
private DynamicMetaObject CallMethodNoResult<TBinder> (MethodInfo method, TBinder binder, Expression[] args, Fallback<TBinder> fallback)
where TBinder : DynamicMetaObjectBinder
{
//
// First, call fallback to do default binding
// This produces either an error or a call to a .NET member
//
DynamicMetaObject fallbackResult = fallback (this, binder, null);
ParameterExpression callArgs = Expression.Parameter (typeof (object[]), null);
ReadOnlyCollection<Expression> callArgsValue = GetConvertedArgs (args);
//
// Build a new expression like:
// if (TryDeleteMember(payload)) { } else { fallbackResult }
//
var callDynamic = new DynamicMetaObject (
Expression.Block (
new TrueReadOnlyCollection<ParameterExpression> (callArgs),
new TrueReadOnlyCollection<Expression> (
Expression.replacedign (callArgs, Expression.NewArrayInit (typeof (object), callArgsValue)),
Expression.Condition (
Expression.Call (
GetLimitedSelf (),
method,
BuildCallArgs (
binder,
method.Name == "TryInvokeMember", // JJA
args,
callArgs,
null
)
),
Expression.Block (
ReferenceArgreplacedign (callArgs, args),
AstUtils.Empty
),
fallbackResult.Expression,
typeof (void)
)
)
),
GetRestrictions ().Merge (fallbackResult.Restrictions)
);
//
// Now, call fallback again using our new MO as the error
// When we do this, one of two things can happen:
// 1. Binding will succeed, and it will ignore our call to
// the dynamic method, OR
// 2. Binding will fail, and it will use the MO we created
// above.
//
return fallback (this, binder, callDynamic);
}
19
View Source File : DelegateGenerator.cs
License : MIT License
Project Creator : albyho
License : MIT License
Project Creator : albyho
public Func<List<object>, object> Generate(Expression exp)
{
_parameterCount = 0;
_parametersExpression =
Expression.Parameter(typeof(List<object>), "parameters");
var body = this.Visit(exp); // normalize
if (body.Type != typeof(object))
{
body = Expression.Convert(body, typeof(object));
}
var lambda = Expression.Lambda<Func<List<object>, object>>(body, _parametersExpression);
return lambda.Compile();
}
19
View Source File : WeakTypeDelegateGenerator.cs
License : MIT License
Project Creator : albyho
License : MIT License
Project Creator : albyho
protected override Expression VisitConstant(ConstantExpression c)
{
var p = Expression.Parameter(c.Type, "p" + _parameters.Count);
_parameters.Add(p);
return p;
}
See More Examples