我可以将基本 class 类型作为通用参数传递给接口吗

Question

Can I pass base class types as a generic parameters to interfaces which are implemented in the context of the successors of that base class in C#.

Let's imagine there is an interface:

public interface IElement<T>
{
   Collection<T> Neighbors { get; }   
}

I want to implement this interface like this:

public class Element : IElement<object>
{
   public Collection<Neighbor> Neighbors { get; set; }
}

I also even tried achieving it like this:

public class Element : IElement<IObject>
{
   public Collection<Neighbor> Neighbors { get; set; }
}

Where IObject and Neighbor are:

public interface IObject
{ 
}

public class Neighbor : IObject
{
   // some props
}

In either way I get the same error: Element does not implement the IElement interface - member Neighbors cannot implement IElement.Neighbors, because they have different return types.

The purpose of this is to make an abstraction of the datatypes and use a simpler version of them in the business logic:

public class BusinessLogic
{
   bool predicate1;
   bool predicate2;
    
   // variant 1
   public bool CanIDoSomething(IElement<object> element)
   {
      return element.Neighbours.Any() && predicate1 && predicate2;
   }

   // variant 2
   public bool CanIDoSomething(IElement<IObject> element)
   {
      return element.Neighbours.Any() && predicate1 && predicate2;
   }
}

The problem goes even deeper if I try to use IEnumerable instead of Collection:

public interface IElement<T>
{
   IEnumerable<T> Neighbors { get; }   
}

What am I missing and is there a workaround for this?

---

EDIT:

I Made the IElement interface generic parameter covariant as follows:

public interface IElement<out T>
{
   IEnumerable<T> Neighbors { get; }
}

But this does not solve the interface implementation error.

The only way I can make the class to implement the interface correctly is by doing this:

public class Element : IElement<IObject>
{
   public Collection<Neighbor> Neighbors { get; set; }

   IEnumerable<IObject> IElement<IObject>.Neighbors => Neighbors;
}

Is there a limitation that causes the covariance to not be applied implicitly when implementing an interface?

Is there a more elegant way of doing this?

I want to keep the IObject interface instead of using object directly because in the IObject interface if I ever need I can place a certain subset of the properties of the Neighbor class.

Answer 1

Original scenario with Collection<T>

You get this error, because your IElement<T> interface has a generic type parameter T and the property Neighbors is of type Collection<T> . Hence, your Element type that implements IElement with the concrete type object needs to implement a Collection<object> not a Collection<Neighbor> . This property must be public , as it is implemented from your public interface and the default member visibility in a class is private . The same applies if you replace object with Neighbor or any other type. See this example for Neighbor .

public class Element : IElement<Neighbor>
{
    public Collection<Neighbor> Neighbors { get; set; }
}

While this resolves your original your error, you will not be able to pass instances of type Element to your method CanIDoSomething , because your type parameter T in IElement<T> is invariant , which means you can only use the originally specified type. In the example this type would be Neighbor and not IObject or object .

You need to make yout type parameter covariant in order to use a more derived type like Neighbor . However, you will run into the issue that Collection<T> uses an invariant type parameter as well, so you will need to replace it with a type that has a covariant type parameter like IReadOnlyCollection<T> or IEnumerable<T> . The example below will show you how convariance works for your case. You can start from there to use other types and collections.

Scenario with generics and IEnumerable<T>

If you want your IElement<T> to be generic and use IEnumerable<T> , declare your interface with a convariant type parameter using the keyword out .

public interface IElement<out T>
{
    IEnummerable<T> Neighbors { get; }
}

Then implement it in your concrete class with the correct type, eg Neighbor .

public class Element : IElement<Neighbor>
{
    public IEnumerable<Neighbor> Neighbors { get; }
}

You can keep both of your CanIDoSomething methods as they are, because Neighbor is derived from object and implements the IObject interface, so it will work with covariance in both cases.