Une classe anonyme peut-elle implémenter une interface ?

Question

Est-il possible de faire en sorte qu'un type anonyme implémente une interface ?

J'ai un morceau de code que j'aimerais faire fonctionner, mais je ne sais pas comment m'y prendre.

J'ai eu quelques réponses qui disaient soit non, soit créer une classe qui implémente l'interface et construire de nouvelles instances de celle-ci. Ce n'est pas vraiment l'idéal, mais je me demande s'il existe un mécanisme permettant de créer une classe dynamique fine au-dessus d'une interface, ce qui simplifierait les choses.

public interface DummyInterface
{
    string A { get; }
    string B { get; }
}

public class DummySource
{
    public string A { get; set; }
    public string C { get; set; }
    public string D { get; set; }
}

public class Test
{
    public void WillThisWork()
    {
        var source = new DummySource[0];
        var values = from value in source
                     select new
                     {
                         A = value.A,
                         B = value.C + "_" + value.D
                     };

        DoSomethingWithDummyInterface(values);

    }

    public void DoSomethingWithDummyInterface(IEnumerable<DummyInterface> values)
    {
        foreach (var value in values)
        {
            Console.WriteLine("A = '{0}', B = '{1}'", value.A, value.B);
        }
    }
}

J'ai trouvé un article Habillage dynamique des interfaces qui décrit une approche. Est-ce la meilleure façon de procéder ?

Answer 1

Non, les types anonymes ne peuvent pas implémenter une interface. D'après le Guide de programmation C# :

Les types anonymes sont des types de classe qui consistent en une ou plusieurs propriétés publiques en lecture seule. Aucun autre type de membre de classe, comme les méthodes ou les événements, n'est autorisé. Un type anonyme ne peut être converti en aucune interface ni aucun type, à l'exception de l'objet.

Answer 2

Bien que les réponses données dans le fil de discussion soient toutes vraies, je ne peux résister à l'envie de vous dire qu'en fait est possible pour qu'une classe anonyme implémente une interface, même s'il faut un peu de tricherie créative pour y parvenir.

En 2008, j'écrivais un fournisseur LINQ personnalisé pour mon employeur de l'époque et, à un moment donné, j'ai eu besoin de pouvoir distinguer "mes" classes anonymes d'autres classes anonymes, ce qui signifiait qu'elles devaient implémenter une interface que je pouvais utiliser pour vérifier leur type. La façon dont nous avons résolu ce problème était d'utiliser des aspects (nous avons utilisé PostSharp ), pour ajouter l'implémentation de l'interface directement dans l'IL. Donc, en fait, laisser des classes anonymes implémenter des interfaces est faisable vous devez juste contourner les règles un peu pour y arriver.

Answer 3

Le transfert de types anonymes vers des interfaces est quelque chose que j'ai voulu depuis un certain temps, mais malheureusement, l'implémentation actuelle vous oblige à avoir une implémentation de cette interface.

La meilleure solution est d'avoir un type de proxy dynamique qui crée l'implémentation pour vous. En utilisant l'excellent Projet LinFu vous pouvez remplacer

select new
{
  A = value.A,
  B = value.C + "_" + value.D
};

con

 select new DynamicObject(new
 {
   A = value.A,
   B = value.C + "_" + value.D
 }).CreateDuck<DummyInterface>();

Answer 4

Non, un type anonyme ne peut rien faire d'autre que d'avoir quelques propriétés. Vous devez créer votre propre type. Je n'ai pas lu l'article en question en profondeur, mais il semble qu'il utilise Reflection.Emit pour créer de nouveaux types à la volée ; mais si vous limitez la discussion aux éléments suivants au sein même de C# tu ne peux pas faire ce que tu veux.

Answer 5

La meilleure solution est tout simplement de ne pas utiliser de classes anonymes.

public class Test
{
    class DummyInterfaceImplementor : IDummyInterface
    {
        public string A { get; set; }
        public string B { get; set; }
    }

    public void WillThisWork()
    {
        var source = new DummySource[0];
        var values = from value in source
                     select new DummyInterfaceImplementor()
                     {
                         A = value.A,
                         B = value.C + "_" + value.D
                     };

        DoSomethingWithDummyInterface(values.Cast<IDummyInterface>());

    }

    public void DoSomethingWithDummyInterface(IEnumerable<IDummyInterface> values)
    {
        foreach (var value in values)
        {
            Console.WriteLine("A = '{0}', B = '{1}'", value.A, value.B);
        }
    }
}

Notez que vous devez convertir le résultat de la requête en type d'interface. Il existe peut-être un meilleur moyen de le faire, mais je ne l'ai pas trouvé.