public void Should_invoke_method_faster_than_reflection()
{
var iterations = 10000;
var type = new TypeCache().GetTypeDescriptor(typeof(InvokerMethods));
var method = type.Methods.FirstOrDefault(x =>
x.Name == nameof(InvokerMethods.MethodWithReturnAndParameters));
var invoke = method.GenerateAsyncInvoker(type);
var instance = new InvokerMethods();
var parameters = new object[] { "param1", "param2" };
var nativeElapsed = new List <long>();
var reflectionElapsed = new List <long>();
var expressionElapsed = new List <long>();
iterations.Times(() =>
{
expressionElapsed.Add(instance.ElapsedTicks(x => invoke(x, parameters)));
reflectionElapsed.Add(method.ElapsedTicks(x => x.MethodInfo.Invoke(instance, parameters)));
nativeElapsed.Add(instance.ElapsedTicks(x => x.MethodWithReturnAndParameters(
(string)parameters[0], (string)parameters[1])));
});
Console.WriteLine($"Native: {nativeElapsed.Average()}");
Console.WriteLine($"Compiled expression: {expressionElapsed.Average()}");
Console.WriteLine($"Reflection: {reflectionElapsed.Average()}");
}
public async Task Should_throw_informative_message_when_argument_cannot_be_cast_to_parameter_type()
{
var type = new TypeCache().GetTypeDescriptor(typeof(InvokerMethods));
var method = type.Methods.FirstOrDefault(x =>
x.MethodInfo.Name == nameof(InvokerMethods.MethodWithNonNullableParameter));
var invoker = method.GenerateAsyncInvoker(type);
var instance = new InvokerMethods();
var message = invoker.Should().Throw <ParameterInvalidCastException>(
async x => await invoker(instance, new object[] { "fark" })).Result.Message;
message.ShouldContain("param");
message.ShouldContain("String");
message.ShouldContain("Int32");
}
public async Task Should_invoke_method(LambdaExpression expression,
object[] parameters, object response)
{
var type = new TypeCache().GetTypeDescriptor(typeof(InvokerMethods));
var method = type.Methods.FirstOrDefault(x =>
x.MethodInfo == expression.GetMethodInfo());
var invoker = method.GenerateAsyncInvoker(type);
var instance = new InvokerMethods();
var result = await invoker(instance, parameters);
instance.CalledMethod.ShouldEqual(method.Name);
if (parameters != null)
{
instance.Params.ShouldOnlyContain(parameters);
}
result.ShouldEqual(response);
}
public void Should_invoke_method_faster_than_reflection()
{
var type = new TypeCache().GetTypeDescriptor(typeof(InvokerMethods));
var method = type.Methods.First(x => x.Name == nameof(InvokerMethods.MethodWithReturnAndParameters));
var invoke = method.GenerateAsyncInvoker(type);
var instance = new InvokerMethods();
var parameters = new object[] { "param1", "param2" };
var comparison = PerformanceComparison.InTicks(10000, 1000);
comparison.AddCase("Native", () => instance
.MethodWithReturnAndParameters((string)parameters[0], (string)parameters[1]));
var compiledCase = comparison.AddCase("Compiled expression", () => invoke(instance, parameters));
var reflectionCase = comparison.AddCase("Reflection", () => method.MethodInfo.Invoke(instance, parameters));
comparison.Run();
compiledCase.Average.ShouldBeLessThan(reflectionCase.Average);
}
