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

Question

Existe-t-il un moyen d'obtenir la déclaration de fonction suivante ?

public bool Foo<T>() where T : interface;

c'est-à-dire où T est un type d'interface (similaire à where T : class et struct ).

Actuellement, je me suis contenté de :

public bool Foo<T>() where T : IBase;

Où IBase est définie comme une interface vide qui est héritée par toutes mes interfaces personnalisées... Pas idéal, mais cela devrait fonctionner... Pourquoi ne pouvez-vous pas définir qu'un type générique doit être une interface ?

Pour ce que ça vaut, je veux ça parce que Foo fait de la réflexion où il a besoin d'un type d'interface... Je pourrais le passer en tant que paramètre normal et faire les vérifications nécessaires dans la fonction elle-même, mais ceci semblait beaucoup plus sûr (et je suppose un peu plus performant, puisque toutes les vérifications sont faites au moment de la compilation).

Answer 1

Le plus proche que vous puissiez faire (sauf pour votre approche de l'interface de base) est " where T : class ", qui signifie type de référence. Il n'existe pas de syntaxe pour signifier "toute interface".

Cette (" where T : class ") est utilisé, par exemple, dans WCF pour limiter les clients aux contrats de service (interfaces).

Answer 2

Je sais que c'est un peu tard mais pour ceux qui sont intéressés, vous pouvez utiliser un contrôle d'exécution.

typeof(T).IsInterface

Answer 3

Non, en fait, si vous pensez class et struct moyenne class es et struct s, vous avez tort. class signifie tout type de référence (qui comprend également les interfaces) et struct signifie tout type de valeur (par exemple struct , enum ).

Answer 4

Pour faire suite à la réponse de Robert, c'est encore plus tard, mais vous pouvez utiliser une classe d'aide statique pour que le runtime ne vérifie 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 également que votre solution "devrait fonctionner" ne fonctionne pas, en fait. Considérez :

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, rien ne vous empêche d'appeler Foo ainsi :

Foo<Actual>();

Le site Actual après tout, la classe satisfait à l'exigence IBase contrainte.

Answer 5

Vous ne pouvez pas le faire dans les versions publiées de C#, ni dans la future version 4.0 de C#. Ce n'est pas non plus une limitation de C# - il n'y a pas de contrainte d'"interface" dans le CLR lui-même.