private void SetRequestTimeout(MethodContext methodContext, ParameterExpression param, IConnectionParameters dbParameters)
{
var propInfo = DbContextProxyHelper.GetConnectionParamsProperty(param.Type);
if (propInfo == null)
{
return;
}
var newDbConfig = Expression.New(typeof(ConnectionParameters).GetConstructor(new[] { typeof(IConnectionParameters) }), Expression.Constant(dbParameters));
methodContext.Do(Expression.Assign(Expression.Property(param, propInfo), newDbConfig));
}
private void GetBodyForMethod(MethodContext methodContext)
{
ParameterExpression param;
var ret = methodContext.Return(methodContext.TaskType);
var task = methodContext.AddVariable(typeof(Task <IDataReader>), "task");
var parameterConverter = StoredProcedureAttribute.GetConverter(Caller);
if (parameterConverter == null)
{
throw new InvalidOperationException($"Could not get parameter converter for method {Caller.Name} of type {Caller.DeclaringType.FullName}");
}
if (parameterConverter is DefaultParameterConverter parameterConverterInternal)
{
param = parameterConverterInternal.Convert(methodContext, Parameters, Caller);
}
else
{
param = CustomConverter(methodContext, parameterConverter);
}
var dbConnectionParameters = Caller.GetCustomAttribute <DbConnectionParametersAttribute>();
if (dbConnectionParameters != null)
{
SetRequestTimeout(methodContext, param, dbConnectionParameters);
}
var disp = methodContext.DispatcherMethod;
var arguments = GetDispatcherAttributes(methodContext, param, disp);
methodContext.Do(Expression.Assign(task,
disp == null ?
Expression.Call(ThisParameter, _nonDispatchedSpReaderWrapperMethodInfo, arguments) :
Expression.Call(ThisParameter, disp, arguments)));
var reader = GetReaderWrapper(methodContext);
var action = reader.Invoke(null, new object[0]);
var proxType = action.GetType();
var prox = methodContext.AddVariable(proxType, "proxy");
methodContext.Do(prox.Assign(action));
var invokeProx = proxType.GetMethod("Invoke");
methodContext.Do(ret.Assign(Expression.Call(prox, invokeProx, task)));
}
private ParameterExpression CustomConverter(MethodContext methodContext, IParameterConverter parameterConverter)
{
var param = methodContext.AddVariable(typeof(object), "dispArgs");
var dict = Expression.Variable(typeof(IDictionary <string, object>), "params");
var dictInit = new List <Expression>
{
dict.Assign(Expression.Constant(new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)))
};
foreach (var parameter in Parameters.Skip(1))
{
dictInit.Add(Expression.Call(dict, _dictAdd, Expression.Constant(parameter.Name), parameter));
}
dictInit.Add(Expression.Call(Expression.Constant(parameterConverter), StoredProcedureAttribute.Convert, dict));
methodContext.Do(param.Assign(Expression.Block(param.Type, new[] { dict }, dictInit)));
return(param);
}
private List <Expression> GetDispatcherAttributes(MethodContext methodContext, ParameterExpression param, MethodInfo disp)
{
var arguments = new List <Expression>
{
methodContext.ActionNameConstant,
param
};
if (disp == null ||
disp.GetParameters().LastOrDefault()?.ParameterType == typeof(CancellationToken))
{
if (CancellationToken == null)
{
arguments.Add(Expression.Constant(System.Threading.CancellationToken.None));
}
else
{
arguments.Add(CancellationToken);
}
}
return(arguments);
}
protected abstract MethodInfo GetReaderWrapper(MethodContext context);
/// <inheritdoc />
protected override MethodInfo GetReaderWrapper(MethodContext context)
{
return(_readerWrapperMethodInfo);
}
