CODEWITHSUNDEEP
c#.netgenerics
AK_
AK_

Reputation: 8099

C# simpler run time generics

Is there a way to invoke a generic function with a type known only at run time?

I'm trying to do something like: 

    static  void bar()
    {
        object b = 6;
        string c = foo<typeof(b)>();
    }

    static  string foo<T>()
    {
       return typeof (T).Name;
    }

Basically I want to decide on the type parameter only at run time, but the function I'm calling depends on the type parameter.

Also I know this can be done with reflections... but it's not the nicest solution to the problem...

I'm sort of looking for dynamic features in C#...

I'm writhing a bridge between two classes the first one is basically a big tree with different types of of objects (composite by interface) the other is a sort of a "super visitor". the supper visitor accepts key-value dictioneries that map types to object it looks like: dic.Add(object value)

and T is not necessarily the type of the value... a lot of times it isn't... I know it's written poorly, but i can't fix it... I can work around it, but only at runtime...

I already did it with reflections, but if there's a better way to do it without them i would be happy to learn...

Thank you

Upvotes: 2

Views: 140

Answers (5)

JiB&#233;Doublev&#233;
JiB&#233;Doublev&#233;

Reputation: 4269

You can use dynamic keyword if you're using .NET 4. In a word, the type of the variable will be resolved at run time so it is a super generic type ;) You can read a article here or read the MSDN documentation

Upvotes: 1

chuckj
chuckj

Reputation: 29545

This is a bit of a hack but you can get dynamic to do the reflection work for you by something like,

class Program
{
    static void Main(string[] args)
    {
        var b = 6;
        var t = (dynamic)new T();
        var n = t.Foo(b);
    }

    class T
    {
        public string Foo<T>(T a)
        {
            return typeof(T).Name;
        }
    }
}

Here the dynamic call will extract the type of b and use it as a type parameter for Foo().

Upvotes: 1

Chris
Chris

Reputation: 3162

You can set up a class which takes a type parameter at run time which can be used in the methods in that class.

public class GenericClass<T>()
{
    ICommonInterface TheObject;

    public GenericClass(T theObject)
    {
         TheObject = theObject;
    }


    public string GetName()
    {
        return TheObject.Name;
    }
}

But this is only really useful if the Types being passed in share interfaces so have common properties between them. In your example it seems that relection is the answer as depending on the type you want to access specific properties.

Upvotes: 0

Myles McDonnell
Myles McDonnell

Reputation: 13335

This I believe is the only way:

 var foo =  typeof(Foo<>).MakeGenericType(typeof (bar));

Upvotes: 0

TomTom
TomTom

Reputation: 62101

Saly refelction is THE solution to the problem, whether it is nice or not is irrelevant here. It is the runtime designed mechanism to achieve exactly this. As there is no parameter or generics to use as input, this is the only way to do it - it is also senseless. As in: your example is bad. Because in the example the type is hardcoded.

If the method where b exists has b as generic parameter, the type is available for passing to foo. If not - reflection is THE way to go, albeit the syntax looks clumsy. Only one time, though.

Upvotes: 0

Related Questions