Pourquoi les classes statiques ne peuvent-elles pas implémenter des interfaces?

Duplication possible:
Pourquoi C # n’autorise-t-il pas les méthodes statiques à implémenter une interface?

Dans mon application, je souhaite utiliser un référentiel qui permettra d’accéder aux données brutes (TestRepository, SqlRepository, FlatFileRepository, etc.). Comme un tel référentiel serait utilisé tout au long de l’exécution de mon application, il me semblait judicieux d’en faire une classe statique pour que je puisse y aller.

SqlRepository.GetTheThingById(5); 

sans avoir à se régénérer tout le temps. Parce que je veux que mes référentiels soient interchangeables, je leur demande d’implémenter une interface commune: IRepository. Mais quand j’essaie de le faire, je reçois

 "Static classes cannot implement interfaces" 

Pourquoi ne peuvent-ils pas? Comment suggérez-vous que je change de design alors? Y a-t-il un modèle que je pourrais utiliser?

METTRE À JOUR
Cinq ans plus tard: cette question a été visitée plus de 20 fois, j’ai appris les inconvénients du modèle de repository, appris à propos de l’IoC et réalisé que ma question était mal formulée.

Je ne demandais pas vraiment quelle est la spécification C # d’une interface, mais plutôt pourquoi elle me limitait délibérément de cette manière.

La réponse pratique est que la syntaxe pour appeler une méthode sur une instance ou sur un type est différente. Mais la question est close

Les interfaces ne peuvent pas avoir de méthodes statiques. Une classe qui implémente une interface doit les implémenter toutes en tant que méthodes d’instance. Les classes statiques ne peuvent pas avoir de méthodes d’instance. QED.

Peut-être que notre expérience aidera. Plutôt que SqlRepository en tant que classe statique, nous utilisons AutoFac pour l’injection et masquons le conteneur derrière une classe statique. Ensuite, chaque entité possède une propriété de référentiel statique:

 public class Part : inheritence... { public static IPartRepository Repository { get { return IoCContainer.GetInstance>(); } } // ... more part-y stuff } 

De cette façon, nous pouvons échanger l’implémentation et les appelants savent toujours où l’obtenir:

 Part p = Part.Repository.Get(id); 

Dans un autre projet, il y a un PartRepository enregistré avec le conteneur:

 public class PartRepository : IPartRepository { // IPartRepository implementation that talks to injected DAL } 

Dans un autre projet, nous avons des simulacres pour les tests, y compris des référentiels pré-chargés avec des entités connues:

 public class MockPartRepository : Dictionary, IPartRepository { // IPartRepository implementation based on dictionary } 

… et il est enregistré avec le conteneur pour les tests unitaires. L’appel SAME obtient le référentiel:

 Part p = Part.Repository.Get(id); 

Par définition, les interfaces créent un contrat pour les instances à remplir. Comme vous ne pouvez pas instancier une classe statique, les classes statiques ne peuvent pas implémenter les interfaces.

Il n’est pas nécessaire d’avoir un référentiel statique. Simplement le rendre non statique et l’instancier quand vous en avez besoin.