We Keep Coding

Using reflection to find classes and invoke properly

I have an abstract class called Action which accepts a byte array and represents actions done by the client. I have several actions that are implemented from this class and they contain properties, like so:
[Action(ActionCode.Login)]
public class LoginAction : Action
{
public string Username { get; private set; }
public string Password { get; private set; }
public LoginAction(byte[] data)
: base(data)
{
this.Username = this.ReadMapleString();
this.Password = this.ReadMapleString();
}
}
I want to be able to defind a method using the actions like so:
public static void Login(LoginAction action)
So when I receive data from the client I can handle the actions based on the code received. However, I'm not sure how to use reflection to find the method that's associated with the action. I mean, I can find LoginAction using the code under, but I can't find the method that's using LoginAction as a parameter, which is the method I want to invoke.
I want to achieve something like:
public void OnRecieveData(ActionCode code, byte[] data)
{
// Using the ActionCode, call the specified action handler method.
// Login(new LoginAction(data));
}
I already know how to find classes that use the ActionCodeAttribute, but I'm not sure how to invoke it:
static IEnumerable<Type> GetTypesWithHelpAttribute(Assembly assembly) {
foreach(Type type in assembly.GetTypes()) {
if (type.GetCustomAttributes(typeof(HelpAttribute), true).Length > 0) {
yield return type;
}
}
}

Assuming there is a good reason for your design (see comments), you could find it with a bit of LINQ.
First, we need to find the type. We just get all types, filter their attributes by type (using OfType<>), and find the first class that has at least one ActionAttribute.
var type = System.Reflection.Assembly.GetCallingAssembly()
.GetTypes()
.Where
(
t => t.GetCustomAttributes()
.OfType<ActionAttribute>()
.Where( a => a.ActionCode == code)
.Any()
)
.Single();
Next to find the static member. We already know the type of the containing class. But we don't necessarily know the name. Tnen again, we do know the type of the first parameter, and that the call is static. Assuming there is always exactly one method that meets all of these criteria, we can use this:
var member = type
.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Where
(
m=> m.GetParameters()
.First()
.ParameterType == type
)
.Single();
Then we create the instance:
var instance = Activator.CreateInstance(type, new object[] { data });
And invoke it:
member.Invoke(null, new object[] { instance });
Full example:
static public void OnReceiveData(ActionCode code, byte[] data)
{
var type = System.Reflection.Assembly.GetCallingAssembly()
.GetTypes()
.Where
(
t => t.GetCustomAttributes()
.OfType<ActionAttribute>()
.Where( a => a.ActionCode == code)
.Any()
)
.Single();
var member = type
.GetMethods(BindingFlags.Static | BindingFlags.Public)
.Where
(
m=> m.GetParameters()
.First()
.ParameterType == type
)
.Single();
var instance = Activator.CreateInstance(type, new object[] { data });
member.Invoke(null, new object[] { instance });
}
Working example on DotNetFiddle

What you can do when you want to execute actions based on a code is to create a dictionary with action objects:
public abstract class Action {
public abstract void Execute(byte[] data);
}
//...
Dictionary<ActionCode, Action> actions = new Dictionary<ActionCode, Action>();
//...
void ExecuteAction(ActionCode actionCode, byte[] data) {
actions[actionCode].Execute(data);
}
You can populate the actions dictionary in an appropriate way that solves your problem. If you want to load the implementations from external libraries, you could do the following (using your existing GetTypesWithHelpAttribute method):
void PopulateActions(Assembly assembly) {
foreach(Type actionType in GetTypesWithHelpAttribute(assembly)) {
var codeQry =
from attribute in type.GetCustomAttributes().OfType<ActionAttribute>()
select attribute.Code;
ActionCode code = codeQry.Single();
Action action = (Action)Activator.CreateInstance(type);
actions.Add(code, action);
}
}
That assumes you apply the HelpAttribute to the actions you want to load. You can also directly look for the ActionAttribute and drop the HelpAttribute altogether.
This solution keeps the reflection code where it belongs: when you load the actions from an external source. Your execution code is free from reflection, which improves maintainability and performance. You can also combine the dynamic load with static actions you add without reflection from your main module.

