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