Refactor a LINQ JOIN out of the expression

Question

I have a LINQ-to-SQL expression which is repeated 3 times, with only the Join statement changing.

switch (elmntType)
{
    case ElementType.Dictionary:
        auditLogs = db.st_element_audit_log.Where(al => /* some conditions */)
                      .Join(db.stt_dictionary,
                            auditLog => auditLog.element_id,
                            dictionary => dictionary.id,
                            (auditLog, dictionary) => new AuditLogAndDict { AuditLog = auditLog, Dictionary = dictionary })
                      .Where(ald => /* some conditions */)
                      .OrderByDescending(ald => /* some conditions */)
                      .Select(ald => ald.AuditLog);
        break;

    case ElementType.Concept:
        auditLogs = db.st_element_audit_log.Where(al => /* some conditions */)
                      .Join(db.stt_concept,
                            auditLog => auditLog.element_id,
                            concept => concept.id,
                            (auditLog, concept) => new {auditLog, concept})
                      .Join(db.stt_dictionary,
                            anon => anon.concept.dictionary_id,
                            dictionary => dictionary.id,
                            (anon, dictionary) => new AuditLogAndDict {AuditLog = anon.auditLog, Dictionary = dictionary})
                      .Where(ald => /* some conditions */)
                      .OrderByDescending(ald => /* some conditions */)
                      .Select(ald => ald.AuditLog);
        break;

    case ElementType.Term:
        auditLogs = db.st_element_audit_log.Where(al => /* some conditions */)
                      .Join(db.stt_term,
                            auditLog => auditLog.element_id,
                            term => term.id,
                            (auditLog, term) => new {auditLog, term})
                      .Join(db.stt_concept,
                            anon => anon.term.concept_id,
                            concept => concept.id,
                            (anon, concept) => new {anon.auditLog, concept})
                      .Join(db.stt_dictionary,
                            anon => anon.concept.dictionary_id,
                            dictionary => dictionary.id,
                            (anon, dictionary) => new AuditLogAndDict {AuditLog = anon.auditLog, Dictionary = dictionary})
                      .Where(ald => /* some conditions */)
                      .OrderByDescending(ald => /* some conditions */)
                      .Select(ald => ald.AuditLog);
        break;

    default:
        throw new ArgumentException("Unsupported ElementType enumeration.", nameof(elmntType));
}

What I'd like to find out is whether I can refactor the Join statement, leaving just a single instance of the entire LINQ statement with the Join coming in from a switch statement:

switch (elmntType)
{
    case ElementType.Dictionary:
        // build .Join() statement
        break;

    case ElementType.Concept:
        // build .Join() statement
        break;

    case ElementType.Term:
        // build .Join() statement
        break;

    default:
        throw new ArgumentException("Unsupported ElementType enumeration.", nameof(elmntType));
}

var auditLogs = db.st_element_audit_log.Where(al => /* some conditions */)
                          // use the custom .Join() statement here
                          .Where(ald => /* some conditions */)
                          .OrderByDescending(ald => /* some conditions */)
                          .Select(ald => ald.AuditLog);

Is this even possible?

Answer 1

You can refactor out the duplicated code like this.

var filtered = db.st_element_audit_log.Where(al => /* some conditions */)
IQueryable<AuditLogAndDict> joined = null;
switch (elmntType)
{
    case ElementType.Dictionary:
        joined = filtered.Join(db.stt_dictionary,
            auditLog => auditLog.element_id,
            dictionary => dictionary.id,
            (auditLog, dictionary) => new AuditLogAndDict { AuditLog = auditLog, Dictionary = dictionary })
        break;

    case ElementType.Concept:
        joined = filtered
            .Join(db.stt_concept,
                auditLog => auditLog.element_id,
                concept => concept.id,
                (auditLog, concept) => new {auditLog, concept})
            .Join(db.stt_dictionary,
                anon => anon.concept.dictionary_id,
                dictionary => dictionary.id,
                (anon, dictionary) => new AuditLogAndDict {AuditLog = anon.auditLog, Dictionary = dictionary})
        break;

    case ElementType.Term:
        joined = filtered
            .Join(db.stt_term,
                auditLog => auditLog.element_id,
                term => term.id,
                (auditLog, term) => new {auditLog, term})
            .Join(db.stt_concept,
                anon => anon.term.concept_id,
                concept => concept.id,
                (anon, concept) => new {anon.auditLog, concept})
            .Join(db.stt_dictionary,
                anon => anon.concept.dictionary_id,
                dictionary => dictionary.id,
                (anon, dictionary) => new AuditLogAndDict {AuditLog = anon.auditLog, Dictionary = dictionary})
        break;

    default:
        throw new ArgumentException("Unsupported ElementType enumeration.", nameof(elmntType));
}

auditLogs = joined
    .Where(ald => /* some conditions */)
    .OrderByDescending(ald => /* some conditions */)
    .Select(ald => ald.AuditLog);

Answer 2

Did you try creating a method like this :

static object MyJoin(object x)
        {
            return x.Join(db.stt_dictionary,
            auditLog => auditLog.element_id,
            dictionary => dictionary.id,
            (auditLog, dictionary) => new AuditLogAndDict { AuditLog = auditLog, Dictionary = dictionary });

        }