从泛型类型继承的数组

Question

Code to demonstrate the problem:

static void Main(string[] args)
{
    var a = new A();
    var b = new B();
    Base<>[] all = new Base<>[] { a, b }; // doesn't work
}

class Base<T>
{
    public string Caption { get { return typeof(T).ToString(); } }
}

class A : Base<A> { }
class B : Base<B> { }

Perhaps I went the wrong direction. Idea was to move Caption into base class ( Base become generic). Non-generic version works without problems:

var all = new Base[] { a, b }; // no problems for as long as Base is not generic

Answer 1

There's no Type<?> in C# - you always have to specify a concrete generic type.

The only way around this is to make Base<T> inherit a non-generic base-class, or implement a non-generic interface. You could then use that as the type of the array.

EDIT:

In your case this is extremely simple, since the part of the interface you want doesn't include the generic type argument. So you can simply do either:

public abstract class Superbase
{
  public abstract string Caption { get; }
}

public class Base<T>: Superbase
{
  public override string Caption { get { return typeof(T).Name; } }
}

Or, using an interface:

public interface IBase
{
  string Caption { get; }
}

public class Base<T>: IBase
{
  public string Caption { get { return typeof(T).Name; } }
}

Your array would then be Superbase[] or IBase[] , respectivelly. In both cases, you can see that I'm not actually providing an implementation - both the declarations are "abstract", in a sense.

In general, I'm trying to keep the non-generic stuff in a non-generic base class, rather than stuffing it in the derived generic classes. It just feels more clean :)

Answer 2

based on @Luaan ideea, here is an implementation:

class Program
{
    static void Main(string[] args)
    {
        var a = new A();
        var b = new B();

        var arr = new Base[] { a, b};

        foreach (var obj in arr)
            Console.WriteLine(obj.Caption);

        Console.ReadKey();
    }
}

public class Base<T> : Base
{
    public override string Caption
    {
        get { return typeof (T).ToString(); }
    }
}

public class A : Base<A> { }

public class B : Base<B> { }

public abstract class Base
{
    public abstract string Caption { get; }
}

Answer 3

Instead of trying to use inheritance (which will lead to more problems down the line), use an extension method instead:

public interface IClassAORClassB {}

class A : IClassAORClassB { }
class B : IClassAORClassB { }

public static class Captions
{
    public static string Caption<T>(this T obj) where T : IClassAORClassB
    {
        return obj.GetType().ToString();
    }
}

static void Main(string[] args)
{
    var a = new A();
    var b = new B();
    var all = new IClassAORClassB[] { a, b }; // works just fine
    Console.WriteLine(all[0].Caption()); // prints A
    Console.WriteLine(all[1].Caption()); // prints B
}