Comment puis-je utiliser l'interface comme un C# de type générique de contrainte?

Je sais c'est un peu tard, mais pour ceux qui sont intéressés, vous pouvez utiliser un moment de l'exécution.

typeof(T).IsInterface

De suivi sur Robert réponse, c'est encore plus tard, mais vous pouvez utiliser une statique de la classe helper pour rendre le moment de l'exécution qu'une seule fois par type:

public bool Foo<T>() where T : class
{
    FooHelper<T>.Foo();
}

private static class FooHelper<TInterface> where TInterface : class
{
    static FooHelper()
    {
        if (!typeof(TInterface).IsInterface)
            throw //... some exception
    }
    public static void Foo() { /*...*/ }
}

Je note aussi que votre "doit travailler" la solution n'est pas, en effet, le travail. Considérer:

public bool Foo<T>() where T : IBase;
public interface IBase { }
public interface IActual : IBase { string S { get; } }
public class Actual : IActual { public string S { get; set; } }

Maintenant il n'y a rien qui vous empêche d'appeler Foo ainsi:

Foo<Actual>();

La Actual classe, après tout, s'il satisfait à la IBase contrainte.

Si possible, je suis allé avec une solution de ce genre. Il ne fonctionne que si vous voulez plusieurs interfaces spécifiques (par exemple, ceux que vous avez accès à la source d') pour être transmis en tant que paramètre générique, pas du tout.

• Je laisse mes interfaces, qui est entré en question, hériter d'une interface vide IInterface.
• J'ai limité le générique du paramètre T de IInterface

Dans la source, il ressemble à ceci:

• N'importe quelle interface vous voulez être transmis en tant que paramètre générique:

  public interface IWhatever : IInterface
  {
      //IWhatever specific declarations
  }

• IInterface:

  public interface IInterface
  {
      //Nothing in here, keep moving
  }

• La classe sur laquelle vous souhaitez placer une contrainte de type:

  public class WorldPeaceGenerator<T> where T : IInterface
  {
      //Actual world peace generating code
  }

J'ai essayé de faire quelque chose de similaire et utilisé une solution de rechange: j'y ai pensé implicite et explicite de l'opérateur sur la structure: L'idée est d'envelopper le Type de structure qui peut être converti en Type de données implicitement.

Ici est d'une telle structure:

public struct InterfaceType
{
Type privé _type;

public InterfaceType(Type type)
{
    CheckType(type);
    _type = type;
}

public static explicit operator Type(InterfaceType value)
{
    return value._type;
}

public static implicit operator InterfaceType(Type type)
{
    return new InterfaceType(type);
}

private static void CheckType(Type type)
{
    if (type == null) throw new NullReferenceException("The type cannot be null");
    if (!type.IsInterface) throw new NotSupportedException(string.Format("The given type {0} is not an interface, thus is not supported", type.Name));
}

}

d'utilisation de base:

//OK
InterfaceType type1 = typeof(System.ComponentModel.INotifyPropertyChanged);

//Throws an exception
InterfaceType type2 = typeof(WeakReference);

Vous devez imaginer votre propre mécanisme de contourner cela, mais, par exemple, pourrait être une méthode pris un InterfaceType en paramètre à la place d'un type

this.MyMethod(typeof(IMyType)) //works
this.MyMethod(typeof(MyType)) //throws exception

Une méthode pour remplacer la qui devrait retourne types d'interface:

public virtual IEnumerable<InterfaceType> GetInterfaces()

Il y a peut-être des choses à faire avec les génériques, mais je n'ai pas essayé

Espère que cela peut vous aider ou donne des idées 🙂