Classe anônima pode implementar interface?

É possível que um tipo anônimo implemente uma interface?

Eu tenho um pedaço de código que gostaria de trabalhar, mas não sei como fazer isso.

Eu tive algumas respostas que dizem não ou criam uma classe que implementa a interface para construir novas instâncias disso. Isso não é realmente ideal, mas estou me perguntando se existe um mecanismo para criar uma classe dinâmica fina em cima de uma interface que tornaria isso simples.

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

Encontrei um artigo Encapsulamento de interface dinâmica que descreve uma abordagem. Essa é a melhor maneira de fazer isso?

Não, tipos anônimos não podem implementar uma interface. No guia de programação em C # :

Tipos anônimos são tipos de classe que consistem em uma ou mais propriedades públicas somente leitura. Nenhum outro tipo de membro da classe, como métodos ou eventos, é permitido. Um tipo anônimo não pode ser convertido para nenhuma interface ou tipo, exceto para o objeto.

Embora essa possa ser uma pergunta de dois anos e, embora as respostas no tópico sejam todas verdadeiras, não resisto à tentação de dizer que é realmente possível que uma classe anônima implemente uma interface, mesmo que seja necessário um pouco de trapaça criativa para chegar lá.

Em 2008, eu estava escrevendo um provedor LINQ personalizado para o meu então empregador e, em um determinado momento, eu precisava ser capaz de diferenciar "minhas" classes anônimas de outras classes anônimas, o que significava que elas implementassem uma interface que eu poderia usar para digitar check eles. A maneira como resolvemos isso foi usando aspectos (usamos PostSharp ), para adicionar a implementação da interface diretamente na IL. Então, de fato, é possível permitir que classes anônimas implementem interfaces , você só precisa dobrar as regras um pouco para chegar lá.

A conversão de tipos anônimos para interfaces é algo que eu queria há algum tempo, mas infelizmente a implementação atual obriga a uma implementação dessa interface.

A melhor solução para isso é ter algum tipo de proxy dinâmico que crie a implementação para você. Usando o excelente projeto LinFu, você pode substituir

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

com

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

Tipos anônimos podem implementar interfaces por meio de um proxy dinâmico.

Eu escrevi um método de extensão no GitHub e uma postagem no blog http://wblo.gs/feE para suportar esse cenário.

O método pode ser usado assim:

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

Não; um tipo anônimo não pode ser feito para fazer nada, exceto ter algumas propriedades. Você precisará criar seu próprio tipo. Não li o artigo vinculado em profundidade, mas parece que ele usa o Reflection.Emit para criar novos tipos em tempo real; mas se você limitar a discussão a coisas no próprio C #, não poderá fazer o que deseja.

A melhor solução é simplesmente não usar classes 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);
        }
    }
}

Observe que você precisa converter o resultado da consulta no tipo de interface. Pode haver uma maneira melhor de fazê-lo, mas não consegui encontrá-lo.

A resposta para a pergunta especificamente feita é não. Mas você está olhando estruturas de zombaria? Uso MOQ, mas existem milhões por aí e eles permitem que você implemente / stub (parcialmente ou totalmente) interfaces em linha. Por exemplo.

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

Outra opção é criar uma classe de implementação única e concreta que aceite lambdas no construtor.

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

Se tudo o que você vai fazer é converter DummySourcepara DummyInterface, seria mais simples ter apenas uma classe que pega um DummySourceno construtor e implementa a interface.

Mas, se você precisar converter vários tipos para DummyInterface, isso é muito menos placa de caldeira.