If you're happy to define methods using the same name in the same class for each of the different type of actions:
void Handle(LoginAction action);
void Handle(FooAction action);
void Handle(BarAction action);
And you've constructed your ...Action object of the right type, you can call it using:
Handle((dynamic)action)
You can even afford the explicit case if you just do
dynamic dynAction = action;
Handle(dynAction);
And yes, the correct overload will be determined at runtime based on the type of the action.

Type inference for (ignoring) method parameters in order to select a MethodInfo

We are creating a configuration API for some of our internal projects. The API is replacing an attribute-based configuration. The new API involves specifying methods within a class along with the options that go with it.
public static class Configuration<T> {
public static void ForMethod(Expression<Action<T>> methodExpression, Options options) { //Option-1
MethodInfo method = GetMethod(methodExpression);
// do something with options
}
public static void ForMethod<TResult>(Expression<Func<T,TResult>> methodExpression, Options options) { //Option-2
MethodInfo method = GetMethod(methodExpression);
// do something with options
}
private static MethodInfo GetMethod(Expression expression) {
// there's other checks done, but this is what it boils down to
var methodCall = (MethodCallExpression) expression.Body;
return methodCall.Method;
}
}
class MyClass {
void MyMethod() { ... }
}
Configuration<MyClass>.ForMethod(x => x.MyMethod(), ... );
This is great except for when the methods themselves have parameters. IE
class MyClass2 {
void MyMethod2(int x) { }
int SomeOtherMethod(int x) { return x*x; }
}
These can be handled by expanding the configuration class like:
public static void ForMethod<TResult, TIn>(Expression<Func<T,TIn,TResult>> methodExpression, ...) { //Option-3
}
// and then called:
Configuation<MyClass2>.ForMethod<int,int>((x,y) => x.SomeOtherMethod(y), ...);
As more parameters get added it becomes a bit more clumsy. Technically we don't care about the parameters themselves, so long as we select the correct method. We could get around this by simply specifying everything as Option-1 (since we can also ignore the return type and specify everything as Actions) and just specifying the parameters using the default keyword, ie:
Configuration<MyClass2>.ForMethod(x => x.SomeOtherMethod(default(int)), ...)
However, this gets quite ugly.
Is there any way with type inference (or some other magic) to select the appropriate method without needing to explicitly state the parameter types? My hope would be something like this (although this do not work)
Configuration<MyClass2>.ForMethod((x,y) => x.SomeOtherMethod(y), ...) // Option 3 with return type and type of input inferred
or even
Configuration<MyClass2>.ForMethod((x,y) => x.SomeOtherMethod, ...) // Option 3 with return type and input 1 inferred + as method group
My gut tells me that this is not possible as I haven't been able to find any way around this online. My hope is that perhaps with a combination of extension methods and type inference this could be made possible, but I'm having difficulty finding anything that compiles. Is this even possible?

C# Type GetMethod() where parameter order is random

I am trying to get a method of an object, and it works fine if the parameters of the method match the order of the list of parameters I provide. I am trying to avoid this, so I do not have to worry about the order of parameter types in methods across different files. Here is what I have
MethodInfo mi = stateType.GetMethod("Entrance", typesToUse.ToArray());
In my test case, typesToUse only contains two instances of unique interfaces,
IClass1 and IClass2 in that order.
If the Entrance method is : Entrance(IClass1 c1, IClass2 c2), it picks this method up. Although, if its Entrance(IClass2 c2, IClass1 c1), it will not and mi will then be null.
Is there a way around this? Perhaps a way to tell GetMethod to ignore parameter order?
Any help is appreciated and thank you.

