In C# What Does 'Where T:Class' Mean

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

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.

What does this mean: ClassNameT where T : class

We are restricting it to consumable via a class as generic parameter and not to be used with struct (Value Types).

if we don't apply the constraint of the class on T, it would be usable with struct too and here the author has limited this generic class to usable on with T parameter with a reference type i.e. class as type parameter.

For more details, please refer to the MSDN docs on Type Constraint.

What does where T : class, new() mean?

That is a constraint on the generic parameter T. It must be a class (reference type) and must have a public parameter-less default constructor.

That means T can't be an int, float, double, DateTime or any other struct (value type).

It could be a string, or any other custom reference type, as long as it has a default or parameter-less constructor.

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

? attached to a type in C# (supported from version 8) means it is a nullable reference type. class? means that the calling code has to pass in a type parameter which is a class, and may be nullable.

For instance, DoThis<string?>(someNullableString) is valid. It may also be called with the non-nullable version, e.g. DoThis<string>(someNonNullableString).

What does where mean in a C# class declaration?

It's a generic constraint and restricts what types can be passed into the generic parameter.

In your case it requires that T is indentical to or derived from DataContext and has a default(argumentless) constructor(the new() constraint).

You need generic constraints to actually do something non trivial with a generic type.

• The new() constraint allows you to create an instance with new T().
• The DataContext constraint allows you to call the methods of DataContext on an instance of T

MSDN wrote:

where T : <base class name>
The type argument must be or derive from the specified base class.

where T : new()
The type argument must have a public parameterless constructor. When used together with other constraints, the new() constraint must be specified last.

What does where T : somevalue mean?

It is a constraint on a type parameter, meaning that the type T given to a generic class or method must inherit from the class Attribute

For example:

public class Foo<T> : 
   where T : Attribute
{
    public string GetTypeId(T attr) { return attr.TypeId.ToString(); }
 // ..
}

Foo<DescriptionAttribute> bar; // OK, DescriptionAttribute inherits Attribute
Foo<int> baz; // Compiler error, int does not inherit Attribute

This is useful, because it allows the generic class to do things with objects of type T with the knowledge that anything that is a T must also be an Attribute.

In the example above, it's okay for GetTypeId to query the TypeId of attr because TypeId is a property of an Attribute, and because attr is a T it must be a type that inherits from Attribute.

Constraints can also be used on generic methods, with the same effect:

public static void GetTypeId<T>(T attr) where T : Attribute
{
   return attr.TypeId.ToString();
}

There are other constraints you can place on a type; from MSDN:

where T: struct

The type argument must be a value
type. Any value type except Nullable
can be specified.

where T : class

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

where T : new()

The type argument must have a public
parameterless constructor. When used
together with other constraints, the
new() constraint must be specified
last.

where T : <base class name>

The type argument must be or derive
from the specified base class.

where T : <interface name>

The type argument must be or implement
the specified interface. Multiple
interface constraints can be
specified. The constraining interface
can also be generic.

where T : U

The type argument supplied for T must
be or derive from the argument
supplied for U. This is called a naked
type constraint.

interfaceT where T : class

Check my full post here : Constrain on custom generic type which talks about different type of generic constrain

it's Reference Type Constrain

Constrain ensure that type argument is Reference Type. i.e Class, Interface, Delegates, Array etc.

interface iSend<T> where T : class

Example

Valid             InValid
A<MyClass>        A<int>
A<InterfaceME>    A<float>   
A<float[]>  

Note :
Always come first when multiple constrain applied.

What is where T : class in C# generic methods?

In the second method the T can only be a class and cannot be a structure type.

See Constraints on Type Parameters (C# Programming Guide):

where T : class

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

What does T denote in C#

It is a Generic Type Parameter.

A generic type parameter allows you to specify an arbitrary type T to a method at compile-time, without specifying a concrete type in the method or class declaration.

For example:

public T[] Reverse<T>(T[] array)
{
    var result = new T[array.Length];
    int j=0;
    for(int i=array.Length - 1; i>= 0; i--)
    {
        result[j] = array[i];
        j++;
    }
    return result;
}

reverses the elements in an array. The key point here is that the array elements can be of any type, and the function will still work. You specify the type in the method call; type safety is still guaranteed.

So, to reverse an array of strings:

string[] array = new string[] { "1", "2", "3", "4", "5" };
var result = reverse(array);

Will produce a string array in result of { "5", "4", "3", "2", "1" }

This has the same effect as if you had called an ordinary (non-generic) method that looks like this:

public string[] Reverse(string[] array)
{
    var result = new string[array.Length];
    int j=0;
    for(int i=array.Length - 1; i >= 0; i--)
    {
        result[j] = array[i];
        j++;
    }
    return result;
}

The compiler sees that array contains strings, so it returns an array of strings. Type string is substituted for the T type parameter.

---

Generic type parameters can also be used to create generic classes. In the example you gave of a SampleCollection<T>, the T is a placeholder for an arbitrary type; it means that SampleCollection can represent a collection of objects, the type of which you specify when you create the collection.

So:

var collection = new SampleCollection<string>();

creates a collection that can hold strings. The Reverse method illustrated above, in a somewhat different form, can be used to reverse the collection's members.

What does T stands for in C#?

It is a Generic Type Parameter.

A generic type parameter allows you to specify an arbitrary type T to a method at compile-time, without specifying a concrete type in the method or class declaration.

For example:

public T[] Reverse<T>(T[] array)
{
    var result = new T[array.Length];
    j=0;
    for(int i=array.Length; i>= 0; i--)
    {
        result[j] = array[i];
        j++;
    }
    return result;
}

reverses the elements in an array. The key point here is that the array elements can be of any type, and the function will still work. You specify the type in the method call; type safety is still guaranteed.

So, to reverse an array of strings:

string[] array = new string[] { "1", "2", "3", "4", "5" };
var result = reverse(array);Will produce a string array in result of { "5", "4", "3", "2", "1" }

This has the same effect as if you had called an ordinary (non-generic) method that looks like this:

public string[] Reverse(string[] array)
{
    var result = new string[array.Length];
    j=0;
    for(int i=array.Length; i >= 0; i--)
    {
        result[j] = array[i];
        j++;
    }
    return result;

}The compiler sees that array contains strings, so it returns an array of strings. Type string is substituted for the T type parameter.

---

Generic type parameters can also be used to create generic classes.

In the example you gave of a SampleCollection, the T is a placeholder for an arbitrary type; it means that SampleCollection can represent a collection of objects, the type of which you specify when you create the collection.

So:

var collection = new SampleCollection<string>();

creates a collection that can hold strings. The Reverse method illustrated above, in a somewhat different form, can be used to reverse the collection's members.

---

Related Topics