implementacion - ¿Puede una clase anónima de C#implementar una interfaz?

declaracion de interfaces c#

Question

¿Es posible que un tipo anónimo implemente una interfaz? Tengo un código que me gustaría trabajar, pero no sé cómo hacerlo.

He tenido un par de respuestas que dicen no, o crean una clase que implementa la interfaz para construir nuevas instancias de eso. Esto no es realmente ideal, pero me pregunto si hay un mecanismo para crear una clase dinámica delgada en la parte superior de una interfaz que haría esto simple.

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);
        }
    }
}

He encontrado un artículo Envoltura de interfaz dinámica que describe un enfoque. ¿Es esta la mejor manera de hacer esto?

Answer 1

Convertir tipos anónimos en interfaces ha sido algo que he querido durante un tiempo, pero desafortunadamente la implementación actual te obliga a tener una implementación de esa interfaz.

La mejor solución a su alrededor es tener algún tipo de proxy dinámico que cree la implementación para usted. Usando el excelente proyecto LinFu puedes reemplazar

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 2

La mejor solución es simplemente no usar clases anónimas.

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);
        }
    }
}

Tenga en cuenta que debe convertir el resultado de la consulta al tipo de interfaz. Puede haber una mejor manera de hacerlo, pero no pude encontrarlo.

Answer 3

La respuesta a la pregunta formulada específicamente es no. ¿Pero has estado mirando a los marcos burlones? Utilizo MOQ pero hay millones de ellos y te permiten implementar / stub (parcial o totalmente) las interfaces en línea. P.ej.

public void ThisWillWork()
{
    var source = new DummySource[0];
    var mock = new Mock<DummyInterface>();

    mock.SetupProperty(m => m.A, source.Select(s => s.A));
    mock.SetupProperty(m => m.B, source.Select(s => s.C + "_" + s.D));

    DoSomethingWithDummyInterface(mock.Object);
}

Answer 4

Los tipos anónimos pueden implementar interfaces a través de un proxy dinámico.

Escribí un método de extensión en GitHub y una publicación de blog http://wblo.gs/feE para admitir este escenario.

El método se puede utilizar de esta manera:

class Program
{
    static void Main(string[] args)
    {
        var developer = new { Name = "Jason Bowers" };

        PrintDeveloperName(developer.DuckCast<IDeveloper>());

        Console.ReadKey();
    }

    private static void PrintDeveloperName(IDeveloper developer)
    {
        Console.WriteLine(developer.Name);
    }
}

public interface IDeveloper
{
    string Name { get; }
}

Answer 5

No, los tipos anónimos no pueden implementar una interfaz. De la guía de programación de C # :

Los tipos anónimos son tipos de clase que constan de una o más propiedades públicas de solo lectura. No se permiten otros tipos de miembros de clase, tales como métodos o eventos. Un tipo anónimo no se puede convertir a ninguna interfaz o tipo, excepto para el objeto.

Answer 6

No; no se puede hacer que un tipo anónimo haga nada, excepto tener algunas propiedades. Necesitará crear su propio tipo. No leí el artículo vinculado en profundidad, pero parece que utiliza Reflection.Emit para crear nuevos tipos sobre la marcha; pero si limita la discusión a las cosas dentro de C #, no puede hacer lo que quiere.

Answer 7

Si bien esta puede ser una pregunta de dos años, y si bien las respuestas en el hilo son lo suficientemente ciertas, no puedo resistir la tentación de decirle que, de hecho, es posible que una clase anónima implemente una interfaz, aunque se necesita una Un poco de trampa creativa para llegar allí.

En el 2008, estaba escribiendo un proveedor LINQ personalizado para mi entonces empleador, y en un momento tuve que ser capaz de decir "mis" clases anónimas de otras clases anónimas, lo que significaba que implementaran una interfaz que podría usar para la verificación de tipo ellos. La forma en que lo resolvimos fue mediante el uso de aspectos (usamos PostSharp ), para agregar la implementación de la interfaz directamente en el IL. Entonces, de hecho, permitir que las clases anónimas implementen interfaces es factible , solo necesita doblar las reglas ligeramente para llegar allí.