It is not sensible to implement a method that will ignore parameter order. Parameter order is critical to determining that you have found the correct method.
Consider this simple class:
public class A
{
public void Foo(int a, string b)
{
PrintAString();
}
public void Foo(string b, int a)
{
FormatHardDrive();
}
}
If you're method ignored the parameter order...bad things might happen!
Having said all that, it is possible of course. Simply get all the methods with a given name, eliminate all those that do not contain parameters for all the types in typesToUse, and then ensure you only have one.
The following code demonstrates this:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
public class Program
{
public static void Main()
{
var typesToUse = new Type[] { typeof(int), typeof(string) };
var methods = typeof(A).GetMethods().Where(m => m.Name == "Foo");
var matchingMethods = methods.Where(m => ContainsAllParameters(m, typesToUse));
Console.WriteLine(matchingMethods.Single());
}
private static bool ContainsAllParameters(MethodInfo method, Type[] typesToUse)
{
var methodTypes = method.GetParameters().Select(p => p.ParameterType).ToList();
foreach(var typeToUse in typesToUse)
{
if (methodTypes.Contains(typeToUse))
{
methodTypes.Remove(typeToUse);
}
else
{
return false;
}
}
return !methodTypes.Any();
}
}
public class A
{
public void Foo(string a, int b)
{
Console.WriteLine("Hello World");
}
}

You could create an overload of the method, that takes the parameters in different order.
The recommended solution would probably just be to make sure they always are passed in the correct order.
If you can't ensure this, you might solve the problem by creating an overload of the method, or by performing some checks as the first thing in the Entrance-method.

MongoDB, C#, Reflection, Dynamic Execution [duplicate]

Here's my class:
public class MyClass<T>
{
public void MyMethod(T a)
{
}
public void MyMethod(int a)
{
}
}
How would I Invoke MyMethod(T) using Reflection even if int is the generic type parameter for MyClass?
Here's a single statement that does it (Might be inefficient, but I like brevity):
var mc = new MyClass<int>();
typeof(MyClass<int>).GetMethods().ElementAt(
typeof(MyClass<int>).
GetGenericTypeDefinition().
GetMethods().ToList().FindIndex(m =>
m.Name.Equals("MyMethod") &&
m.GetParameters().Count() == 1 &&
m.GetParameters()[0].ParameterType.IsGenericParameter)
).Invoke(mc, new object[] { 1 });

Revised Answer
Okay, so I think I've figured out why the IsGenericParameter property evaluates as false is because you were creating the MyClass type with an explicit type for <T>.
Since the compiler new what type the a parameter was (inferring from the instantiation of the class), I'm guessing that the compiler was treating the parameter as a non-generic type.
Also, based upon what I was reading in MSDN, I think that the ParameterType.IsGenericParameter and Type.IsGenericType property would only evaluate to true
whenever you had a method like MyMethod<T>() vs. MyMethod(T a), where the type for <T> is inferred from the type instantiated with the class.
Here's a little program that demonstrates this:
using System;
using System.Linq;
using System.Reflection;
namespace GenericParametersViaReflectionTest
{
class Program
{
static void Main(string[] args)
{
// Note: we're using the type without specifying a type for <T>.
var classType = typeof(MyClass<>);
foreach (MethodInfo method in classType.GetMembers()
.Where(method => method.Name == "MyMethod"))
{
// Iterate through each parameter of the method
foreach (var param in method.GetParameters())
{
// For generic methods, the name will be "T" and the FullName
// will be null; you can use which ever check you prefer.
if (param.ParameterType.Name == "T"
|| param.ParameterType.FullName == null)
Console.WriteLine("We found our generic method!");
else
Console.WriteLine("We found the non-generic method:");
Console.WriteLine("Method Name: {0}", method.Name);
Console.WriteLine("Parameter Name: {0}", param.Name);
Console.WriteLine("Type: {0}", param.ParameterType.Name);
Console.WriteLine("Type Full Name: {0}",
param.ParameterType.FullName ?? "null");
Console.WriteLine("");
}
}
Console.Read();
}
}
public class MyClass<T>
{
public void MyMethod(T a) { }
public void MyMethod(int a) { }
}
}
And the results we end up with are:
We found or generic method!
Method Name: MyMethod
Parameter Name: a
Type: T
Type Full Name: null
We found the non-generic method:
Method Name: MyMethod
Parameter Name: a
Type: Int32
Type Full Name: System.Int32
If you need to create an instance of the class using a particular type, you might find the Activator.CreateInstance class useful too.
Original Answer
I think that if you pass in a parameter of the same datatype that matched one of the explictly set methods (e.g. the Int32 method), then the compiler would automatically select that over the one that accepts a generic parameter. Otherwise, the generic method would be selected by the compiler.
However, if you want to be able to control which method is selected, you could modify each method to have different parameter names, while maintaining identical signatures, like so:
public class MyClass<T>
{
public void MyMethod(T genericA) {}
public void MyMethod(int intA) {}
}
Then, using named parameters, you could explicitly call the desired method, like so:
var foo = new MyClass<int>();
foo.MyMethod(genericA: 24); // This will call the "MyMethod" that only accepts <T>.
foo.MyMethod(intA: 19); // This will call the "MyMethod" that only accepts integers.
Edit
For some reason, in my original answer I missed the part where you mentioned using reflection, but it looks my original answer could be coupled with these other answers to give you a viable solution:
Invoking methods with optional parameters through reflection
How can you get the names of method parameters?

