CODEWITHSUNDEEP
c#generics
ilay zeidman
ilay zeidman

Reputation: 2814

C# make generic method that knows how to call function on "some" class

is it possible to make generic function in c# that get as input some class and method (of the class) and parameters to the method ( and maybe the result type ) and make instance of that class and call to the function of the class with the parameters and return the result?

Upvotes: 0

Views: 1397

Answers (4)

Ian P
Ian P

Reputation: 12993

Here's how you create an instance of a class using reflection and then call a method on that class.

Assuming you have a class:

public class MyType
{
    public void DoSomething()
    {
        // do stuff here
    }
}

You could do the following:

Type instanceType = Type.GetType("MyType");
object instance = Activator.CreateInstance(instanceType);

MethodInfo method = instanceType.GetMethod("MethodName");
object returnValue = method.Invoke(instance, new object[] { /* paramaters go here */ });

Upvotes: 1

ken2k
ken2k

Reputation: 49013

Sure.

public class MyClass
{
    public class Test
    {
        public int TestMethod(int a, int b)
        {
            return a + b;
        }
    }

    public static void Main()
    {
        int result = ExecuteMethod<Test, int>("TestMethod", 1, 2);
        Console.Read();
    }

    public static TResult ExecuteMethod<TClass, TResult>(string methodName, params object[] parameters)
    {
        // Instantiate the class (requires a default parameterless constructor for the TClass type)
        var instance = Activator.CreateInstance<TClass>();

        // Gets method to execute
        var method = typeof(TClass).GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);

        // Executes and returns result
        return (TResult)method.Invoke(instance, parameters);
    }
}

Upvotes: 4

Mario J Vargas
Mario J Vargas

Reputation: 1195

Unless Reflection is your absolute option, use one of the following delegates:

  • Action<T>: Will let you execute a method that does not return a value. There are several overloads that will let you pass in additional arguments.

  • Func<TResult>: Will let you execute a method that returns a result of type TResult. There are more overloads that will let you pass in additional arguments. They all follow the syntax Func<T1, T2, T3, TResult> and so on.

  • And finally, you can define your own delegate.

Upvotes: 2

vfabre
vfabre

Reputation: 1408

Yes it's possible. You can do that with reflection.

Here you have a few useful links

Create an instance with reflection

How to invoke method with parameters

Upvotes: 1

Related Questions