Does C# Support Return Type Covariance?

C# return type co -changes: in -depth discussion

In object -oriented programming, developers often need to obtain more accurate type information when rewriting methods. Back to the type of collaboration is a concept, which allows subclasses to return a more specific type than the base class. But does C# support this powerful feature?

C# position on the backbone type co -changes

Although the language like C is widely used in the return type coordination, unfortunately, C# does not natively support it. This is the fundamental restriction of the C# code execution -when the public language is running (CLR).

Type safety issues

C# does not support one reason for returning types of collaboration is the type of security. Allowing subclasses to return more specific types than base classes may cause unexpected inconsistency and runtime errors. The strict type inspection mechanism of the CLR ensures that the object is consistently processed throughout the system, and the introduction of the return type coordinating change will destroy this stability. Solution

Although C# does not directly support the return type coordination, developers can still achieve similar effects through other methods. A commonly used technology is to introduce protected auxiliary methods in the base class. These methods provide an indirect layer that allows subclasses to return a more specific type, while maintaining the type safety:

In this example, the Aquarium class rewrite the protected GetContents () method, and provides a new public Contents () method. This method returns a more specific type FISH, while maintaining the Animal of the base class Animal Return to type compatibility.

Latest Progress: The coordination in C# 9.0 returns

<code class="language-c#">abstract class Enclosure
{
    protected abstract Animal GetContents();
    public Animal Contents() { return this.GetContents(); }
}

class Aquarium : Enclosure
{
    protected override Animal GetContents() { return this.Contents(); }
    public new Fish Contents() { ... }
}</code>

However, the situation is changing. In the recently released C# 9.0, Microsoft introduced a feature called "Cooperative Change" as a step as a step to gradually support the type of collaboration. As long as it is a type of parameters of the base interface or method, this feature allows developers to specify more specific return types for the rewriting method. Although this is a major improvement, it still cannot achieve all the functions of a complete return type coordination.

If you encounter a situation of returning type co -changes to your code, you can consider exploring other languages ​​that fully support this feature, such as C /CLI or F#.

The above is the detailed content of Does C# Support Return Type Covariance?. For more information, please follow other related articles on the PHP Chinese website!