public T GetMyClass() where T : MyClass, new() { /* is this pointless? */ }

Question

are the two methods in the class "Confused" below the same?

class MyClass
{
    public override string ToString()
    {
        return "I am confused now";
    }
}

class Confused
{    
    public MyClass GetMyClass()
    {
        return new MyClass();
    }

    public T GetMyClass<T>() where T : MyClass, new()
    {
        return System.Activator.CreateInstance<T>();
    }
}

class Program
{
    static void Main()
    {
        Confused c = new Confused();
        System.Console.WriteLine(c.GetMyClass());
        System.Console.WriteLine(c.GetMyClass<MyClass>());
    }
}

They produce different IL, but is there any reason to write the generic version other than the 'straight up' version other than to confuse the heck out of collegues :)

Adam Houldsworth · Answer 1 · 2011-07-14T14:46:52.207

4

If you write the generic version, you can instantiate and return derived classes:

where T : MyClass

Also, with the generic version you don't need the activation code:

return new T();

This is because you have specified:

where T : new()

The generic constraint enforcing a public parameterless constructor.

edited Jul 14 '11 at 14:46

answered Jul 14 '11 at 14:28

Adam Houldsworth

63,413
11
150
187

score 2 · Accepted Answer · answered Jul 14 '11 at 14:29

2

Sure there's a difference. Let's say you have a second class deriving from MyClass:

class MyClass2 : MyClass { }

Then you can do

MyClass2 myClass2 = confused.GetMyClass<MyClass2>();

You can't do that with the other function.

answered Jul 14 '11 at 14:29

Heinzi

167,459
57
363
519

score 1 · Answer 3 · answered Jul 14 '11 at 14:28

MyClass could be a base class (or an interface IMyClass). The generic version with the constraint says you want this function to work for any class derived from (or implementing) a common base or interface and to return the result as that derived class, not as the base.

class MyClass { }
class MySpecializedClass : MyClass { } 
// etc.

score 1 · Answer 4 · answered Jul 14 '11 at 14:28

1

There is a very big difference:
The non generic version can only return instances of type MyClass, whereas the generic version can return instances of type MyClass and all classes derived from MyClass!

answered Jul 14 '11 at 14:28

Daniel Hilgarth

171,043
40
335
443

score 0 · Answer 5 · answered Jul 14 '11 at 14:28

0

No. They are not the same. The first will only ever construct a MyClass object, and the second will construct any object that is a MyClass or a descendent of MyClass, based on the type parameter.

answered Jul 14 '11 at 14:28

FishBasketGordo

22,904
4
58
91

score 0 · Answer 6 · answered Jul 14 '11 at 14:30

They would give the same result ONLY if you called .GetMyClass<MyClass>(). However, I presume the extra method has been created to allow for creation of other classes? If not, then they're the same, so one's redundant (and I'd get rid of the generic version as has overhead inside the assembly).

Are they being used differently?

score 0 · Answer 7 · answered Jul 14 '11 at 14:38

They are not the same. The generic allows inherited classes to be built as well like this:

class MyClass
{
    public override string ToString()
    {
        return "I am confused now";
    }
}

class InheritedClass : MyClass
{
}

class Confused
{
    public MyClass GetMyClass()
    {
        return new MyClass();
    }

    public T GetMyClass<T>() where T : MyClass, new()
    {
        return System.Activator.CreateInstance<T>();
    }
}

class Program
{
    static void Main()
    {
        Confused c = new Confused();
        System.Console.WriteLine(c.GetMyClass());
        System.Console.WriteLine(c.GetMyClass<MyClass>());
        System.Console.WriteLine(c.GetMyClass<InheritedClass>());
    }
}

score -1 · Answer 8 · answered Jul 14 '11 at 14:28

-1

I'm not quite sure, but Generics are a runtime feature in .NET. Therefore, the non-generic method isn't equivalent to the generic one, even though it is used equivalently. As they're public, this can't be optimized away.

answered Jul 14 '11 at 14:28

Matthias Meid

12,455
7
45
79

As far as I know, they aren't (in .NET). See also http://stackoverflow.com/questions/6127855/why-is-this-generic-not-resolved-at-compile-time/6128454#6128454... – Matthias Meid Jul 14 '11 at 14:37

public T GetMyClass() where T : MyClass, new() { /* is this pointless? */ }

8 Answers8