Cast generic type parameter to a specific type in C#

Question

If you need to cast a generic type parameter to a specific type we can cast it to a object and do the casting like below,

void SomeMethod(T t)
{
    SomeClas         


        

Answer 1

A better design is to put a constraint on it that is common between type T and the class you want to expect in your method, in this case SomeClass.

class SomeConsumer<T> where T : ISomeClass
{
    void SomeMethod(T t)
    {
        ISomeClass obj2 = (ISomeClass) t;
    }
}

interface ISomeClass{}

class SomeClass : ISomeClass {}

---

Edit based on edit of Question

That is bad design. Try to move that "operation" into the class itself so the caller does not have to know the type. If that is not possible share more of what is being done, what you want to accomplish though is that you do not have a stack of if/else statements where execution depends on the type of object being passed in to the method.

class SomeConsumer<T> where T : ISomeClass
{
    void SomeMethod(T t)
    {
        ISomeClass obj2 = (ISomeClass) t;
        // execute
        t.Operation();
    }
}

interface ISomeClass{
    void Operation();
}

class SomeClass : ISomeClass {
    public void Operation(){/*execute operation*/}
}

Answer 2

I know this is a late question but here what you can do

A great option is to make your function accept parameter of class object, and do your switch case as you wish

And just do the casting

YourClass = (YourClass) parameterObject;

Answer 3

If there is no relation between the input type T and the target types TypeA or TypeB (using parameter contraints), and we are looking purely at the casting-problem, the answer is simple:

No, there is no better way than the method you are using!!!

I do agree with some other people, if you are doing more operations on that object, you might wanna choose a different design.

Answer 4

Using as:

SomeClass obj2 = t as SomeClass;

This would not throw an exception and t would be null if the cast fails.

I don't really know what you're trying to do, but I hope that you're not missing the point of Generics here.

If your intention is to restrict the method to type SomeClass and descendants:

void SomeMethod(T t)  where T : SomeClass

Answer 5

You can use Convert.ChangeType

SomeClass obj2 = (SomeClass)Convert.ChangeType(t, typeof(SomeClass));

Although, keep in mind that this will throw an exception if a cast is invalid.

Answer 6

You can use as for that case

void SomeMethod(T t)
{
    SomeClass obj2 = t as SomeClass;
}