TReturn IQueryClient.Call <TReturn>(Type interfaceType, string methodName, object[] arguments) { try { var returnType = typeof(TReturn); var returnTypeDetails = TypeAnalyzer.GetTypeDetail(returnType); if (returnTypeDetails.IsTask) { var isStream = returnTypeDetails.InnerTypeDetails[0].BaseTypes.Contains(streamType); var callRequestMethodGeneric = TypeAnalyzer.GetGenericMethodDetail(callRequestAsyncMethod, returnTypeDetails.InnerTypes.ToArray()); return((TReturn)callRequestMethodGeneric.Caller(this, new object[] { isStream, interfaceType, methodName, arguments })); } else { var isStream = returnTypeDetails.BaseTypes.Contains(streamType); var model = CallInternal <TReturn>(isStream, interfaceType, methodName, arguments); return(model); } } catch (Exception ex) { _ = Log.ErrorAsync($"Call Failed", ex); throw; } }
private static object GetGeneric(Type type, Type providerInterfaceType, bool throwException) { var genericMethodProviderManagerTryGet = TypeAnalyzer.GetGenericMethodDetail(methodProviderManagerGet, type); var provider = genericMethodProviderManagerTryGet.Caller(providerInterfaceType, new object[] { providerInterfaceType, throwException }); return(provider); }
TReturn IQueryClient.Call <TReturn>(Type interfaceType, string methodName, object[] arguments) { var providerName = interfaceType.Name; var stringArguments = arguments.Select(x => JsonSerializer.Serialize(x)).ToArray(); var returnType = typeof(TReturn); var data = new CQRSRequestData() { ProviderType = providerName, ProviderMethod = methodName, }; data.AddProviderArguments(arguments); var returnTypeDetails = TypeAnalyzer.GetTypeDetail(returnType); if (returnTypeDetails.IsTask) { var callRequestAsyncMethodGeneric = TypeAnalyzer.GetGenericMethodDetail(requestAsyncMethod, returnTypeDetails.InnerTypes.ToArray()); return((TReturn)callRequestAsyncMethodGeneric.Caller(this, new object[] { endpointAddress, providerName, requestContentType, data, true })); } else { var model = Request <TReturn>(endpointAddress, providerName, requestContentType, data, true); return(model); } }
//public static IOrderedQueryable<TSource> OrderBy<TSource, TModel>(this IQueryable<TSource> source, QueryOrder<TModel> linqOrder) // where TModel : class, new() //{ // IQueryable<TSource> result = source; // foreach (var order in linqOrder.OrderExpressions.Reverse()) // { // var sourceOrder = LinqRebinder.RebindType(order.Expression, typeof(TModel), typeof(TSource)); // var propertyType = ((LambdaExpression)sourceOrder).ReturnType; // if (order.Descending) // { // var method = TypeAnalyzer.GetGenericMethod(queryableOrderByDescending, typeof(TSource), propertyType); // result = (IOrderedQueryable<TSource>)method.Caller(null, new object[] { result, sourceOrder }); // } // else // { // var method = TypeAnalyzer.GetGenericMethod(queryableOrderBy, typeof(TSource), propertyType); // result = (IOrderedQueryable<TSource>)method.Caller(null, new object[] { result, sourceOrder }); // } // } // return (IOrderedQueryable<TSource>)result; //} public static IOrderedQueryable <TModel> OrderBy <TModel>(this IQueryable <TModel> source, QueryOrder <TModel> linqOrder) where TModel : class, new() { IQueryable <TModel> result = source; foreach (var order in linqOrder.OrderExpressions.Reverse()) { var propertyType = ((LambdaExpression)order.Expression).ReturnType; if (order.Descending) { var method = TypeAnalyzer.GetGenericMethodDetail(queryableOrderByDescending, typeof(TModel), propertyType); result = (IOrderedQueryable <TModel>)method.Caller(null, new object[] { result, order.Expression }); } else { var method = TypeAnalyzer.GetGenericMethodDetail(queryableOrderBy, typeof(TModel), propertyType); result = (IOrderedQueryable <TModel>)method.Caller(null, new object[] { result, order.Expression }); } } return((IOrderedQueryable <TModel>)result); }
private void ToBytesSpecialTypeEnumerable(IEnumerable values, int length, SerializerTypeDetails typeDetail, ref ByteWriter writer) { var specialType = typeDetail.TypeDetail.IsNullable ? typeDetail.InnerTypeDetail.TypeDetail.SpecialType.Value : typeDetail.TypeDetail.SpecialType.Value; switch (specialType) { case SpecialType.Type: { foreach (var valueType in (IEnumerable <Type>)values) { writer.Write(valueType?.FullName, true); } return; } case SpecialType.Dictionary: { foreach (var value in values) { if (value != null) { writer.WriteNotNull(); var method = TypeAnalyzer.GetGenericMethodDetail(enumerableToArrayMethod, typeDetail.TypeDetail.IEnumerableGenericInnerType); var innerValue = (ICollection)method.Caller(null, new object[] { value }); var count = innerValue.Count; ToBytesEnumerable(innerValue, count, typeDetail.InnerTypeDetail, ref writer); } else { writer.WriteNull(); } } return; } default: throw new NotImplementedException(); } }
private void ToBytesSpecialType(object value, SerializerTypeDetails typeDetail, bool nullFlags, ref ByteWriter writer) { var specialType = typeDetail.TypeDetail.IsNullable ? typeDetail.InnerTypeDetail.TypeDetail.SpecialType.Value : typeDetail.TypeDetail.SpecialType.Value; switch (specialType) { case SpecialType.Type: { var valueType = value == null ? null : (Type)value; writer.Write(valueType?.FullName, nullFlags); } return; case SpecialType.Dictionary: { if (value != null) { if (nullFlags) { writer.WriteNotNull(); } var method = TypeAnalyzer.GetGenericMethodDetail(enumerableToArrayMethod, typeDetail.TypeDetail.IEnumerableGenericInnerType); var innerValue = (ICollection)method.Caller(null, new object[] { value }); var count = innerValue.Count; ToBytesEnumerable(innerValue, count, typeDetail.InnerTypeDetail, ref writer); } else if (nullFlags) { writer.WriteNull(); } } return; default: throw new NotImplementedException(); } }
public static void SetForeignIdentity(Type type, string foreignIdentityNames, object model, object identity) { var genericSetForeignIdentityMethod = TypeAnalyzer.GetGenericMethodDetail(setForeignIdentityMethod, type); genericSetForeignIdentityMethod.Caller(null, new object[] { foreignIdentityNames, model, identity }); }
public static object GetForeignIdentity(Type type, string foreignIdentityNames, object model) { var genericGetForeignIdentityMethod = TypeAnalyzer.GetGenericMethodDetail(getForeignIdentityMethod, type); return(genericGetForeignIdentityMethod.Caller(null, new object[] { foreignIdentityNames, model })); }
public static void SetIdentity(Type type, object model, object identity) { var genericSetIdentityMethod = TypeAnalyzer.GetGenericMethodDetail(setIdentityMethod, type); genericSetIdentityMethod.Caller(null, new object[] { model, identity }); }
public static object GetIdentity(Type type, object model) { var genericGetIdentityMethod = TypeAnalyzer.GetGenericMethodDetail(getIdentityMethod, type); return(genericGetIdentityMethod.Caller(null, new object[] { model })); }
public static Expression <Func <T, bool> > AppendExpressionOnMember <T>(Expression <Func <T, bool> > it, MemberInfo member, params Expression[] expressions) { PropertyInfo propertyInfo = null; FieldInfo fieldInfo = null; Type type; if (member.MemberType == MemberTypes.Property) { propertyInfo = (PropertyInfo)member; type = propertyInfo.PropertyType; } else if (member.MemberType == MemberTypes.Field) { fieldInfo = (FieldInfo)member; type = fieldInfo.FieldType; } else { throw new ArgumentException("Member is not a property or a field"); } LambdaExpression itLambda = (LambdaExpression)it; Expression exp = itLambda.Body; ParameterExpression parameter = itLambda.Parameters[0]; foreach (Expression expression in expressions) { LambdaExpression expressionLambda = expression as LambdaExpression; var typeDetails = TypeAnalyzer.GetTypeDetail(type); Type elementType = null; if (type.IsArray) { elementType = typeDetails.InnerTypes[0]; } else { if (typeDetails.InnerTypes.Count == 1) { elementType = typeDetails.InnerTypes[0]; } } if (elementType != null && typeDetails.IsIEnumerable) { Expression memberExpression = member.MemberType == MemberTypes.Property ? Expression.Property(parameter, propertyInfo) : Expression.Field(parameter, fieldInfo); MethodInfo anyMethod2Generic = TypeAnalyzer.GetGenericMethodDetail(anyMethod2, elementType).MethodInfo; MethodCallExpression callAny2 = Expression.Call(anyMethod2Generic, memberExpression, expressionLambda); MethodInfo anyMethod1Generic = TypeAnalyzer.GetGenericMethodDetail(anyMethod1, elementType).MethodInfo; MethodCallExpression callAny1 = Expression.Call(anyMethod1Generic, memberExpression); Expression emptyCheckExpression = Expression.OrElse(Expression.Not(callAny1), callAny2); if (exp.NodeType == ExpressionType.Constant && ((ConstantExpression)exp).Value?.ToString().ToBoolean() == true) { exp = emptyCheckExpression; } else { exp = Expression.AndAlso(exp, emptyCheckExpression); } } else { Expression memberExpression = member.MemberType == MemberTypes.Property ? Expression.Property(parameter, propertyInfo) : Expression.Field(parameter, fieldInfo); LambdaExpression convertedExpressionLambda = (LambdaExpression)LinqRebinder.RebindExpression(expressionLambda, expressionLambda.Parameters[0], memberExpression); Expression nullCheckExpression = Expression.OrElse(Expression.Equal(memberExpression, Expression.Constant(null)), convertedExpressionLambda.Body); if (exp.NodeType == ExpressionType.Constant && ((ConstantExpression)exp).Value?.ToString().ToBoolean() == true) { exp = nullCheckExpression; } else { exp = Expression.AndAlso(exp, nullCheckExpression); } } } return(Expression.Lambda <Func <T, bool> >(exp, itLambda.Parameters)); }