Declaring a Generic type must implement the Generic Constraint

Question

I would ideally like Foo<T> to require that any instantiations themselves implement the T. (Foo<> is either abstract, or an interface)

Or if it's actually MyFoo : IFoo<ConcreteClass> then MyFoo : ConcreteClass

Currently I've achieved my underlying goal by having Foo<T> declare a property of type T, which is generally satisfied by returning the class itself, but I'm curious as to whether I can do it more directly.

---

EDIT: I've convinced myself this is impossible. For reference the code in question looks like this:

public abstract class BotController<TBot> : BotController, IBotController<TBot>
{
    protected BotController(TBot wrappedBot, PlayerRecord player, long timeout) : base(player, timeout)
    {
        WrappedBot = wrappedBot;
    }

    protected TBot WrappedBot { get; set; }
    public abstract TBot ControlledBot { get; }

    private string cachedName;
    public  override string BotName => (cachedName = (cachedName ?? WrappedBot.Name));

    protected T SafelyPerformBotActionWithTimer<T>(Func<TBot, T> botAction, string errorDescriptor)
    {
        return SafelyPerformBotActionWithTimer(() => botAction(WrappedBot), errorDescriptor);
    }

    protected void SafelyPerformBotActionWithTimer(Action<TBot> botAction, string errorDescriptor)
    {
        SafelyPerformBotActionWithTimer(() => botAction(WrappedBot), errorDescriptor);
    }
}


public class BattleshipsController : BotController<IBattleshipsBot>, IBattleshipsBot
{
    public BattleshipsController(IBattleshipsBot battleshipImplementation, PlayerRecord playerRecord, long timeout = 1000)
        : base(battleshipImplementation, playerRecord, timeout) {}

    public override IBattleshipsBot ControlledBot => this;


    public IEnumerable<IShipPosition> GetShipPositions()
    {
        //qqMDM validate Ship Positions here?
        return SafelyPerformBotActionWithTimer(b => b.GetShipPositions(), "specifying ship positions");
    }

    public IGridSquare SelectTarget()
    {
        var target = SafelyPerformBotActionWithTimer(b => b.SelectTarget(), "selecting a target");

        if (target.IsOutsideGrid())
        {
            throw new ShotOffBoardException($"{BotName} has tried to shoot off the board, aiming at square {target.Row}{target.Column}", this);
        }
        return target;
    }

    public void HandleShotResult(IGridSquare square, bool wasHit)
    {
        SafelyPerformBotActionWithTimer(b => b.HandleShotResult(square, wasHit), "handling shot result");
    }

    public void HandleOpponentsShot(IGridSquare square)
    {
        SafelyPerformBotActionWithTimer(b => b.HandleOpponentsShot(square), "handling opponent's shot");
    }

    public string Name => BotName;
}

Answer 1

The specific thing I was imagining is not possible.

I wanted some syntax along the lines of:

abstract class Foo<TWrappedType> where Foo : TWrappedType

which might conceptually work if TWrappedType is an interface (which it will be in my cases), but could never work if TWrappedType is a concrete class, because C# doesn't do multiple inheritance.

Since you can't constrain whether a Generic Type is an interface or a class, the syntax cannot exist.

I'd sort of gotten half way towards that as I was writing the question, hence the confused question, but not far enough to work out that it was impossible.

Answer 2

If I've understood you correctly, you could do this with an intermediate class/interface:

interface IInterface<T>
{ }

class Foo<T> : IInterface<T> where T : IInterface<T>
{
}

But your question isn't all that clear. I'm not sure if this is anything similar to what you want, these kind of class declarations simply make my head hurt.

Answer 3

For the benefit of future people considering this, it initially seemed as though you could get some benefit and end up with the same syntax at the endpoint (a Foo<T> that looks like a T), by setting up explicit and implicit cast operators that simply return the property of the abstract class.

However this is not allowed in the language.

See here: implicit operator using interfaces