Вернуть результаты анонимного типа?

Используя простой пример ниже, каков наилучший способ вернуть результаты из нескольких таблиц, используя Linq to 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и указать этот тип в select? Или есть другой способ проще?

Я склонен идти по этой схеме:

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

Возможно, вам придется установить пакет nuget System.ValueTuple.

Теперь я понимаю, что компилятор не позволит мне вернуть набор анонимных типов, поскольку он ожидает Dogs, но есть ли способ вернуть это без необходимости создания пользовательского типа?

Используйте use object для возврата списка анонимных типов без создания пользовательского типа. Это будет работать без ошибки компилятора (в .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;
}

Ну, если вы возвращаете собак, вы должны сделать:

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

Попробуйте это, чтобы получить динамические данные. Вы можете конвертировать код для списка <>

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