Как сделать объединение в LINQ для нескольких полей в одном объединении

Мне нужно сделать запрос LINQ2DataSet, который выполняет объединение более чем в одном поле (как

var result = from x in entity
join y in entity2 
       on x.field1 = y.field1 
and 
          x.field2 = y.field2

Я еще не нашел подходящего решения (я могу добавить дополнительные ограничения к предложению where, но это далеко от подходящего решения, или использовать это решение, но это предполагает эквиджоин).

Возможно ли в LINQ объединить несколько полей в одно соединение?

РЕДАКТИРОВАТЬ

var result = from x in entity
             join y in entity2
             on new { x.field1, x.field2 } equals new { y.field1, y.field2 }

это решение, на которое я ссылаюсь, как предполагающее эквиджоин выше.

Дальнейшее редактирование

Чтобы ответить на критику, что мой первоначальный пример был эквиджоин, я признаю, что мое текущее требование - эквиойн, и я уже использовал решение, на которое я ссылался выше.

Я, однако, пытаюсь понять, какие возможности и лучшие практики я использую / должен использовать с LINQ. Мне нужно будет сделать соединение запроса диапазона дат с идентификатором таблицы, и я просто решил эту проблему. Похоже, мне нужно будет добавить диапазон дат в предложении where.

Спасибо, как всегда, за все предложения и комментарии

Решение с анонимным типом должно работать нормально. LINQ может представлять только равноценные выражения (в любом случае, с предложениями соединения), и действительно, это то, что вы сказали, что хотите выразить в любом случае на основе вашего исходного запроса.

Если вам не нравится версия с анонимным типом по какой-то конкретной причине, вы должны объяснить эту причину.

Если вы хотите сделать что-то кроме того, о чем вы изначально просили, приведите пример того, что вы действительно хотите сделать.

РЕДАКТИРОВАТЬ: Отвечая на редактирование в вопросе: да, чтобы сделать объединение «диапазон дат», вам нужно вместо этого использовать предложение where. Они действительно семантически эквивалентны, так что это просто вопрос доступных оптимизаций. Equijoins обеспечивают простую оптимизацию (в LINQ to Objects, которая включает в себя LINQ to DataSets) путем создания поиска на основе внутренней последовательности - представьте его как хеш-таблицу из ключа в последовательность записей, соответствующих этому ключу.

Делать это с диапазонами дат несколько сложнее. Однако, в зависимости от того, что именно вы подразумеваете под «объединением диапазона дат», вы можете сделать что-то похожее - если вы планируете создавать «полосы» дат (например, по одной в год), чтобы две записи, которые встречаются в тот же год (но не в тот же день) должен совпадать, тогда вы можете сделать это, просто используя эту полосу в качестве ключа. Если это сложнее, например, одна сторона объединения предоставляет диапазон, а другая сторона объединения предоставляет одну дату, соответствующую, если она попадает в этот диапазон, это будет лучше обрабатываться с помощью whereпредложения (через секундуfromоговорка) ИМО. Вы могли бы сделать что-то особенное в стиле фанк, заказав одну или другую сторону для более эффективного поиска совпадений, но это было бы большой работой - я бы сделал такую ​​вещь только после проверки, является ли производительность проблемой.

var result = from x in entity
   join y in entity2 on new { x.field1, x.field2 } equals new { y.field1, y.field2 }

var result = from x in entity1
             join y in entity2
             on new { X1= x.field1, X2= x.field2 } equals new { X1=y.field1, X2= y.field2 }

Это необходимо сделать, если имена столбцов различаются в двух объектах.

Просто чтобы завершить это с помощью эквивалентного синтаксиса цепочки методов:

entity.Join(entity2, x => new {x.Field1, x.Field2},
                     y => new {y.Field1, y.Field2}, (x, y) => x);

В то время как последний аргумент (x, y) => x- то, что вы выбираете (в приведенном выше случае мы выбираем x).

Я думаю, что более читабельным и гибким вариантом является использование функции Where:

var result = from x in entity1
             from y in entity2
                 .Where(y => y.field1 == x.field1 && y.field2 == x.field2)

Это также позволяет легко перейти от внутреннего соединения к левому, добавив .DefaultIfEmpty ().

var result = from x in entity
             join y in entity2
             on new { X1= x.field1, X2= x.field2 } equals new { X1=y.field1, X2= y.field2 }
             select new 
             {
               /// Columns
              };

Вы могли бы сделать что-то вроде (ниже)

var query = from p in context.T1

        join q in context.T2

        on

        new { p.Col1, p.Col2 }

        equals

         new { q.Col1, q.Col2 }

        select new {p...., q......};

Используя оператор соединения, вы можете выполнять только эквайоины. Другие типы объединений могут быть созданы с использованием других операторов. Я не уверен, будет ли проще использовать именно эти методы для точного соединения, которое вы пытаетесь сделать, или изменив предложение where. Документацию по предложению соединения можно найти здесь . В MSDN есть статья об операциях объединения с несколькими ссылками на примеры других объединений.

Если имена полей различаются в сущностях

var result = from x in entity
   join y in entity2 on 
          new {
                field1=   x.field1,
               field2 =  x.field2 
             } 
          equals
         new { 
                field1= y.field1,
                field2=  y.myfield
              }
select new {x,y});

Как полная цепочка методов, которая будет выглядеть так:

lista.SelectMany(a => listb.Where(xi => b.Id == a.Id && b.Total != a.Total),
                (a, b) => new ResultItem
                {
                    Id = a.Id,
                    ATotal = a.Total,
                    BTotal = b.Total
                }).ToList();

from d in db.CourseDispatches
                             join du in db.DispatchUsers on d.id equals du.dispatch_id
                             join u in db.Users on du.user_id equals u.id
                             join fr in db.Forumreports on (d.course_id + '_' + du.user_id)  equals  (fr.course_id + '_'+ fr.uid)

это работает для меня

Объявите класс (тип) для хранения элементов, к которым вы хотите присоединиться. В приведенном ниже примере объявить JoinElement

 public class **JoinElement**
{
    public int? Id { get; set; }
    public string Name { get; set; }

}

results = from course in courseQueryable.AsQueryable()
                  join agency in agencyQueryable.AsQueryable()
                   on new **JoinElement**() { Id = course.CourseAgencyId, Name = course.CourseDeveloper } 
                   equals new **JoinElement**() { Id = agency.CourseAgencyId, Name = "D" } into temp1