CODEWITHSUNDEEP
c#syntax
Makach
Makach

Reputation: 7569

In c# what does 'where T : class' mean?

In C# what does where T : class mean?

Ie. 

public IList<T> DoThis<T>() where T : class

Upvotes: 176

Views: 187441

Answers (12)

Soner from The Ottoman Empire
Soner from The Ottoman Empire

Reputation: 20901

where T : base-class   // Base-class constraint
where T : interface    // Interface constraint
where T : class        // Reference-type constraint
where T : class?       // (See "Nullable Reference Types" in Chapter 4)
where T : struct       // Value-type constraint (excludes Nullable types)
where T : unmanaged    // Unmanaged constraint
where T : new()        // Parameterless constructor constraint
where U : T            // Naked type constraint
where T : notnull      // Non-nullable value type, or (from C# 8)
                       // a non-nullable reference type

Excerpt From C# 12 in a Nutshell Joseph Albahari

Upvotes: 1

Muhammad Hanif Shahzad
Muhammad Hanif Shahzad

Reputation: 65

public class MyGenericClass<T> where T : SomeType
{
    // Class implementation
}

Type Constraints: You can apply various constraints to type parameters, such as:

Class constraint (where T : class): This ensures that the type argument must be a reference type (a class or interface).

Struct constraint (where T : struct): This ensures that the type argument must be a value type (a struct).

Constructor constraint (where T : new()): This ensures that the type argument must have a parameterless constructor.

Interface constraint (where T : IMyInterface): This ensures that the type argument must implement a specific interface.

Base class constraint (where T : MyBaseClass): This ensures that the type argument must inherit from a specific base class.

Upvotes: 0

Donut
Donut

Reputation: 112835

It's a type constraint on T, specifying that it must be a class.

The where clause can be used to specify other type constraints, e.g.:

where T : struct // T must be a struct
where T : new()  // T must have a default parameterless constructor
where T : IComparable // T must implement the IComparable interface

For more information, check out Microsoft's page generic parameter constraints.

Upvotes: 64

Hemant Kumar
Hemant Kumar

Reputation: 4611

Here T refers to a Class.It can be a reference type.

Upvotes: 3

Andy Rose
Andy Rose

Reputation: 16984

Simply put this is constraining the generic parameter to a class (or more specifically a reference type which could be a class, interface, delegate, or array type).

See this MSDN article for further details.

Upvotes: 143

explorer
explorer

Reputation: 12090

where T: class literally means that T has to be a class. It can be any reference type. Now whenever any code calls your DoThis<T>() method it must provide a class to replace T. For example if I were to call your DoThis<T>() method then I will have to call it like following:

DoThis<MyClass>();

If your metthod is like like the following:

public IList<T> DoThis<T>() where T : class
{
   T variablename = new T();

   // other uses of T as a type

}

Then where ever T appears in your method, it will be replaced by MyClass. So the final method that the compiler calls , will look like the following:

public IList<MyClass> DoThis<MyClass>() 
{
   MyClass variablename= new MyClass();

  //other uses of MyClass as a type

  // all occurences of T will similarly be replace by MyClass
 }

Upvotes: 11

AsifQadri
AsifQadri

Reputation: 2389

T represents an object type of, it implies that you can give any type of. IList : if IList s=new IList; Now s.add("Always accept string.").

Upvotes: 4

Oded
Oded

Reputation: 499132

It is a generic type constraint. In this case it means that the generic type T has to be a reference type (class, interface, delegate, or array type).

Upvotes: 45

Carlos
Carlos

Reputation: 2513

It is called a type parameter constraint. Effectively it constraints what type T can be.

The type argument must be a reference type; this applies also to any class, interface, delegate, or array type.

Constraints on Type Parameters (C# Programming Guide)

Upvotes: 4

Vilx-
Vilx-

Reputation: 106970

That restricts T to reference types. You won't be able to put value types (structs and primitive types except string) there.

Upvotes: 19

Isak Savo
Isak Savo

Reputation: 35904

it means that the type used as T when the generic method is used must be a class - i.e. it cannot be a struct or built in number like int or double

// Valid:
var myStringList = DoThis<string>();
// Invalid - compile error
var myIntList = DoThis<int>();

Upvotes: 9

Randy Minder
Randy Minder

Reputation: 48482

'T' represents a generic type. It means it can accept any type of class. The following article might help:

http://www.15seconds.com/issue/031024.htm

Upvotes: 1

Related Questions