The only way I was able to do this was to use GetGenericTypeDefinition with IsGenericParameter. In the generic type definition, one method will have IsGenericParameter set to true on the parameter. However, for closed types none of the parameters will have this as true. Then, you can't use the MethodInfo from the generic type definition to invoke the method, so I stored the index and used that to lookup the corresponding MethodInfo in the closed type.
public class Program
{
public static void Main(string[] args)
{
bool invokeGeneric = true;
MyClass<int> b = new MyClass<int>();
var type = b.GetType().GetGenericTypeDefinition();
int index = 0;
foreach(var mi in type.GetMethods().Where(mi => mi.Name == "MyMethod"))
{
if (mi.GetParameters()[0].ParameterType.IsGenericParameter == invokeGeneric)
{
break;
}
index++;
}
var method = b.GetType().GetMethods().Where(mi => mi.Name == "MyMethod").ElementAt(index);
method.Invoke(b, new object[] { 1 });
}
}
public class MyClass<T>
{
public void MyMethod(T a)
{
Console.WriteLine("In generic method");
}
public void MyMethod(int a)
{
Console.WriteLine("In non-generic method");
}
}

How do I determine if a method is a generic instance of a generic method

I have a MethodInfo passed in to a function and I want to do the following
MethodInfo containsMethod = typeof(ICollection<>).GetMethod("Contains");
if (methodInfo.Equals(containsMethod)
{
// do something
}
But this doesn't work because the methodInfo has a specific generic type. For the example does work if I knew that the ICollection was always of type string.
MethodInfo containsMethod = typeof(ICollection<string>).GetMethod("Contains");
if (methodInfo.Equals(containsMethod)
{
// do something
}
How can I check whether the MethodInfo is a ANY typed instance of the generic method without caring what the type is?
Thanks.
EDIT: Question clarification
As correctly pointed out the method is not generic but the containing class is so the question is more how to I find out if the MethodInfo is for a Type which is a typed instance of ICollection<>.
EDIT: more context
I am writing a Linq provider and trying to handle the "in" case
IList<string> myList = new List<string>{ "1", "2" };
from Something s in ...
where myList.Contains(s.name)
select s;

Note that ICollection<T>.Contains is not a generic method - it is a non-generic method of a generic type. Otherwise IsGenericMethod and GetGenericTypeDefinition would help. You could obtain the generic type definition (DeclaringType.GetGenericTypeDefinition()) and work back up to Contains, but I wonder if you are approaching this problem the hard way.
Usually, if you are using reflection, it may be pragmatic to drop to non-generic IList - unless you need the type data (for example, for meta-programming). And in that case, I would consider looking closely to see if you can simplify the setup here.

You could check the declaring type:
if( methodInfo.Name == "Contains"
&& methodInfo.DeclaringType.IsGenericType
&& methodInfo.DeclaringType.GetGenericTypeDefinition() == typeof(ICollection<>))
{

Some error checking would need to be added to this, but I believe this roughly does what you want. You can use a method with or without a type argument as the parameter.
static bool IsContainsMethod(MethodInfo methodInfo)
{
Type[] types = { methodInfo.GetParameters().First().ParameterType };
MethodInfo containsMethod = typeof(ICollection<>).MakeGenericType(types).GetMethod("Contains");
return methodInfo.Equals(containsMethod);
}

The problem is that you don't have a generic method: you have a non-generic method on a generic type. I don't know of a way to use reflection to go directly from a method definition on an open generic type to that same method on a closed generic type or vice versa. However, you can take advantage of the fact that the methods returned by GetMethods() on the open and closed generic types should always be in the same order and do the translation by index:
MethodInfo containsMethod = typeof(ICollection<>).GetMethod("Contains");
var methodIndex = Array.IndexOf(methodInfo.DeclaringType.GetMethods(), methodInfo);
var methodOnTypeDefinition = methodInfo.DeclaringType.GetGenericTypeDefinition().GetMethods()[methodIndex];
if (methodOnTypeDefinition.Equals(containsMethod))
{
// do something
}

try this method
public static bool CheckGenericMethod(MethodInfo methodInfo)
{
bool areSimilarMethods = false;
MethodInfo methodToCompare = typeof(ISomeInterface<>).GetMethod("func");
Type interfaceInfo = methodInfo.DeclaringType.GetInterface(methodToCompare.DeclaringType.FullName);
if (interfaceInfo != null)
areSimilarMethods = (methodToCompare.Name.Equals(methodInfo.Name)
&& interfaceInfo.FullName.Contains(methodToCompare.DeclaringType.FullName));
else
{
areSimilarMethods = methodToCompare.DeclaringType.Equals(methodInfo.DeclaringType);
}
return areSimilarMethods;
}
and here is the full example usage.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
namespace TestReflection
{
public class Program
{
static void Main(string[] args)
{
MethodInfo info1 = typeof(ISomeInterface<>).GetMethod("func");
MethodInfo info2 = typeof(MyStringCollection).GetMethod("func");
MethodInfo info3 = typeof(MyProgramCollection).GetMethod("func");
MethodInfo info4 = typeof(MyXCollection).GetMethod("func");
if (CheckGenericMethod(info1)) Console.WriteLine("true");else Console.WriteLine("false");
if (CheckGenericMethod(info2)) Console.WriteLine("true");else Console.WriteLine("false");
if (CheckGenericMethod(info3)) Console.WriteLine("true");else Console.WriteLine("false");
if (CheckGenericMethod(info4)) Console.WriteLine("true"); else Console.WriteLine("false");
Console.ReadKey();
}
public static bool CheckGenericMethod(MethodInfo methodInfo)
{
bool areSimilarMethods = false;
MethodInfo methodToCompare = typeof(ISomeInterface<>).GetMethod("func");
Type interfaceInfo = methodInfo.DeclaringType.GetInterface(methodToCompare.DeclaringType.FullName);
if (interfaceInfo != null)
areSimilarMethods = (methodToCompare.Name.Equals(methodInfo.Name)
&& interfaceInfo.FullName.Contains(methodToCompare.DeclaringType.FullName));
else
{
areSimilarMethods = methodToCompare.DeclaringType.Equals(methodInfo.DeclaringType);
}
return areSimilarMethods;
}
}
public interface ISomeInterface<T> where T : class
{
T func(T s);
}
public class MyStringCollection : ISomeInterface<string>
{
public string func(string s)
{
return s;
}
}
public class MyProgramCollection : ISomeInterface<Program>
{
public Program func(Program s)
{
return s;
}
}
public class MyXCollection
{
public int func(int s)
{
return s;
}
}
}