private bool HasOneParameterNeeded(ParameterInfo[] parameters, TypeInfo eventArgsType)
{
return parameters.Any() &&
parameters.ElementAt(0).ParameterType.GetTypeInfo().IsAssignableFrom(eventArgsType);
}
private static bool IsValidCommandHandler(Type commandType, MethodInfo method, ParameterInfo[] parameters, MethodParameterInjector injector)
{
if (method.DeclaringType != null && method.DeclaringType.GetProperties().Any(p => IsPropertyAccessor(method, p)))
return false;
return parameters.Any(p => p.ParameterType == commandType)
&& parameters.All(p => p.ParameterType == commandType || injector.CanSupply(p.ParameterType));
}
/// <summary>
/// Check if unwrap args is needed. If false, UnwrapArgs/WrapResult become NOP.
/// The default implementation returns true if there is any [out] params.
/// </summary>
/// <param name="parameterInfos">All the parameterinfo.</param>
/// <returns>true if UnwrapArgs/WrapResult should be performed.</returns>
protected virtual bool IsUnwrapArgsNeeded(ParameterInfo[] parameterInfos)
{
return parameterInfos.Any(p => p.IsOut);
}
private static string BuildParameterPath(ParameterInfo[] parameters)
{
if(!parameters.Any()) return String.Empty;
var parameterPath = Path.Combine(parameters.Select(p => $"{{{p.Name}}}").ToArray());
return $"/{parameterPath}";
}
public static void SetEmptyCollectionOnMethodSelect(ParameterInfo[] parameters, ObservableCollection<ControlView> controlViewBindingObject, string guid)
{
if (parameters.Any())
{
foreach (ParameterInfo mParameter in parameters)
{
int parameterOrder = mParameter.Position;
//mParameter.ParameterType
GetParameter(controlViewBindingObject, mParameter, parameterOrder, guid);
}
}
}
public static void SetCollectionOnValue(Value selectedValueObj, ParameterInfo[] parameters, ObservableCollection<ControlView> controlViewBindingObject, string guid)
{
if (parameters.Any())
{
foreach (ParameterInfo mParameter in parameters)
{
int parameterOrder = mParameter.Position;
var paramValue = (from p in selectedValueObj.Param
where p.Order == parameterOrder
select p).First();
GetParameter(controlViewBindingObject, mParameter, parameterOrder, guid, paramValue);
}
}
}
private void EmitMethodWithParameterCombo(int thissIdx, MethodInfo realMethod, Type[] parameters, MethodBuilder methodBuilder, ParameterInfo[] realParams)
{
var gen = methodBuilder.GetILGenerator();
if (!realMethod.IsStatic)
{
// Set 'this' to the result of JishProxy.GetInstance. This allows one
// class to proxy to methods from different source classes.
SetReferenceToAppropriateThis(gen, thissIdx);
}
for (int i = 0; i < parameters.Length; i++)
{
if (IsParamsArray(realParams[i]))
{
break; // Break as this is the last parameter (params must always be last)
}
// if (IsParamDelegate(realParams[i])) // TODO: This is in the wrong place
// {
// If the param is a delegate it needs to be replaced with a string which
// will be used to find the 'real' delegate in the jish_internal scope.
// }
// Else add standard inline arg
gen.Emit(OpCodes.Ldarg, i + 1);
}
for (int i = parameters.Count(); i < realParams.Length; i++)
{
if (IsParamsArray(realParams[i])) break;
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldc_I4, thissIdx); // Load the this index into the stack for GetInstance param
gen.Emit(OpCodes.Ldc_I4, i);
MethodInfo getLastOptional = typeof (JishProxy).GetMethod("GetOptionalParameterDefaultValue");
getLastOptional = getLastOptional.MakeGenericMethod(new[] {realParams[i].ParameterType});
gen.Emit(OpCodes.Callvirt, getLastOptional);
}
ParameterInfo last = realParams.Any() ? realParams.Last() : null;
if (last != null && IsParamsArray(last))
{
CovertRemainingParametersToArray(parameters, gen, realParams.Count() - 1, last.ParameterType.GetElementType());
}
// Call the real method
gen.Emit(realMethod.IsStatic ? OpCodes.Call : OpCodes.Callvirt, realMethod);
gen.Emit(OpCodes.Ret);
}