CODEWITHSUNDEEP
c#oop
Anonymous
Anonymous

Reputation: 1979

What is the purpose of a restricting the type of generic in a method?

I'm having a hard time understanding why it would be beneficial to do something like this: (Sample is a class)

static void PrintResults<T>(T result) where T : Sample

Wouldn't it be better to to just pass Sample into the method?

 static void PrintResults (Sample result)

Upvotes: 15

Views: 343

Answers (3)

akton
akton

Reputation: 14376

I recommend avoiding generic types where non-generic syntax works, such as the example you gave. However, there are other useful cases.

For example, specifying the return type generically:

static T Create<T>() where T: Sample, new()
{
    return new T();
}

// Calling code
Sample sample = Create<Sample>();

instead of

static object Create()
{
    return new Sample();
}

// Calling code
Sample sample = (Sample) Create();

You can also use templates to place multiple restrictions on a type. For example:

static T Create<T>() where T: IMyInterface, new()
{
    return new T();
}

interface IMyInterface {} 
class MyClass : IMyInterface { }

// Calling code.
MyClass myClass = Create<MyClass>();

This allows the generic creation of a new type that implements a specific interface and has a generic constructor. Also:

static void DoSomething<T>(T t) where T: IMyInterface1, IMyInterface2
{
    t.MethodOnIMyInterface1();
    t.MethodOnIMyInterface2();
}

interface IMyInterface1 
{
    void MethodOnIMyInterface1();
}     
interface IMyInterface2
{
    void MethodOnIMyInterface2();
}     
class MyClass: IMyInterface1, IMyInterface2 
{ 
    // Method implementations omitted for clarity
}

// Calling code
MyClass myclass'
DoSomething(myclass);  // Note that the compiler infers the type of T.

Where you can require multiple interfaces on a single parameter without (1) creating a new type that implements all these interfaces and (2) requiring parameters to be of that type.

As @dcastro points out in his/her answer, generic types can also tell the compiler to require types are the same. For example:

static void DoSomething<T>(T t1, T t2) where T: MyType
{
    // ...
}

class MyType {}
class MyType1: MyType {} 
class MyType2: MyType {} 

// Calling code
MyType1 myType1;
MyType2 myType2;
DoSomething<MyType>(myType1, myType2);

Where the compiler requires that t1 and t2 are the same type but can be any type that inherits MyType. This is useful in automated unit testing frameworks, such as NUnit or MSTest, for generic equality and comparison checks.

Upvotes: 10

Brandon
Brandon

Reputation: 39182

Most of the answers are offering explanations of the usefulness of generics involving interfaces that don't really seem to address your actual question.

Truth is, for the example you posted, there is no benefit to using a generic method. It is actually worse because it will cause multiple implementations of the same function to be generated and ever slightly increase the code size at runtime.

Upvotes: 3

CSharpie
CSharpie

Reputation: 9467

In voids you could allways use an interface as a parameter to make multiple types work, so generics arent often useful here.

Only exceptions are the constraints on generics. And by that i dont mean something like where T: IA, IB since this could be done by an interface aswell that both implements IA and IB. This will get tiresome at some point however since you will need more and more interfaces. So lets look ath the "special constraints" class and new

public void AddNew(List<T> items) where T : new
{
    items.Add(new T());
}

and class which is useful if the method mutates its parameter, which wont work for structs

static void IncA<T>(T item) where T: class, IA
{
    item.A++;
}

The real power of generics is when methods have a generic return type or generic classes like List <T>. You dont want to implement a new class for every List you will need.

Upvotes: 2

Related Questions