返回匿名类型的结果？

使用下面的简单示例，使用Linq将多个表中的结果返回到SQL的最佳方法是什么？

说我有两个表：

Dogs:   Name, Age, BreedId
Breeds: BreedId, BreedName

我想把所有的狗都还给他们BreedName。我应该让所有的狗都使用这样的东西而没有问题：

public IQueryable<Dog> GetDogs()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select d;
    return result;
}

但是，如果我想要带有品种的狗并尝试这样做，则会遇到问题：

public IQueryable<Dog> GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select new
                        {
                            Name = d.Name,
                            BreedName = b.BreedName
                        };
    return result;
}

现在，我意识到编译器不允许我返回一组匿名类型，因为它期望使用Dogs，但是有没有一种方法可以不必创建自定义类型而返回它呢？还是我必须为其创建自己的类DogsWithBreedNames并在选择中指定该类型？还是有另一种更简单的方法？

我倾向于这种模式：

public class DogWithBreed
{
    public Dog Dog { get; set; }
    public string BreedName  { get; set; }
}

public IQueryable<DogWithBreed> GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select new DogWithBreed()
                        {
                            Dog = d,
                            BreedName = b.BreedName
                        };
    return result;
}

这意味着您有一个额外的类，但它编写起来又快又容易，易于扩展，可重用并且是类型安全的。

您可以返回匿名类型，但这确实不是很漂亮。

在这种情况下，我认为创建适当的类型会更好。如果仅在包含该方法的类型中使用它，则将其设置为嵌套类型。

我个人希望C＃获得“命名匿名类型”-即与匿名类型相同的行为，但是具有名称和属性声明，仅此而已。

编辑：其他人建议回狗，然后通过属性路径等访问品种名称。这是一种完全合理的方法，但是IME会导致您由于需要数据而以特定方式进行查询的情况使用-并且当您刚返回时该元信息会丢失IEnumerable<Dog>-该查询可能期望您使用（例如），Breed而不是Owner由于某些加载选项等，但是如果您忘记了这一点并开始使用其他属性，则您的应用可能会运行，但效率不如您最初设想的那样。当然，我可能在谈论垃圾，或者过度优化等等。

只是为了增加我两美分的价值：-)我最近学会了一种处理匿名对象的方法。仅在以.NET 4框架为目标，并且仅在添加对System.Web.dll的引用时才可以使用它，但是它非常简单：

...
using System.Web.Routing;
...

class Program
{
    static void Main(string[] args)
    {

        object anonymous = CallMethodThatReturnsObjectOfAnonymousType();
        //WHAT DO I DO WITH THIS?
        //I know! I'll use a RouteValueDictionary from System.Web.dll
        RouteValueDictionary rvd = new RouteValueDictionary(anonymous);
        Console.WriteLine("Hello, my name is {0} and I am a {1}", rvd["Name"], rvd["Occupation"]);
    }

    private static object CallMethodThatReturnsObjectOfAnonymousType()
    {
        return new { Id = 1, Name = "Peter Perhac", Occupation = "Software Developer" };
    }
}

为了能够添加对System.Web.dll的引用，您必须遵循rushonerok的建议：确保[项目的]目标框架是“ .NET Framework 4”而不是“ .NET Framework 4 Client Profile”。

不，您必须经过一些技巧才能返回匿名类型。

如果您不使用C＃，那么您要查找的内容（在没有具体类型的情况下返回多个数据）称为Tuple。

有很多C＃元组实现，使用此处显示的实现，您的代码将像这样工作。

public IEnumerable<Tuple<Dog,Breed>> GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select new Tuple<Dog,Breed>(d, b);

    return result;
}

并在呼叫站点上：

void main() {
    IEnumerable<Tuple<Dog,Breed>> dogs = GetDogsWithBreedNames();
    foreach(Tuple<Dog,Breed> tdog in dogs)
    {
        Console.WriteLine("Dog {0} {1}", tdog.param1.Name, tdog.param2.BreedName);
    }
}

您可以执行以下操作：

public System.Collections.IEnumerable GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select new
                        {
                            Name = d.Name,
                            BreedName = b.BreedName
                        };
    return result.ToList();
}

您必须首先使用ToList()方法从数据库中获取行，然后选择项目作为类。试试这个：

public partial class Dog {
    public string BreedName  { get; set; }}

List<Dog> GetDogsWithBreedNames(){
    var db = new DogDataContext(ConnectString);
    var result = (from d in db.Dogs
                  join b in db.Breeds on d.BreedId equals b.BreedId
                  select new
                  {
                      Name = d.Name,
                      BreedName = b.BreedName
                  }).ToList()
                    .Select(x=> 
                          new Dog{
                              Name = x.Name,
                              BreedName = x.BreedName,
                          }).ToList();
return result;}

因此，诀窍是第一ToList()。它立即进行查询并从数据库获取数据。第二个技巧是选择项目并使用对象初始化程序生成加载了项目的新对象。

希望这可以帮助。

在C＃7中，您现在可以使用元组！...，这消除了创建类以返回结果的需要。

这是一个示例代码：

public List<(string Name, string BreedName)> GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
             join b in db.Breeds on d.BreedId equals b.BreedId
             select new
             {
                Name = d.Name,
                BreedName = b.BreedName
             }.ToList();

    return result.Select(r => (r.Name, r.BreedName)).ToList();
}

您可能需要安装System.ValueTuple nuget软件包。

现在，我意识到编译器不允许我返回一组匿名类型，因为它期望使用Dogs，但是有没有一种方法可以不必创建自定义类型而返回它呢？

