É 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?
c#
anonymous-types
Nick Randell
fonte
fonte
Respostas:
Não, tipos anônimos não podem implementar uma interface. No guia de programação em C # :
fonte
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á.
fonte
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
com
fonte
DynamicObject
tipo LinFu?System.Dynamic.DynamicObject
possui apenas um construtor protegido (pelo menos no .NET 4.5).DynamicObject
que antecede a versão DLRTipos 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:
fonte
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.
fonte
A melhor solução é simplesmente não usar classes anônimas.
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.
fonte
values.OfType<IDummyInterface>()
vez de transmitir. Ele retorna apenas os objetos em sua coleção que realmente podem ser convertidos para esse tipo. Tudo depende do que você quer.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.
fonte
Outra opção é criar uma classe de implementação única e concreta que aceite lambdas no construtor.
Se tudo o que você vai fazer é converter
DummySource
paraDummyInterface
, seria mais simples ter apenas uma classe que pega umDummySource
no construtor e implementa a interface.Mas, se você precisar converter vários tipos para
DummyInterface
, isso é muito menos placa de caldeira.fonte