是否可以将泛型类型约束到Interface，new（）？

Question

I'm trying to create a simple object recycling class

public class ObjectPool<T> where T : class, IRecyclable, new()
{
}

I want to be able to use it with my interface:

public interface ISomeInterface : IRecyclable
{
}

ObjectPool<ISomeInterface> pool = new ObjectPool<ISomeInterface>();

But this yields the error:

error CS0310: The type `ISomeInterface' must have a public parameterless constructor in order to use it as parameter `T' in the generic type or method `ObjectPool<T>'

From what I have read online I know that I can't specify a constructor in an interface.

I have read that you can use reflection instead of "new" to create a new instance, though I'm concerned about the speed of performing this instantiation.

What is the correct way to resolve this situation? Is there a simpler solution that I'm completely overlooking?

Answer 1

You can't provide an interface there. class and new require it to be a constructable reference type.

Answer 2

Interfaces can only implement other interfaces.

interface IA : IB, IC
{
    ...
}

A good way to solve your dilemma is to introduce a factory interface as well.

interface IThing
{
    ...
}

interface IThingFactory
{
    IThing Create();
}

Now anything that wants to have the ability to create things should receive an IThingFactory for that purpose.

If you need a generic concept of a factory, you could use something like this:

interface IFactory<T>
{
    T Create();
}

class ObjectPool<T, F>
    where T : IRecyclable        
    where F : IFactory<T>
{
    public ObjectPool(F factory)
    {
        ...
    }
}

Answer 3

You cannot construct an ObjectPool<ISomeInterface> . You could have a generic type MyClass<TT> where T:class,ISomeInterface,new() declare an ObjectPool<TT> within it, and then later on declare variables of type MyClass<SomeClassWhichImplementsISomeInterfaceAndHasADefaultConstructor> , but the compiler can only execute methods for ObjectPool<T> when T is of a particular known class type which meets all the constraints.

Alternatively, you could omit the new constraint and then require that any code which constructs an ObjectPool<T> must pass the constructor (or other method that creates the instance) a Func<T> . That would make it possible to create an ObjectPool<ISomeInterface> provided that one had a method which, when called, would return a new object of some suitable type that implemented ISomeInterface .