{"id":621,"date":"2022-05-06T16:32:12","date_gmt":"2022-05-06T09:32:12","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=621"},"modified":"2023-04-04T13:15:44","modified_gmt":"2023-04-04T06:15:44","slug":"csharp-generic-constraints","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-generic-constraints\/","title":{"rendered":"C# Generic Constraints"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# generic constraints that allow you to specify what kinds of types are acceptable as arguments.<\/p>\n\n\n\n

Introduction to C# generic constraints<\/h2>\n\n\n\n

The following example defines a generic class<\/a> Result<T><\/code>:<\/p>\n\n\n

class<\/span> Result<\/span><T<\/span>>\n{\n    T Data { get<\/span>; set<\/span>; }\n    int<\/span> Status { get<\/span>; set<\/span>; }\n    public<\/span> Result<\/span>(T data, int<\/span> status<\/span>)<\/span>\n    {\n        Data = data;\n        Status = status;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the Result<T><\/code> only assigns data<\/code> argument to Data<\/code> member. It doesn’t do anything else that requires the operations of the type T<\/code>. <\/p>\n\n\n\n
The reason is that the Result<T><\/code> doesn’t know the data of the type T<\/code> it will store. Therefore, it can’t know the members of the type T<\/code>. <\/p>\n\n\n\n
Since all objects are derived from the object<\/code> class including T<\/code>, the Result<T><\/code> class only knows the members of the object<\/code> class such as ToString()<\/code>, Equals()<\/code>, and GetType()<\/code>.<\/p>\n\n\n\n
As long as the Result<T><\/code> class does not access the member of the type T<\/code> other than members of the object<\/code> class, the Result<T><\/code> class can handle any type. This type parameter is called the unbounded type parameter<\/strong>.<\/p>\n\n\n\n
However, if you try to use any other members, the compiler will produce an error message. For example:<\/p>\n\n\n
class<\/span> Result<\/span><T<\/span>>\n{\n    T Data { get<\/span>; set<\/span>; }\n    int<\/span> Status { get<\/span>; set<\/span>; }\n\n    public<\/span> Result<\/span>(T data, int<\/span> status<\/span>)<\/span>\n    {\n        Data = data;\n        Status = status;\n    }\n\n\n    public<\/span> string<\/span> JSON<\/span>(<\/span>)<\/span> \n    {\n        return<\/span> Data?.ToJSON(); \/\/ ERROR<\/span>\n    }\n\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
This example causes an error because the JSON()<\/code> method of the Result<T><\/code> class attempts to call the ToJSON()<\/code> method of the Data<\/code> member.<\/p>\n\n\n\n
To make the Result<T><\/code> class more useful, you can specify the information about the kind of types that is acceptable as arguments. This additional information is called generic constraints<\/strong>.<\/p>\n\n\n\n
To specify a generic constraint, you use the where<\/code> clause after the closing angle bracket of the type parameter list:<\/p>\n\n\n
class<\/span> MyClass<\/span><T<\/span>> where<\/span> TypeParam<\/span>: constraint<\/span>, constraint<\/span>,<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
For example, the following specifies that the type T must be a type that implements the IJSON<\/code> interface:<\/p>\n\n\n
\ninterface<\/span> IJSON<\/span>\n{\n    string<\/span> ToJSON<\/span>(<\/span>)<\/span>;\n}\n\n\nclass<\/span> Result<\/span><T<\/span>> \n       where<\/span> T<\/span> : IJSON<\/span>\n{\n    T Data { get<\/span>; set<\/span>; }\n    int<\/span> Status { get<\/span>; set<\/span>; }\n    public<\/span> Result<\/span>(T data, int<\/span> status<\/span>)<\/span>\n    {\n        Data = data;\n        Status = status;\n    }\n\n    public<\/span> string<\/span> JSON<\/span>(<\/span>)<\/span> \n    {\n        return<\/span> Data?.ToJSON();\n    }\n\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
C# Generic constraint types and order<\/h2>\n\n\n\n
C# provides you with five types of generic constraints:<\/p>\n\n\n\n
Constraint Type<\/th>Description<\/th><\/tr><\/thead>
ClassName<\/td>The type argument is the class of this type or classes derived from it.<\/td><\/tr>
class<\/td>The type argument can be any reference type including classes, arrays, delegates, and interfaces.<\/td><\/tr>
struct<\/td>The type argument can be any value type<\/td><\/tr>
InterfaceName<\/td>The type argument can be the interface or types that implement this interface<\/td><\/tr>
new()<\/td>The type argument with the parameterless public constructor.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
A generic type can have multiple constraints. In other words, it can have multiple where<\/code> clauses like this:<\/p>\n\n\n
class<\/span> MyClass<\/span><T1<\/span>, T2<\/span>, T3<\/span>>\n    where<\/span> T2<\/span>: MyClass2<\/span>\n    where<\/span> T3<\/span>: IMyInterface<\/span>\n{\n   \/\/...<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The order of the where<\/code> clauses is not important. However, the constraints in a where<\/code> clause matters. The following shows the order of the constraints:<\/p>\n\n\n\n
Primary (0 or 1)<\/th>Secondary (0 or more)<\/th>Constructor (0 or 1)<\/th><\/tr><\/thead>
ClassName
class
struct<\/td>		InterfaceName<\/td>new()<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • Generic constraints specify constraints on the type used as arguments for type parameters in generic type.<\/li>\n\n\n\n
  • Use the where<\/code> clauses to specify generic constraints.<\/li>\n<\/ul>\n
    \n\t
    \n\t\t
    Was this tutorial helpful ?<\/div>\n\t\t
    \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
    \n\t\t
    \n\t\t\t
    <\/div>\n\t\t\t\n\t\t\t