C＃强制转换通用接口的非通用实现

Question

I read quite a lot of possible answers and didn't find any that could fit my needs !

I am trying to declare a generic interface, have different non-generic implementing classes and then use this classes in the same context.

This is what I have so far :

Interfaces

public interface WeirdType { }
public class WeirdType1 : WeirdType { }
public class WeirdType2 : WeirdType { }


public interface IGenericInterface<T>
{
  T GiveT();
  void TakeItBack(T data);
}

Implementations

public class NonGenericImplementation1 : IGenericInterface<WeirdType1>
{
  public WeirdType1 GiveT() { return new WeirdType1(); }
  public void TakeItBack(WeirdType1 data) { Console.WriteLine("Got it back 1"); }
}

public class NonGenericImplementation2 : IGenericInterface<WeirdType2>
{
  public WeirdType2 GiveT() { return new WeirdType2(); }
  public void TakeItBack(WeirdType2 data) { Console.WriteLine("Got it back 2"); }
}

Usage

List<IGenericInterface<WeirdType>> implementations = new List<IGenericInterface<WeirdType>>
{
  new NonGenericImplementation1(),
  new NonGenericImplementation2()
};

foreach (var impl in implementations)
{
  WeirdType x = impl.GiveT();
  impl.TakeItBack(x);
}

This throws me

'Argument Type NonGenericImplementation1 is not assignable to IGenericInterface<WeirdType>' 

and even if some black casting magic gets me through compilation it crashes at runtime for the same reason.

Help me understand what makes this impossible for C# typing and/or suggest slightly more complex patterns to get it done smoothly

I can solve my actual problem a lot of different ways, so completely alternate solutions are not really what I am looking for

And obviously if the actual answer already exists sorry for the time wasting

Answer 1

As always it's hard to be pertinent without context, still I'll do my best to help.

The error 'Argument Type NonGenericImplementation1 is not assignable to IGenericInterface' seems perfectly fine to me, in C# the different members of a collection must have the same type.

But why do you declare :

public class NonGenericImplementation1 : IGenericInterface<WeirdType1>
public class NonGenericImplementation2 : IGenericInterface<WeirdType2>

Instead of:

public class NonGenericImplementation1 : IGenericInterface<WeirdType>
public class NonGenericImplementation2 : IGenericInterface<WeirdType>

In this way, all your example code will still work, and both classes will implement the same interface, so you can now declare:

List<IGenericInterface<WeirdType>> implementations = new List<IGenericInterface<WeirdType>>
            {
              new NonGenericImplementation1(),
              new NonGenericImplementation2()
            };

Hope it helps.

Answer 2

即使WeirdType1实现WeirdType ， IGenericInterface<WeirdType1>也不是IGenericInterface<WeirdType> 。

Answer 3

The problem is that if you take something out of implementations we know it is of type IGenericInterface<WeirdType> . This means that we should be able to call GiveT and get a WeirdType and TakeItBack while passing it a WeirdType .

In particular this means both of the following must work:

impl.TakeItBack(new WeirdType1());
impl.TakeItBack(new WeirdType2());

Now if impl is of type NonGenericImplementation1 then the second is not valid and if it is of type NonGenericImplementation2 then the first is not valid.

This means that we are not allowed to claim that NonGenericImplementation1 is of type IGenericInterface<WeirdType> and the same for NonGenericImplementation2 .

Answer 4

You do not have any non generic class which implements IGenericInterface .

Your "implements" collection can only accept objects of type which implements above mentioned interface.

That's the beauty of Generics. They are strongly typed and specially when you are dealing with Generics of Generics it becomes much more challenging. But there is not way out of it.

First of all Generic List will not accept any object of type which is not implementing IGenericInterface. Next when you have that kind of class it will also not allow the object which is instantiated with type other then "WeirdType" no matter even if the type is inherited from "WeirdType".

So inheritance in Generics helps at the first level but not beyond that.

There is solution for your problem. It's not a 100% valid solution, and many OOP Experts will not agree with this, but it has class structure you want and it works the way you want.

You need to create sub classes as following.

public class GenericClass<T> : IGenericInterface<T> where T : WeirdType
{
    public virtual T GiveT()
    {
        return default(T);
    }

    public virtual void TakeItBack(T data)
    {

    }
}

public class NonGenericClass1 : GenericClass<WeirdType1>, IGenericInterface<WeirdType>
{
    public override WeirdType1 GiveT()
    {
        return new WeirdType1();
    }

    public void TakeItBack(WeirdType data)
    {
        Console.WriteLine("Got it back 1");
    }

    public override void TakeItBack(WeirdType1 data)
    {
        this.TakeItBack(data);
    }

    WeirdType IGenericInterface<WeirdType>.GiveT()
    {
        return GiveT();
    }
}

public class NonGenericClass2 : GenericClass<WeirdType2>, IGenericInterface<WeirdType>
{
    public WeirdType2 GiveT()
    {
        return new WeirdType2();
    }

    public void TakeItBack(WeirdType data)
    {
        Console.WriteLine("Got it back 2");

    }

    public override void TakeItBack(WeirdType2 data)
    {
        this.TakeItBack(data);
    }

    WeirdType IGenericInterface<WeirdType>.GiveT()
    {
        return this.GiveT();
    }
}

Now you can initialize the collection of Generic interface and add objects of sub classes into it.

var obj1 = new NonGenericClass1();
        var obj2 = new NonGenericClass2();
        List<IGenericInterface<WeirdType>> implementations = new List<IGenericInterface<WeirdType>>
        {
           obj1, obj2
        };

        foreach (var impl in implementations)
        {
            WeirdType x = impl.GiveT();
            impl.TakeItBack(x);
        }

This should resolve your issue.

Answer 5

Thanks everyone for your input, I was tryng not to repeat code that was T agnostic, with as less boilerplate as possible.

The solution I went with was adding an abstract class implementing an extra interface.

This does not satisfy me as I believe you should be able to write type agnostic code for generics, and thus without modifying the actual classes and interfaces code/hierarchy nor abusing reflexion.

That would be possible with extension methods and non-typed list of generics, the later not being supported in C#.

Heres the extra code :

public interface IComplexable { void DoComplexStuff(); }

public abstract class GenericImplementation<T> : IGenericInterface<T>, IComplexable
{
    public abstract T GiveT();
    public abstract void TakeItBack(T data);

    public void DoComplexStuff()
    {
        T x = GiveT();
        TakeItBack(x);
    }
}

Classes declaration :

public class NonGenericImplementation1 : GenericImplementation<WeirdType1>
public class NonGenericImplementation2 : GenericImplementation<WeirdType2>

Usage :

var impl = new IComplexable[] { new NonGenericImplementation1(),new NonGenericImplementation2() };
foreach (var complexable in impl)
{
  complexable.DoComplexStuff();
}