用返回类型实现接口，该接口实现所需的返回类型

Question

Why can't I do this?

IHasOperatingSystem {
IOperatingSystem OperatingSystem { get; }
} 

Computer<T> : IHasOperatingSystem where T : IOperatingSystem {
public T OperatingSystem { get; }
}

It's telling me that the type should be IOperatingSystem, but if T implements IOperatingSystem, shouldn't that be sufficient?

Also, I realize that the title to this question might be a little confusing, but I couldn't think of a better way to phrase it.

Answer 1

It's telling me that the type should be IOperatingSystem, but if T implements IOperatingSystem, shouldn't that be sufficient?

No. That's just not the way C# works. In order to implement an interface, or override a method, the parameter types and the return type have to match exactly . From section 13.4.4 of the C# 5 specification:

For purposes of interface mapping, a class member A matches an interface member B when:

• A and B are methods, and the name, type, and formal parameter lists of A and B are identical.
• ...

(Here "type" should be read as "return type".)

Now you could make your IHasOperatingSystem type generic, of course:

public interface IHasOperatingSystem<T> where T : IOperatingSystem
{
    T OperatingSystem { get; }
}

public class Computer<T> : IHasOperatingSystem<T> where T : IOperatingSystem
{
    public T OperatingSystem { get { ... } }
}

Or alternatively you could use explicit interface implementation in the Computer<T> class:

public interface IHasOperatingSystem
{
    IOperatingSystem OperatingSystem { get; }
} 

public class Computer<T> : IHasOperatingSystem where T : IOperatingSystem
{
    // Explicit interface implementation...
    IHasOperatingSystem.OperatingSystem IOperatingSystem
    {
        // Delegate to the public property
        get { return OperatingSystem; }
    }

    public T OperatingSystem { get { ... } };
}

Answer 2

if T implements IOperatingSystem, shouldn't that be sufficient?

Even though it may be sufficient in other languages (Scala, I think), In C#, it is not. Return types are invariant (except for delegate return types, which are covariant ).

A common workaround for these situations is to use generics, as such:

IHasOperatingSystem<T> where T: IOperatingSystem 
{
    T OperatingSystem { get; }
} 

Computer<T> : IHasOperatingSystem <T> where T : IOperatingSystem
{
    public T OperatingSystem { get; }
}