Type manipulation

Question

Is it possible to create a method which returns a type and use it?

for example, assume I have a Person type and Object parameter. As you probably know, If we want to cast our Object parameter, we can write:

object param;

((Person)param).executePersonMethod();

My question is how can I write a method which return Person type and use it instead the concrete Person cast - I want write something like this:

public Type GetPersonType()
{
//return here type of person
}

and then use

  ((GetPersonType())param).executePersonMethod();

Is it possible? If yes, how?

You may want to look at [Generics](http://msdn.microsoft.com/en-us/library/512aeb7t.aspx). — Cristian Lupascu, Sep 19 '13 at 07:30

score 4 · Answer 1 · answered Sep 19 '13 at 07:34

4

You can use interface.

((IPerson)param).executePersonMethod();

each type of person must be an IPerson and in IPerson you declare executePersonMethod()

answered Sep 19 '13 at 07:34

Pascalz

2,348
1
24
25

Hi, I know this approach - it not good for my scenario, I need more dynamic solution. I don`t want create seperate Interface for any type – Ofir Sep 19 '13 at 07:38

score 2 · Answer 2 · answered Sep 19 '13 at 07:41

You can also use dynamic for this.

Note that using dynamic will skip any compile time checking whether that method exists and will throw an exception at runtime if it doesn't.

Due to this risk, I would only do this if I have no other choice, but it's good to know that the option exists:

dynamic d = param;
d.executeWhateverMethodHereWithoutCompileTimeChecking();

score 2 · Answer 3 · answered Sep 19 '13 at 07:41

Yes you can. There is a new type called dynamic which will avoid static type check during compilation.

public dynamic GetPersonOrObjectWhichHasExecutePersonMethod()
{
 //return not the type but the object itself
 return new Person(); 
}

public class Person
{
    public void executePersonMethod()
    {
      // do something
    }
}

// this is how you invoke it
public void ExecuteMethod()
{
  dynamic obj = GetPersonOrObjectWhichHasExecutePersonMethod();
  obj.executePersonMethod();
}

score 1 · Answer 4 · answered Sep 19 '13 at 07:37

1

Maybe you can use something like that:

Convert.ChangeType(param, typeof(Person));

It would returns param as a Person.

answered Sep 19 '13 at 07:37

Ricardo Rodriguez

1,010
11
22

score 0 · Answer 5 · answered Sep 19 '13 at 07:38

0

Use

TypeOf()

Example :

        if (data.GetType() == typeof(Personne))
            return (Personne)data;
        else
            return new Personne();

After, check your object is not null to know if it's ok

answered Sep 19 '13 at 07:38

CheapD AKA Ju

713
2
7
21

score 0 · Answer 6 · answered Sep 19 '13 at 07:42

Although you can use Generic as a better option, however it is possible using Type Convertor in combination with reflection:

Type type = GetPersonType();
var converted = Convert.ChangeType(param, type);
converted
     .GetType()
     .GetMethod(/*your desired method name in accordance with appropriate bindings */)
     .Invoke(converted, /* your parameters go here */);

score 0 · Accepted Answer · edited May 23 '17 at 12:02

You cannot execute methods on a Type, you can only execute methods on an instance of a particular Type. If I am understanding correctly, you should be able to use the answer @LavG gives to: