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

Question

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

He recibido un par de respuestas que dicen que no, o crean una clase que implementa la interfaz crea nuevas instancias de eso. Esto no es realmente ideal, pero me pregunto si existe un mecanismo para crear una clase dinámica delgada sobre una interfaz que lo haga 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 Dynamic interface wrapping que describe un enfoque. ¿Es esta la mejor manera de hacer esto?

Answer 1

No, los tipos anónimos no pueden implementar una interfaz. Desde C# programming guide:

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

Answer 2

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

Answer 3

La mejor solución es simplemente no utilizar 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 enviar el resultado de la consulta al tipo de interfaz. Puede haber una forma mejor de hacerlo, pero no pude encontrarlo.

Answer 4

Lanzar tipos anónimos a las interfaces ha sido algo que he querido por un tiempo, pero lamentablemente la implementación actual te obliga a tener una implementación de esa interfaz.

La mejor solución al respecto es tener algún tipo de proxy dinámico que crea la implementación para usted. El uso de la excelente LinFu project puede 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 5

Si bien esto puede ser una cuestión de dos años, y si bien las respuestas en el hilo son lo suficientemente todo es verdad, no puede resistir el impulso de le digo que de hecho es posible tener una clase anónima para implementar una interfaz, aunque se necesita un poco de trampa creativa para llegar allí.

Ya en 2008 escribía un proveedor de LINQ personalizado para mi empleador, y en un momento tuve que poder decirle a "mi" clase anónima de otras anónimas, lo que significaba tener que implementar una interfaz que pudiera use para tipearlos. La forma en que lo resolvimos fue mediante el uso de aspectos (utilizamos PostSharp), para agregar la implementación de la interfaz directamente en el IL. Entonces, de hecho, permitiendo que las clases anónimas implementen interfaces es posible, solo necesita doblar las reglas ligeramente para llegar allí.

Answer 6

La respuesta a la pregunta específicamente formulada es no.¿Pero has estado mirando estructuras burlonas? Yo uso MOQ pero hay millones de ellos por ahí y te permiten implementar/stub (parcial o totalmente) 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 7

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 puede ser utilizado 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; } 
}