基本的C＃接口问题

Question

I want to to implement following structure:

public interface IMyDbSet
{
    IEnumerable<User> Users { get; }
}

public class ConcreteDbSet : IMyDbSet
{
    DbSet<User> Users { get; set; }
}

Although DbSet<T> inherits from IEnumerable<T> this is not possbile.

Visual Studio error message:

.... does not implement interface member '....'. '...' cannot implement '....' because it does not have the matching return type of '....'.

Is there another way to implement such a structure or is this not possible at all?

Thanks.

Answer 1

The easiest way would be to implement the interface explicitely and return the value of the implicit Users property from the explicit Users property.

public interface IMyDbSet
{
    IEnumerable<User> Users { get; }
}

public class ConcreteDbSet : IMyDbSet
{
    IEnumerable<User> IMyDbSet.Users 
    {
        get { return Users; }
    }

    DbSet<User> Users 
    { 
        get; set; 
    }
}

Answer 2

It is impossible because whoever invokes IMyDbSet.Users expects to receive IEnumerable<User> which may but does not have to be DbSet<User> . DBSet<T> is IEnumerable<T> , but IEnumerable<T> is not DbSet<T> .

That being said nothing prevents you from returning DbSet<USer> instance as IEnumerable<User>

Answer 3

The feature that you want to use called " return type covariance " and this is not legal (unfortunately) in C# programming language.

In some other language like C++, Java or Eiffel (and some other) you could use more concrete type during overriding virtual method or implement interface.

If you're dealing with interface you could use known idiom (as Florian mentioned): you could implement your interface explicitly and add another method with another signature.

public interface IMyDbSet
{
    IEnumerable<User> Users { get; }
}

public class ConcreteDbSet : IMyDbSet
{
    IEnumerable<User> IMyDbSet.Users {get {return Users;}}

    public DbSet<User> Users { get; set; }
}

Another option - user generic IMyDbSet<T> similarly to bool Equals(object rhs) from System.Object and generic typesafe interface [IEquatable<T>][2] :

public interface IMyDbSet<T> where T : IEnumerable<User>
{
   // Because T is IEnumerable<User> or one of it descendant
   // this property is similar to IEnumerable<User> Users {get;}
   T Users {get;}
}

// Now we're implementing not IMyDbSet interface itself
// but we're IMyDbSet<IList<User>> instead.
// Note you could use your own descendant for IEnumerable<User> here
public class ConcreteDbSet : IMyDbSet<IList<User>>
{
    public IList<User> Users {get; set;}
}


//...
// and now you could use ConcreteDbSet following way:
var set = new ConcreteDbSet();
IList<User> users = set.Users;