¿Puede la clase anónima implementar la interfaz?

¿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 existe un mecanismo para crear una clase dinámica delgada en la parte superior de 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);
        }
    }
}

Encontré un artículo Ajuste dinámico de interfaz que describe un enfoque. ¿Es esta la mejor manera de hacer esto?

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 consisten en una o más propiedades públicas de solo lectura. No se permiten otros tipos de miembros de la clase, como métodos o eventos. Un tipo anónimo no se puede convertir a ninguna interfaz o tipo, excepto por objeto.

Si bien esta podría ser una pregunta de dos años, y aunque las respuestas en el hilo son todas lo suficientemente verdaderas, no puedo resistir la tentación de decirte que, de hecho, es posible que una clase anónima implemente una interfaz, a pesar de que requiere Un poco de trampa creativa para llegar allí.

En 2008, estaba escribiendo un proveedor LINQ personalizado para mi empleador en ese momento, y en un momento tenía que poder distinguir "mis" clases anónimas de otras anónimas, lo que significaba que implementaran una interfaz que podría usar para escribir cheque ellos. 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, permitir que las clases anónimas implementen interfaces es factible , solo necesita doblar ligeramente las reglas para llegar allí.

La conversión de tipos anónimos a las interfaces ha sido algo que he deseado durante un tiempo, pero desafortunadamente la implementación actual lo obliga a tener una implementación de esa interfaz.

La mejor solución es tener algún tipo de proxy dinámico que cree la implementación para usted. Usando el excelente proyecto LinFu 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>();

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 respaldar este escenario.

El método se puede usar así:

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

No; No se puede hacer que un tipo anónimo haga nada excepto tener algunas propiedades. Deberá crear su propio tipo. No leí el artículo vinculado en profundidad, pero parece que usa 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.

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.

La respuesta a la pregunta específicamente formulada es no. ¿Pero has estado buscando marcos burlones? Uso MOQ, pero hay millones de ellos 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);
}

Otra opción es crear una única clase de implementación concreta que tome lambdas en el constructor.

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

// "Generic" implementing class
public class Dummy : DummyInterface
{
    private readonly Func<string> _getA;
    private readonly Func<string> _getB;

    public Dummy(Func<string> getA, Func<string> getB)
    {
        _getA = getA;
        _getB = getB;
    }

    public string A => _getA();

    public string B => _getB();
}

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 Dummy // Syntax changes slightly
                     (
                         getA: () => value.A,
                         getB: () => 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);
        }
    }
}

Si todo lo que son cada vez va a hacer es convertir DummySourcea DummyInterface, entonces sería más fácil tener sólo una clase que toma una DummySourceen el constructor e implementa la interfaz.

Pero, si necesita convertir muchos tipos DummyInterface, esto es mucho menos placa de caldera.