使用use 对象可返回匿名类型列表，而无需创建自定义类型。这将工作而不会出现编译器错误（在.net 4.0中）。我将列表返回给客户端，然后在JavaScript上进行了解析：

public object GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select new
                        {
                            Name = d.Name,
                            BreedName = b.BreedName
                        };
    return result;
}

只需选择狗，然后使用dog.Breed.BreedName，这应该可以正常工作。

如果您有很多狗，请使用DataLoadOptions.LoadWith减少数据库调用的次数。

您不能直接返回匿名类型，但是可以通过通用方法将它们循环。大多数LINQ扩展方法也是如此。那里没有魔术，但看起来它们会返回匿名类型。如果参数为匿名，则结果也可以为匿名。

var result = Repeat(new { Name = "Foo Bar", Age = 100 }, 10);

private static IEnumerable<TResult> Repeat<TResult>(TResult element, int count)
{
    for(int i=0; i<count; i++)
    {
        yield return element;
    }
}

下面是一个基于原始问题代码的示例：

var result = GetDogsWithBreedNames((Name, BreedName) => new {Name, BreedName });


public static IQueryable<TResult> GetDogsWithBreedNames<TResult>(Func<object, object, TResult> creator)
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                    join b in db.Breeds on d.BreedId equals b.BreedId
                    select creator(d.Name, b.BreedName);
    return result;
}

好吧，如果您要归还Dogs，可以这样做：

public IQueryable<Dog> GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    return from d in db.Dogs
           join b in db.Breeds on d.BreedId equals b.BreedId
           select d;
}

如果要让Breed优先加载而不是延迟加载，请使用适当的DataLoadOptions构造。

BreedId该Dog表中的显然是表中相应行的外键Breed。如果您已正确设置数据库，则LINQ to SQL应该自动在两个表之间创建一个关联。生成的Dog类将具有Breed属性，并且Breed类应具有Dogs集合。以这种方式进行设置，您仍然可以返回IEnumerable<Dog>，这是一个包含品种属性的对象。唯一的警告是，您需要在查询中预加载品种对象和狗对象，以便可以在处理完数据上下文之后访问它们，并且（如另一位发布者所建议的那样）对集合执行一个方法，该方法将导致立即执行的查询（在这种情况下为ToArray）：

public IEnumerable<Dog> GetDogs()
{
    using (var db = new DogDataContext(ConnectString))
    {
        db.LoadOptions.LoadWith<Dog>(i => i.Breed);
        return db.Dogs.ToArray();
    }

}

然后，为每只狗获取品种非常简单：

foreach (var dog in GetDogs())
{
    Console.WriteLine("Dog's Name: {0}", dog.Name);
    Console.WriteLine("Dog's Breed: {0}", dog.Breed.Name);        
}

如果主要思想是使发送到数据库服务器的SQL select语句仅具有必填字段，而不是所有Entity字段，那么您可以执行以下操作：

public class Class1
{
    public IList<Car> getCarsByProjectionOnSmallNumberOfProperties()
    {

        try
        {
            //Get the SQL Context:
            CompanyPossessionsDAL.POCOContext.CompanyPossessionsContext dbContext 
                = new CompanyPossessionsDAL.POCOContext.CompanyPossessionsContext();

            //Specify the Context of your main entity e.g. Car:
            var oDBQuery = dbContext.Set<Car>();

            //Project on some of its fields, so the created select statment that is
            // sent to the database server, will have only the required fields By making a new anonymouse type
            var queryProjectedOnSmallSetOfProperties 
                = from x in oDBQuery
                    select new
                    {
                        x.carNo,
                        x.eName,
                        x.aName
                    };

            //Convert the anonymouse type back to the main entity e.g. Car
            var queryConvertAnonymousToOriginal 
                = from x in queryProjectedOnSmallSetOfProperties
                    select new Car
                    {
                        carNo = x.carNo,
                        eName = x.eName,
                        aName = x.aName
                    };

            //return the IList<Car> that is wanted
            var lst = queryConvertAnonymousToOriginal.ToList();
            return lst;

        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine(ex.ToString());
            throw;
        }
    }
}

尝试此操作以获取动态数据。您可以转换List <>的代码

public object GetDogsWithBreedNames()
{
    var db = new DogDataContext(ConnectString);
    var result = from d in db.Dogs
                 join b in db.Breeds on d.BreedId equals b.BreedId
                 select new
                        {
                            Name = d.Name,
                            BreedName = b.BreedName
                        };
    return result.FirstOrDefault();
}

dynamic dogInfo=GetDogsWithBreedNames();
var name = dogInfo.GetType().GetProperty("Name").GetValue(dogInfo, null);
var breedName = dogInfo.GetType().GetProperty("BreedName").GetValue(dogInfo, null);

如果您在数据库中建立了关系，并且对BreedId进行了前瞻性的键约束，那么您是否已经明白了？

现在我可以打电话给：

internal Album GetAlbum(int albumId)
{
    return Albums.SingleOrDefault(a => a.AlbumID == albumId);
}

在调用该代码的代码中：

var album = GetAlbum(1);

foreach (Photo photo in album.Photos)
{
    [...]
}

因此，在您的实例中，您将调用诸如dog.Breed.BreedName之类的东西-如我所说，这取决于您使用这些关系设置的数据库。

正如其他人提到的那样，如果出现问题，DataLoadOptions将有助于减少数据库调用。

这不能完全回答您的问题，但是Google根据关键字将我引到了这里。这是您可以从列表中查询匿名类型的方法：

var anon = model.MyType.Select(x => new { x.Item1, x.Item2});