[Proposal]: Constrained interfaces

[Avid29]

FEATURE_NAME

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

Currently, there's no way of guaranteeing if an interface is a class or a struct. I believe an interface should be able to specify if it must be a class or struct.

Motivation

This would allow interfaces guaranteed to be references to be used as generics with reference constraints and for the -nullable flag to be used more effectively.

Detailed design

An interface can "implement" class or struct same as with a generic constraint. Also similarly to the generic constraint, class or struct must be first in the implementation list.

/// <summary>
/// IFoo is an interface that is guaranteed to be implemented by a class
/// </summary>
public interface IFoo : class, IOtherInterface
{
}

Case 1: Nullable interface

IFoo bar = null;

Case 2: Used as generic with constraint

public class Bar<T>
    where T : class
{
}

Bar<IFoo> myBar = new Bar<IFoo>();

Drawbacks

Effectively "implementing" struct or class begins to defeat the original purpose of interfaces (as opposed to C++ abstract classes). However, this rule has already been stretched for generic constraints.

Alternatives

In some cases, an abstract class could be made as a loop whole to this. However then all the drawbacks of abstract classes apply.

public abstract class Foo : IFoo
{
}

Unresolved questions

Design meetings

[svick]

I don't understand this suggestion. Both of your cases are already valid code today, because interfaces themselves are references types (which is achieved by boxing in the case of value types implementing interfaces) and because the class constraint actually constrains the type to be any reference type.