Interface définissant une signature de constructeur?

Question

Il est bizarre que ce soit la première fois que je me heurte à ce problème, mais:

Comment définissez-vous un constructeur dans une interface C#?

Éditer
Certains voulaient un exemple (c'est un projet de temps libre, donc oui, c'est un jeu)

IDrawable
+Update
+Draw

Pour pouvoir se mettre à jour (vérifier les bords de l'écran, etc.) et se dessiner, il aura toujours besoin d'un GraphicsDeviceManager. Je veux donc m'assurer que l'objet a une référence à celui-ci. Cela devrait être dans le constructeur.

Maintenant que j'ai écrit cela, je pense que ce que j'implémente ici est IObservable et le GraphicsDeviceManager devrait prendre le IDrawable... Il semble soit que je ne comprenne pas le framework XNA, soit que le framework ne soit pas très bien pensé.

Éditer
Il semble y avoir une certaine confusion concernant ma définition de constructeur dans le contexte d'une interface. Une interface ne peut en effet pas être instanciée et n'a donc pas besoin d'un constructeur. Ce que je voulais définir était en fait une signature de constructeur. Exactement comme une interface peut définir la signature d'une méthode spécifique, l'interface pourrait définir la signature d'un constructeur.

Answer 1

Vous ne pouvez pas. C'est parfois une douleur, mais de toute façon vous ne seriez pas en mesure de l'appeler en utilisant des techniques normales.

Dans un article de blog, j'ai suggéré interfaces statiques qui ne pourraient être utilisées que dans des contraintes de types génériques - mais pourraient être vraiment utiles, à mon avis.

Un point à propos si vous pouviez définir un constructeur dans une interface, vous auriez des difficultés à dériver des classes:

public class Foo : IParameterlessConstructor
{
    public Foo() // Selon l'interface
    {
    }
}

public class Bar : Foo
{
    // Aïe! Nous n'avons plus de constructeur sans paramètre...
    public Bar(int x)
    {
    }
}

Answer 2

Une contribution très tardive démontrant un autre problème avec les constructeurs interférés. (J'ai choisi cette question car elle a la meilleure articulation du problème). Supposons que nous puissions avoir:

interface IPerson
{
    IPerson(string name);
}

interface ICustomer
{
    ICustomer(DateTime registrationDate);
}

class Person : IPerson, ICustomer
{
    Person(string name) { }
    Person(DateTime registrationDate) { }
}

Où, par convention, l'implémentation du "constructeur d'interface" est remplacée par le nom du type.

Maintenant, créons une instance:

ICustomer a = new Person("Ernie");

Pouvons-nous dire que le contrat ICustomer est respecté?

Et qu'en est-il de ceci:

interface ICustomer
{
    ICustomer(string address);
}

Answer 3

Vous ne pouvez pas.

Les interfaces définissent des contrats que d'autres objets implémentent et n'ont donc pas d'état à initialiser.

Si vous avez un état à initialiser, vous devriez envisager d'utiliser une classe de base abstraite à la place.

Answer 4

J'ai relu cette question et je me suis dit, peut-être que nous abordons ce problème de la mauvaise manière. Les interfaces pourraient ne pas être la bonne solution lorsqu'il s'agit de définir un constructeur avec certains paramètres... mais une classe de base (abstraite) l'est.

Si vous créez une classe de base avec un constructeur qui accepte les paramètres dont vous avez besoin, chaque classe qui en hérite doit les fournir.

public abstract class Foo
{
  protected Foo(SomeParameter x)
  {
    this.X = x;
  }

  public SomeParameter X { get; private set }
}

public class Bar : Foo // Bar hérite de Foo
{
  public Bar() 
    : base(new SomeParameter("etc...")) // Bar devra fournir le paramètre du constructeur
  {
  }
}

Answer 5

Il n'est pas possible de créer une interface qui définit des constructeurs, mais il est possible de définir une interface qui force un type à avoir un constructeur sans paramètre, bien que ce soit une syntaxe très laide qui utilise des génériques... Je ne suis pas vraiment sûr que ce soit un bon modèle de codage.

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

public class Foo : IFoo
{
  // Ceci ne compilera pas
  public Foo(int x)
  {

  }

  #region ITest Members

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

  #endregion
}

D'autre part, si vous voulez tester si un type a un constructeur sans paramètre, vous pouvez le faire en utilisant la réflexion :

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

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

J'espère que cela vous aidera.