Fix incorrect statement about generic interface inheritance requiring covariance

[Copilot]

Summary

Fixes #43518

The documentation contained a false statement claiming that generic interfaces can only inherit from non-generic interfaces if the generic interface is covariant. This is incorrect—any generic interface can inherit from a non-generic interface regardless of variance.

What Was Wrong

The original text stated:

Generic interfaces can inherit from non-generic interfaces if the generic interface is covariant, which means it only uses its type parameter as a return value.

This is demonstrably false. Generic interfaces can inherit from non-generic interfaces whether they are covariant, contravariant, or invariant. The inheritance has no variance requirement.

What Changed

The corrected text now:

1. Removes the false conditional: States that generic interfaces CAN inherit from non-generic interfaces (no covariance requirement)
2. Explains the actual mechanism: When a generic interface inherits from a non-generic interface, the type parameter replaces object in the overridden members
3. Clarifies the IEnumerable example: Shows how T replaces object specifically in output positions (return types and property getters)
4. Explains why covariance is possible: Because T is used only in output positions in IEnumerable<T>, it can be marked as covariant
5. Addresses the contrapositive: Notes that if T were used in an input position in an overridden member, the interface couldn't be covariant, and the compiler would generate an error

This correction incorporates the clarification provided by @BillWagner about how type parameters replace object in overridden members.

Verification

• Markdown linting passes with no errors
• Created test programs demonstrating that covariant, contravariant, and invariant generic interfaces can all inherit from non-generic interfaces
• Only one line changed (minimal modification)

Co-authored-by: BillWagner [email protected]

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Completely false statement about generic interface inheriting from non-generic interface</issue_title>
<issue_description>### Type of issue

Other (describe below)

Description

The page contains the false statement

Generic interfaces can inherit from non-generic interfaces if the generic interface is covariant, which means it only uses its type parameter as a return value. In the .NET class library, IEnumerable<T> inherits from IEnumerable because IEnumerable<T> only uses T in the return value of GetEnumerator and in the Current property getter.

Not sure if and what got lost in translation/editing there with these two sentences, but it is obviously entirely false from the beginning to end.

Generic interfaces can inherit non-generic interfaces regardless of variance. And IEnumerable<T> being covariant is not because it inherits IEnumerable or vice versa.

Page URL

https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/generics/generic-interfaces

Content source URL

https://github.com/dotnet/docs/blob/main/docs/csharp/programming-guide/generics/generic-interfaces.md

Document Version Independent Id

d54ecf19-fccb-3d6b-d990-81529acf44c3

Platform Id

bf75a432-ec19-5df7-3485-3b75577d31e8

Article author

@BillWagner

Metadata

• ID: be0a00a9-fd5d-3aae-9788-d6b324f17599
• PlatformId: bf75a432-ec19-5df7-3485-3b75577d31e8
• Service: dotnet-csharp
• Sub-service: fundamentals

Related Issues</issue_description>

Comments on the Issue (you are @copilot in this section)

@BillWagner This could use clarification: The important details for `IEnumerable` and `IEnumerable` are that the type parameter, `T` replaces `object` in some overriden members. The members where `T` replaces `object` are all covariant. If `T` were to replace `object` in an input location in an overridden member, that would be a compiler error.

Fixes #47104

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

---

Internal previews

📄 File	🔗 Preview link
docs/csharp/programming-guide/generics/generic-interfaces.md	Generic Interfaces (C# Programming Guide)

[BillWagner]

This is good, with one suggestion.