我有一个返回匿名类型的查询，查询在方法中。你怎么写的：
public "TheAnonymousType" TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new { SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return "TheAnonymousType";
}
}
你不能。
您只能返回object或对象的容器，例如IEnumerable<object>，IList<object>等
随着反思。
public object tst() {
var a = new {
prop1 = "test1",
prop2 = "test2"
};
return a;
}
public string tst2(object anonymousObject, string propName) {
return anonymousObject.GetType().GetProperties()
.Where(w => w.Name == propName)
.Select(s => s.GetValue(anonymousObject))
.FirstOrDefault().ToString();
}
样品：
object a = tst();
var val = tst2(a, "prop2");
输出：
test2
使用C＃7.0我们仍然无法返回匿名类型，但我们支持元组类型，因此我们可以返回tuple的集合（在本例中为System.ValueTuple<T1,T2>）。
您想要的最短版本的代码可能如下所示：
public List<(int SomeVariable, object AnotherVariable)> TheMethod()
{
...
return (from data in TheDC.Data
select (SomeVariable: data.SomeInt, AnotherVariable: data.SomeObject)
).ToList();
}
或者使用流畅的Linq语法：
return TheDC.Data
.Select(data => (SomeVariable: data.SomeInt, AnotherVariable: data.SomeObject))
.ToList();
使用C＃7.1我们可以省略元组的属性名称，它们将从元组初始化中推断出来，就像它与匿名类型一起使用：
select (data.SomeInt, data.SomeObject)
// or
Select(data => (data.SomeInt, data.SomeObject))
您只能使用动态关键字，
dynamic obj = GetAnonymousType();
Console.WriteLine(obj.Name);
Console.WriteLine(obj.LastName);
Console.WriteLine(obj.Age);
public static dynamic GetAnonymousType()
{
return new { Name = "John", LastName = "Smith", Age=42};
}
但是使用动态类型关键字，您将失去编译时安全性，IDE智能感知等...
另一种选择可能是使用automapper：当长公共属性匹配时，您将从匿名返回的对象转换为任何类型。关键点是，返回对象，使用linq和autommaper。 （或使用类似的想法返回序列化的json等，或使用反射..）
using System.Linq;
using System.Reflection;
using AutoMapper;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;
namespace UnitTestProject1
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
var data = GetData();
var firts = data.First();
var info = firts.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).First(p => p.Name == "Name");
var value = info.GetValue(firts);
Assert.AreEqual(value, "One");
}
[TestMethod]
public void TestMethod2()
{
var data = GetData();
var config = new MapperConfiguration(cfg => cfg.CreateMissingTypeMaps = true);
var mapper = config.CreateMapper();
var users = data.Select(mapper.Map<User>).ToArray();
var firts = users.First();
Assert.AreEqual(firts.Name, "One");
}
[TestMethod]
public void TestMethod3()
{
var data = GetJData();
var users = JsonConvert.DeserializeObject<User[]>(data);
var firts = users.First();
Assert.AreEqual(firts.Name, "One");
}
private object[] GetData()
{
return new[] { new { Id = 1, Name = "One" }, new { Id = 2, Name = "Two" } };
}
private string GetJData()
{
return JsonConvert.SerializeObject(new []{ new { Id = 1, Name = "One" }, new { Id = 2, Name = "Two" } }, Formatting.None);
}
public class User
{
public int Id { get; set; }
public string Name { get; set; }
}
}
}
现在特别使用本地函数，但是你总是可以通过传递一个创建匿名类型的委托来完成它。
因此，如果您的目标是在相同的源上运行不同的逻辑，并能够将结果组合到单个列表中。不确定为了达到既定目标而缺少什么细微差别，但只要你返回一个T并传递一个委托来制作T，你就可以从一个函数返回一个匿名类型。
// returning an anonymous type
// look mom no casting
void LookMyChildReturnsAnAnonICanConsume()
{
// if C# had first class functions you could do
// var anonyFunc = (name:string,id:int) => new {Name=name,Id=id};
var items = new[] { new { Item1 = "hello", Item2 = 3 } };
var itemsProjection =items.Select(x => SomeLogic(x.Item1, x.Item2, (y, i) => new { Word = y, Count = i} ));
// same projection = same type
var otherSourceProjection = SomeOtherSource((y,i) => new {Word=y,Count=i});
var q =
from anony1 in itemsProjection
join anony2 in otherSourceProjection
on anony1.Word equals anony2.Word
select new {anony1.Word,Source1Count=anony1.Count,Source2Count=anony2.Count};
var togetherForever = itemsProjection.Concat(otherSourceProjection).ToList();
}
T SomeLogic<T>(string item1, int item2, Func<string,int,T> f){
return f(item1,item2);
}
IEnumerable<T> SomeOtherSource<T>(Func<string,int,T> f){
var dbValues = new []{Tuple.Create("hello",1), Tuple.Create("bye",2)};
foreach(var x in dbValues)
yield return f(x.Item1,x.Item2);
}
您可以返回dynamic，它将为您提供匿名类型的运行时检查版本，但仅限于.NET 4+
您无法返回匿名类型。你能创建一个可以返回的模型吗？否则，你必须使用object。
Here is an article written by Jon Skeet on the subject
文章代码：
using System;
static class GrottyHacks
{
internal static T Cast<T>(object target, T example)
{
return (T) target;
}
}
class CheesecakeFactory
{
static object CreateCheesecake()
{
return new { Fruit="Strawberry", Topping="Chocolate" };
}
static void Main()
{
object weaklyTyped = CreateCheesecake();
var stronglyTyped = GrottyHacks.Cast(weaklyTyped,
new { Fruit="", Topping="" });
Console.WriteLine("Cheesecake: {0} ({1})",
stronglyTyped.Fruit, stronglyTyped.Topping);
}
}
Or, here is another similar article
或者，正如其他人评论，你可以使用dynamic
在C＃7中，我们可以使用元组来完成这个：
public List<(int SomeVariable, string AnotherVariable)> TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new { SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return TheQueryFromDB
.Select(s => (
SomeVariable = s.SomeVariable,
AnotherVariable = s.AnotherVariable))
.ToList();
}
}
您可能需要安装System.ValueTuple nuget包。
在需要返回时，您可以使用Tuple类替代匿名类型：
注意：元组最多可以有8个参数。
return Tuple.Create(variable1, variable2);
或者，对于原始帖子的示例：
public List<Tuple<SomeType, AnotherType>> TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select Tuple.Create(..., ...)
).ToList();
return TheQueryFromDB.ToList();
}
}
http://msdn.microsoft.com/en-us/library/system.tuple(v=vs.110).aspx
C＃编译器是一个两阶段编译器。在第一阶段，它只检查名称空间，类层次结构，方法签名等。方法体仅在第二阶段编译。
在编译方法体之前，不确定匿名类型。
因此编译器无法在第一阶段确定方法的返回类型。
这就是为什么匿名类型不能用作返回类型的原因。
正如其他人所建议的那样，如果你使用.net 4.0或grater，你可以使用Dynamic。
如果我是你，我可能会创建一个类型并从该方法返回该类型。这样，对于维护代码且更具可读性的未来程序员来说，这很容易。
三种选择：
选项1：
public class TheRepresentativeType {
public ... SomeVariable {get;set;}
public ... AnotherVariable {get;set;}
}
public IEnumerable<TheRepresentativeType> TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new TheRepresentativeType{ SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return TheQueryFromDB;
}
}
选项2：
public IEnumerable TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new TheRepresentativeType{ SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return TheQueryFromDB;
}
}
你可以把它作为对象迭代
选项3：
public IEnumerable<dynamic> TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new TheRepresentativeType{ SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return TheQueryFromDB; //You may need to call .Cast<dynamic>(), but I'm not sure
}
}
并且您将能够将其作为动态对象进行迭代并直接访问其属性
在这种情况下，您可以返回对象列表。
public List<object> TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new { SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return TheQueryFromDB ;
}
}
public List<SomeClass> TheMethod(SomeParameter)
{
using (MyDC TheDC = new MyDC())
{
var TheQueryFromDB = (....
select new SomeClass{ SomeVariable = ....,
AnotherVariable = ....}
).ToList();
return TheQueryFromDB.ToList();
}
}
public class SomeClass{
public string SomeVariable{get;set}
public string AnotherVariable{get;set;}
}
创建自己的类并查询它是我所知道的最佳解决方案。据我所知，你不能在另一种方法中使用匿名类型返回值，因为它不会被识别。但是，它们可以在同一个中使用方法。我曾经把它们作为IQueryable或IEnumerable返回，虽然它仍然不会让你看到匿名类型变量里面的内容。
我在尝试重构某些代码之前遇到过这样的问题，你可以在这里查看：Refactoring and creating separate methods