Tenho uma consulta que retorna um tipo anônimo e a consulta está em um método. Como você escreve isso:
public "TheAnonymousType" TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new { SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return "TheAnonymousType";
}
}
c#
.net
anonymous-types
return-type
francês
fonte
fonte
Respostas:
Você não pode.
Você só pode voltar
object
, ou recipiente de objetos, por exemploIEnumerable<object>
,IList<object>
, etc.fonte
dynamic
. Isso torna um pouco mais fácil de trabalhar.Você pode retornar, o
dynamic
que lhe dará uma versão verificada em tempo de execução do tipo anônimo, mas apenas no .NET 4+fonte
No C # 7, podemos usar tuplas para fazer isso:
Você pode precisar instalar o
System.ValueTuple
pacote nuget.fonte
Você não pode retornar tipos anônimos. Você pode criar um modelo que pode ser devolvido? Caso contrário, você deve usar um
object
.Aqui está um artigo escrito por Jon Skeet sobre o assunto
Código do artigo:
Ou, aqui está outro artigo semelhante
Ou, como outras pessoas estão comentando, você pode usar
dynamic
fonte
Você pode usar a classe Tuple como um substituto para tipos anônimos quando o retorno for necessário:
Nota: Tupla pode ter até 8 parâmetros.
Ou, para o exemplo da postagem original:
http://msdn.microsoft.com/en-us/library/system.tuple(v=vs.110).aspx
fonte
O compilador C # é um compilador de duas fases. Na primeira fase, ele apenas verifica os namespaces, hierarquias de classes, assinaturas de métodos, etc. Os corpos dos métodos são compilados apenas durante a segunda fase.
Tipos anônimos não são determinados até que o corpo do método seja compilado.
Portanto, o compilador não tem como determinar o tipo de retorno do método durante a primeira fase.
Essa é a razão pela qual os tipos anônimos não podem ser usados como tipo de retorno.
Como outros sugeriram, se você estiver usando .net 4.0 ou ralador, você pode usar
Dynamic
.Se eu fosse você, provavelmente criaria um tipo e retornaria esse tipo do método. Dessa forma, é fácil para os futuros programadores que mantêm seu código e mais legível.
fonte
Três opções:
Opção 1:
Opção 2:
você pode iterá-lo como um objeto
Opção 3:
e você poderá iterá-lo como um objeto dinâmico e acessar suas propriedades diretamente
fonte
Você pode retornar uma lista de objetos neste caso.
fonte
Usando o C # 7.0 , ainda não podemos retornar tipos anônimos, mas temos suporte para tipos de tupla e, portanto, podemos retornar uma coleção de
tuple
(System.ValueTuple<T1,T2>
neste caso). AtualmenteTuple types
não são suportados em árvores de expressão e você precisa carregar dados na memória.A versão mais curta do código que você deseja pode ter a seguinte aparência:
Ou usando a sintaxe fluente do Linq:
Usando C # 7.1 , podemos omitir nomes de propriedades de tupla e eles serão inferidos da inicialização de tupla como funciona com tipos anônimos:
fonte
Criar sua própria classe e consultá-la é a melhor solução que conheço. Por mais que eu saiba, você não pode usar valores de retorno de tipo anônimo em outro método, porque ele não será apenas reconhecido. No entanto, eles podem ser usados no mesmo método. Eu costumava retorná-los como
IQueryable
ouIEnumerable
, embora ainda não permita que você veja o que está dentro da variável de tipo anônimo.Já encontrei algo assim antes, enquanto tentava refatorar algum código, você pode verificar aqui: Refatorando e criando métodos separados
fonte
Com reflexão.
Amostra:
Resultado:
fonte
Você só pode usar palavras-chave dinâmicas,
Mas com a palavra-chave do tipo dinâmico você perderá a segurança do tempo de compilação, IDE IntelliSense etc ...
fonte
Outra opção poderia ser usar o automapper: você converterá para qualquer tipo de seu objeto retornado anônimo, desde que as propriedades públicas correspondam. Os pontos principais são, retornar objeto, usar linq e autommaper. (ou use uma ideia semelhante retornando json serializado, etc. ou use reflexão ..)
fonte
Agora especialmente com funções locais, mas você sempre pode fazer isso passando um delegado que torna o tipo anônimo.
Portanto, se seu objetivo era executar lógicas diferentes nas mesmas fontes e ser capaz de combinar os resultados em uma única lista. Não tenho certeza de qual nuance está faltando para atingir a meta declarada, mas contanto que você retorne um
T
e passe um delegado para fazerT
, você pode retornar um tipo anônimo de uma função.fonte
Na verdade, é possível retornar um tipo anônimo de um método em um caso de uso específico. Vamos dar uma olhada!
Com C # 7, é possível retornar tipos anônimos de um método, embora venha com uma pequena restrição. Vamos usar um novo recurso de linguagem chamado função local junto com um truque de indireção (outra camada de indireção pode resolver qualquer desafio de programação, certo?).
Aqui está um caso de uso que identifiquei recentemente. Quero registrar todos os valores de configuração depois de carregá-los de
AppSettings
. Por quê? Porque há alguma lógica em torno dos valores ausentes que revertem para os valores padrão, alguma análise e assim por diante. Uma maneira fácil de registrar os valores após aplicar a lógica é colocá-los todos em uma classe e serializá-los em um arquivo de log (usando log4net). Também quero encapsular a lógica complexa de lidar com configurações e separar isso de tudo o que preciso fazer com elas. Tudo sem criar uma classe nomeada que existe apenas para um único uso!Vamos ver como resolver isso usando uma função local que cria um tipo anônimo.
Consegui construir uma classe anônima e também encapsular a lógica de lidar com o gerenciamento de configurações complexas, tudo dentro
CreateHttpClient
e dentro de sua própria "expressão". Isso pode não ser exatamente o que o OP queria, mas é uma abordagem leve com tipos anônimos que atualmente é possível no C # moderno.fonte