Interface defining a constructor signature?

Question

It's weird that this is the first time I've bumped into this problem, but:

How do you define a constructor in a C# interface?

--Edit--
Some people wanted an example (it's a free time project, so yes, it's a game)

IDrawable
+Update
+Draw

To be able to Update (check for edge of screen etc) and draw itself it will always need a GraphicsDeviceManager. So I want to make sure the object has a reference to it. This would belong in the constructor.

Now that I wrote this down I think what I'm implementing here is IObservable and the GraphicsDeviceManager should take the IDrawable... It seems either I don't get the XNA framework, or the framework is not thought out verry well.

--Edit--
There seems to be some confusion about my defenition of constructor in the context of an interface. An interface can indeed not be instantiated so doesn't need a constructor. What I wanted to define was a signature to a constructor. Exactly like an interface can define a signature of a certain method, the interface could define the signature of a constructor.

Answer 1

You can't. It's occasionally a pain, but you wouldn't be able to call it using normal techniques anyway.

In a blog post I've suggested static interfaces which would only be usable in generic type constraints - but could be really handy, IMO.

One point about if you could define a constructor within an interface, you'd have trouble deriving classes:

public class Foo : IParameterlessConstructor
{
    public Foo() // As per the interface
    {
    }
}

public class Bar : Foo
{
    // Yikes! We now don't have a parameterless constructor...
    public Bar(int x)
    {
    }
}

Answer 2

You can't.

Interfaces define contracts that other objects implement and therefore have no state that needs to be initialized.

If you have some state that needs to be initialized, you should consider using an abstract base class instead.

Answer 3

What would you need a constructor in an interface for?
Since it cannot be instanciated, it wouldn't be called, would it?

Answer 4

you don't.

the constructor is part of the class that can implement an interface. The interface is just a contract of methods the class must implement.

Answer 5

It is not possible to create an interface that defines constructors, but it is possible to define an interface that forces a type to have a paramerterless constructor, though be it a very ugly syntax that uses generics... I am actually not so sure that it is really a good coding pattern.

public interface IFoo<T> where T : new()
{
  void SomeMethod();
}

public class Foo : IFoo<Foo>
{
  // This will not compile
  public Foo(int x)
  {

  }

  #region ITest<Test> Members

  public void SomeMethod()
  {
    throw new NotImplementedException();
  }

  #endregion
}

On the other hand, if you want to test if a type has a paramerterless constructor, you can do that using reflection:

public static class TypeHelper
{
  public static bool HasParameterlessConstructor(Object o)
  {
    return HasParameterlessConstructor(o.GetType());
  }

  public static bool HasParameterlessConstructor(Type t)
  {
    // Usage: HasParameterlessConstructor(typeof(SomeType))
    return t.GetConstructor(new Type[0]) != null;
  }
}

Hope this helps.

Answer 6

Add a static factory method to your interface.

interface DoesThings
{
    public static doesThings MakeAThingDoer(int numberOfTimes);
    public static void DoThatThing();
}

class TextPrinter : DoesThings
{
    private int numberOfTimes;
    private string whatToPrint;

    private TextPrinter(int numberOfTimes, string whatToPrint)
    {
        this.numberOfTimes = numberOfTimes;
        this.whatToPrint = whatToPrint;
    }

    public MakeAThingDoer(int numberOfTimes)
    {
        return new TextPrinter(numberOfTimes, "Foo Bar Cheese");
    }

    public void DoThatThing()
    {
        for(int i = 0; i < numberOfTimes; i++)
        {
            Console.writeLine(whatToPrint);
        }
    }
}

As you can see, object creation is part of the interface without dictating to the implementation how that creation will occur.

DoesThings baz = TextPrinter.MakeAThingDoer(5);
baz.DoThatThing();

You can go one step further by using a factory class to create the right kind of DoesThing object at runtime based on execution conditions.