{"id":1391,"date":"2023-04-05T10:02:12","date_gmt":"2023-04-05T03:02:12","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=1391"},"modified":"2023-04-05T10:02:13","modified_gmt":"2023-04-05T03:02:13","slug":"csharp-contravariance","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-contravariance\/","title":{"rendered":"C# Contravariance"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about C# contravariance and how to use it to make your code more flexible.<\/p>\n\n\n\n

Introduction to C# Contravariance<\/h2>\n\n\n\n

Contravariance is a mechanism in C# that allows a method to accept a parameter of a less specific type than what is defined in the method signature. <\/p>\n\n\n\n

In other words, contravariance allows a method to accept an argument of a base class<\/a> or interface<\/a> type, even if the parameter type is a derived class or interface type. C# uses the in<\/code> keyword to define an interface as a contravariance.<\/p>\n\n\n\n

For example, you can define a generic interface as a contravariance like this:<\/p>\n\n\n

interface<\/span> MyInterface<\/span><in<\/span> T<\/span>>\n{\n    void<\/span> MyMethod<\/span>(T item<\/span>)<\/span>;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The in<\/code> keyword means that you can use the T<\/code> as the type of parameters of methods. If you attempt to return a value of type T<\/code>, you’ll get an error. For example:<\/p>\n\n\n
interface<\/span> MyInterface<\/span><in<\/span> T<\/span>>\n{\n    void<\/span> MyMethod<\/span>(T item<\/span>)<\/span>;\n    T ReturnItem<\/span>(<\/span>)<\/span>; \/\/ ERROR<\/span>\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
C# contravariance example<\/h2>\n\n\n\n
The following example demonstrates how contravariance works.<\/p>\n\n\n
using<\/span> static<\/span> System.Console;\r\n\r\nclass<\/span> Person<\/span>\r\n{\r\n    public<\/span> string<\/span> Name\r\n    {\r\n        get<\/span>; set<\/span>;\r\n    }\r\n    public<\/span> Person<\/span>(string<\/span> name<\/span>)<\/span>\r\n    {\r\n        Name = name;\r\n    }\n\r\n}\r\n\r\nclass<\/span> Employee<\/span> : Person<\/span>\r\n{\r\n    public<\/span> string<\/span> JobTitle\r\n    {\r\n        get<\/span>; set<\/span>;\r\n    }\r\n\r\n    public<\/span> Employee<\/span>(string<\/span> name, string<\/span> jobTitle<\/span>) : base<\/span>(name<\/span>)<\/span>\r\n    {\r\n        JobTitle = jobTitle;\r\n    }\r\n\r\n}\r\n\r\ninterface<\/span> IGroup<\/span><in<\/span> T<\/span>>\r\n{\r\n    void<\/span> Add<\/span>(T item<\/span>)<\/span>;\r\n\r\n    int<\/span> Count\r\n    {\r\n        get<\/span>;\r\n    }\r\n}\r\n\r\nclass<\/span> Group<\/span><T<\/span>> : IGroup<\/span><T<\/span>>\r\n{\r\n    private<\/span> readonly<\/span> List<T> list = new<\/span>();\r\n\r\n    public<\/span> int<\/span> Count => list.Count;\r\n\r\n    public<\/span> void<\/span> Add<\/span>(T item<\/span>)<\/span> => list.Add(item);\r\n\r\n}\r\n\r\nclass<\/span> Program<\/span>\r\n{\r\n    public<\/span> static<\/span> void<\/span> Display<\/span>(IGroup<Employee> group<\/span><\/span>)<\/span>\r\n    {\r\n        WriteLine(group<\/span>.Count);\r\n    }\r\n\r\n    public<\/span> static<\/span> void<\/span> Main<\/span>(string<\/span>[] args<\/span>)<\/span>\r\n    {\r\n        IGroup<Person> group<\/span> = new<\/span> Group<Person>();\r\n        group<\/span>.Add(new<\/span> Person(\"John Doe\"<\/span>));\r\n        group<\/span>.Add(new<\/span> Person(\"Jane Doe\"<\/span>));\r\n\r\n        Display(group<\/span>);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Output:<\/p>\n\n\n
2<\/code><\/span><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, define the Person<\/code> class that has the Name<\/code> property, and the Employee<\/code> class that inherits from the Person<\/code> class. The Employee<\/code> class has additional JobTitle<\/code> property.<\/p>\n\n\n\n
Next, define the IGroup<T><\/code> interface as contravariance by using the keyword in<\/code>. The IGroup<T><\/code> has a method Add()<\/code> and a Count<\/code> property.<\/p>\n\n\n\n
Then, define the Group<T><\/code> class that implements the IGroup<T><\/code> interface. The Add()<\/code> method adds an item with type T<\/code> to a list and the Count<\/code> property returns the number of items in the list.<\/p>\n\n\n\n
After that, define the Display<\/code> method that accepts an instance of IGroup<Employee><\/code> and shows the number of items in the group to the console.<\/p>\n\n\n\n
Finally, create a group of Person<\/code> objects and pass it to the Display<\/code> method. Because the IGroup<T><\/code> is a contravariance, the program run successfully. <\/p>\n\n\n\n
But if you take out the in<\/code> keyword from the IGroup<T><\/code> interface, the program won’t be compiled.<\/p>\n\n\n\n
Summary<\/h2>\n\n\n\n
    \n
  • In C#, contravariance is a feature that allows a method to take an argument that is less specific than the one defined in the method signature.<\/li>\n\n\n\n
  • Use the keyword in<\/code> to define an interface as a contravariance.<\/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
Note that to define T<\/code> as the type of a return value, you use the covariance<\/a> instead.<\/p>\n\n\n\n