c# - 可变参数的LINQ方法

Question

我对内部应用程序的“搜索”页面有一种LINQ方法。方法如下

    public static DataTable SearchForPerson(String FirstName, String MiddleName, String LastName, String SSN, DateTime? BirthDate)
    {
        var persons = (from person in context.tblPersons 
                       where person.LastName == LastName || person.LastName.StartsWith(LastName)
                       join addresse in context.tblAddresses on person.PersonID equals addresse.PersonID 
                       orderby person.LastName
                       select new { person.PersonID, person.LastName, person.FirstName, person.SSN, addresse.AddressLine1 });

        var filteredPersonsList = persons.Where(p => p.LastName == LastName).ToList();
        if (filteredPersonsList.Count == 0)
            filteredPersonsList = persons.Where(p => p.LastName.StartsWith(LastName)).ToList();

        var dataTable = filteredPersonsList.CopyLinqToDataTable();



        return dataTable;
    }

现在，您无疑会看到，在创建此文件时我略加疏忽，因为它仅按 LastName搜索。当我想到可能无法正确执行此操作时，我正在扩展此操作。

所以，最后我的问题；使用这样的单一方法与一种机制（我正在考虑对非空参数进行切换）来告诉我要使用哪个参数，是否更可取（最佳实践，更有效等）？只需制作多个版本，例如 SearchForPersonByLastName和 SearchForPersonBySSN？

另外，我认为这是更常见的问题吗？

Answer 1

我是否正确理解仅将使用其中一个参数进行搜索？如果是这样，那么绝对这些应该是单独的方法。每当您使用单词“和”或“或”描述一个方法（或类等）时，您可能都有一个可以分解为多个方法的方法。因此，听起来好像此方法当前被描述为“此方法通过Person或FirstName或MiddleName或LastName或SSN搜索BirthDate。所以写方法

SearchByFirstName
SearchByMiddleName
SearchByLastName
SearchBySSN
SearchByBirthDate

显然，这些方法之间会有一些共同的逻辑，您可以将它们分解为辅助方法。

请澄清我是否误会了，我将相应地修改答案。

编辑：

好的，所以您说您可能正在按多个参数进行搜索。我仍然非常希望为每个参数使用单独的方法（更好的关注点分离，更易于维护，更易于测试等）。这是将它们绑在一起的一种方法：

DataTable Search(
    string firstName,
    string middleName,
    string lastName,
    string ssn,
    DateTime? birthdate
) {
    IQueryable<Person> query = context.tblPersons;
    if(SearchParameterIsValid(firstName)) {
        query = SearchByFirstName(query, firstName);
    }
    if(SearchParameterIsValid(middleName)) {
        query = SearchByMiddleName(query, middleName);
    }
    if(SearchParameterIsValid(lastName)) {
        query = SearchByLastName(query, lastName);
    }
    if(SearchParameterIsValid(ssn)) {
        query = SearchBySSN(query, ssn);
    }
    if(birthDate != null) {
        query = SearchByBirthDate(query, birthDate);
    }

    // fill up and return DataTable from query
}

bool SearchParameterIsValid(string s) {
    return !String.IsNullOrEmpty(s);
}

IQueryable<Person> SearchByFirstName(
    IQueryable<Person> source
    string firstName
) {
    return from p in source
           where p.FirstName == firstName || p.FirstName.StartsWith(firstName)
           select p;
}

// etc.

要么：

DataTable Search(
    string firstName,
    string middleName,
    string lastName,
    string ssn,
    DateTime? birthdate
) {
    Predicate<Person> predicate = p => true;
    if(SearchParameterIsValid(firstName)) {
        predicate = PredicateAnd(predicate, FirstNamePredicate(firstName));
    }
    if(SearchParameterIsValid(middleName)) {
        predicate = PredicateAnd(predicate, MiddleNamePredicate(middleName));
    }
    // etc.
}

Predicate<T> PredicateAnd<T>(Predicate<T> first, Predicate<T> second) {
    return t => first(t) && second(t);
}

Predicate<Person> FirstNamePredicate(string firstName) {
    return p => p.FirstName == firstName || p.FirstName.StartsWith(firstName);
}

// etc.

DataTable SearchByPredicate(
    IQueryable<Person> source,
    Predicate<Person> predicate
) {
    var query = source.Where(predicate)
                      .Join(
                          context.tblAddresses,
                              p => p.PersonID,
                              a => a.PersonID,
                              (p, a) => new {
                                  p.PersonID,
                                  p.LastName,
                                  p.FirstName,
                                  p.SSN,
                                  a.AddressLine1
                              }
                          );

    return query.CopyLinqToDataTable();
}