Covariant Return Types in C#

Covariant return types in C# allow an overriding method or read-only property in a derived class to declare a more-derived (more specific) return type than the method it overrides in the base class. First introduced in C# 9 and standard across all modern .NET versions (.NET 8 through .NET 10), covariant returns eliminate redundant manual type casting and fragile member hiding when returning specialized objects from subclasses.

Updated November 2026: Modernized for current .NET and C# syntax. All examples use modern record inheritance and top-level statements.

One of the most consequential object-oriented additions to the C# language is Covariant return types. While the terminology sounds academic, the practical impact on day-to-day API design and domain modeling is huge. In this post, we’ll break down covariance versus contravariance, see how covariant return types work in practice, and look at real-world examples.

Quick Summary: Covariance vs. Contravariance

Before jumping into return types, it helps to understand what Covariance and Contravariance mean in .NET:

• Covariance (out T) allows for the assignment of a more-derived instance to a less-derived parameter or variable. Since all .NET objects derive from object, we can assign a List<string> to IEnumerable<object>. The conversion is implicit because string inherits from object.
• Contravariance (in T) is the reverse behavior, allowing us to take an instance with a less-derived type argument and assign it to a more-derived type variable. Interfaces like IEqualityComparer<in T> rely on contravariance so a comparer for object can compare specific derived types.

A simple mental model is: Covariance flows outward (returns/outputs), while Contravariance flows inward (parameters/inputs).

What’s A Covariant Return Type?

Generic type parameters have supported out (covariance) and in (contravariance) since C# 4, but overriding methods historically could not change their return types. If a base class declared public virtual Person Clone(), any derived class Employee had to return Person—forcing callers to explicitly cast (Employee)emp.Clone().

C# 9 introduced Covariant return types to solve this exact problem:

Permit the override of a method to declare a more derived return type than the method it overrides, and similarly to permit the override of a read-only property to declare a more derived type. –Microsoft C# Language Proposal

The Problem Before Covariant Returns

Prior to C# 9, developers had two suboptimal workarounds:

1. Keep the base return type: The derived class overrides the method but still returns the base type. Every caller must cast the result:

   // Caller must cast every time
   Gamer gamer = ...;
   GamerIdentity id = (GamerIdentity)gamer.Id;

2. Member hiding with new: The derived class hides the base property with new. This breaks polymorphism because calling the property through a base Person reference invokes the base implementation rather than the derived one.

Covariant returns eliminate both workarounds by providing true polymorphism with strongly typed returns.

Code Example: Person and Gamer Records

Let’s see how this works in practice with modern C# records.

First, let’s look at our base record types of Person and Identity. Both are abstract records, and the Id property is virtual, meaning any deriving record type can override it:

public abstract record Person
{
    public virtual Identity Id { get; }
}

public abstract record Identity
{
    public string Name { get; init; } = string.Empty;
}

Now let’s create a derived Gamer record and override the Id property with a more-derived GamerIdentity type:

public record Gamer : Person
{
    public Gamer(string name, string username)
    {
        Id = new GamerIdentity
        {
            Name = name,
            Username = username
        };
    }

    // Covariant override: returns GamerIdentity, not just Identity!
    public override GamerIdentity Id { get; }
}

public record GamerIdentity : Identity
{
    public string Username { get; init; } = string.Empty;
}

Notice that the Gamer record overrides Person.Id, but declares its return type as GamerIdentity instead of Identity.

Consuming the Covariant Property

When you work directly with a Gamer instance, the compiler knows gamer.Id is a GamerIdentity without any explicit casting:

var gamer = new Gamer("Khalid", "leetKhalid");

// Strongly typed: gamerId is GamerIdentity, exposing Username directly
GamerIdentity gamerId = gamer.Id;
Console.WriteLine($"Gamer username: {gamerId.Username}");

At the same time, it preserves full polymorphic behavior. If you treat the instance as its base Person type, .NET accesses the same property while viewing it through the base contract:

Person person = gamer;

// Polymorphic: calls Gamer.Id under the hood, typed as base Identity
Identity identity = person.Id;
Console.WriteLine($"Person name: {identity.Name}");

Advantages of Covariant Return Types

1. Cleaner API Design: Derived types return their most specific type, eliminating redundant casts for callers.
2. Preserves True Polymorphism: Unlike the new keyword, covariant overrides are true virtual overrides dispatched through the vtable.
3. Fluent Builders & Cloning: Factory and builder methods (like .Clone() or .WithConfig(...)) can return the concrete builder subclass rather than the base interface.
4. Non-Breaking Evolution for Library Authors: Library authors can upgrade an existing method’s return type to a more derived type in a new release without breaking binary or source compatibility for existing consumers.

If you work frequently with type constraints and generic type hierarchies, you might also be interested in our deep dive into generic C# methods with enum constraints, as well as our upcoming guide on C# generics.

Frequently Asked Questions

What are covariant return types in C#?

Covariant return types allow an overriding method or read-only property in a derived class to return a more-derived (more specialized) type than the method it overrides in its base class or interface.

Can value types or structs be used with covariant return types?

No. Covariant return types require reference identity subtyping. Because structs are value types and do not support inheritance, return types must be reference types (classes, records, or interfaces).

Can method parameters also be contravariant when overriding methods in C#?

No. In C#, overriding methods must match base parameter types exactly. Contravariance in C# is restricted to generic type parameters marked with in (such as Action<in T> or IComparable<in T>), not method override parameters.

Do covariant return types work with interfaces in C#?

Yes. Starting with C# 9 on modern .NET runtimes (.NET 5+ and .NET Core 3.0+), an implementing class can satisfy an interface method by returning a more-derived type than the interface signature specifies.

Conclusion

Terminology like covariance and contravariance can seem intimidating, but the concept is intuitive: covariance allows data to flow from a less-derived contract to a more-derived implementation. Covariant return types provide clean, expressive object-oriented contracts that eliminate casting headaches while maintaining strict compile-time safety across your domain models.

References

• What’s new in C# 9.0 — Microsoft Learn
• Covariant Return Types Proposal — C# Language Design
• Covariance and Contravariance in Generics — Microsoft Learn