我该如何清理这个 lambda？

Question

我有一个在多个 LINQ 查询中多次使用的表达式，因此我将其分离到它自己的返回该表达式的方法中。该函数的 lambda 部分看起来有点混乱。有人想尝试重构它并使其更具可读性和/或更小吗？

    private Expression<Func<Message, bool>> UserSelector(string username, bool sent)
    {
        return x => ((sent ? x.FromUser : x.ToUser).Username.ToLower() == username.ToLower()) && (sent ? !x.SenderDeleted : !x.RecipientDeleted);
    }

对其所做操作的快速英文描述是，它检查布尔值 sent 并根据以下内容检查 Message.FromUser 或 Message.ToUser那个布尔值。

如果用户正在查看他/她的发件箱，则 sent 为 true，并且它将查看是否 x.FromUser.Username == username 和 x.SenderDeleted ==假。

如果用户正在查看他/她的收件箱，那么它会执行相同的逻辑，但发送是错误的，并且它会检查 x.ToUser 和 x.RecipientDeleted 。

也许这是最简单的方法，但我愿意进行一些重构。

答案编辑

我真的很喜欢Davy8的答案，但我决定更进一步，做两个表达式，而不是一个带有嵌套函数的表达式。现在我有以下方法：

    /// <summary>
    /// Expression to determine if a message belongs to a user.
    /// </summary>
    /// <param name="username">The name of the user.</param>
    /// <param name="sent">True if retrieving sent messages.</param>
    /// <returns>An expression to be used in a LINQ query.</returns>
    private Expression<Func<Message, bool>> MessageBelongsToUser(string username, bool sent)
    {
        return x => (sent ? x.FromUser : x.ToUser).Username.Equals(username, StringComparison.OrdinalIgnoreCase);
    }

    /// <summary>
    /// Expression to determine if a message has been deleted by the user.
    /// </summary>
    /// <param name="username">The name of the user.</param>
    /// <param name="sent">True if retrieving sent messages.</param>
    /// <returns>An expression to be used in a LINQ query.</returns>
    private Expression<Func<Message, bool>> UserDidNotDeleteMessage(string username, bool sent)
    {
        return x => sent ? !x.SenderDeleted : !x.RecipientDeleted;
    }

所以现在我的查询看起来像这样：

    /// <summary>
    /// Retrieves a list of messages from the data context for a user.
    /// </summary>
    /// <param name="username">The name of the user.</param>
    /// <param name="page">The page number.</param>
    /// <param name="itemsPerPage">The number of items to display per page.</param>
    /// <param name="sent">True if retrieving sent messages.</param>
    /// <returns>An enumerable list of messages.</returns>
    public IEnumerable<Message> GetMessagesBy_Username(string username, int page, int itemsPerPage, bool sent)
    {
        var query = _dataContext.Messages
            .Where(MessageBelongsToUser(username, sent))
            .Where(UserDidNotDeleteMessage(username, sent))
            .OrderByDescending(x => x.SentDate)
            .Skip(itemsPerPage * (page - 1))
            .Take(itemsPerPage);
        return query;
    }

    /// <summary>
    /// Retrieves the total number of messages for the user.
    /// </summary>
    /// <param name="username">The name of the user.</param>
    /// <param name="sent">True if retrieving the number of messages sent.</param>
    /// <returns>The total number of messages.</returns>
    public int GetMessageCountBy_Username(string username, bool sent)
    {
        var query = _dataContext.Messages
            .Where(MessageBelongsToUser(username, sent))
            .Where(UserDidNotDeleteMessage(username, sent))
            .Count();
        return query;
    }

我想说这些是一些非常英语可读的查询，谢谢大家！

参考：http://www.codetunnel.com /blog/post/64/how-to-simplify-complex-linq-表达式

Answer 1

将其拆分为一个单独的函数：

    private Expression<Func<Message, bool>> UserSelector(string username, bool sent)
    {
        return message=> InnerFunc(message, username, sent);
    }

    private static bool InnerFunc(Message message, string username, bool sent)
    {
        if(sent)
        {
            return string.Equals(message.FromUser.Username, username, StringComparison.InvariantCultureIgnoreCase) && !message.SenderDeleted;
        }
        return string.Equals(message.ToUser.Username, username, StringComparison.InvariantCultureIgnoreCase) && !message.RecipientDeleted;
    }

或者可以将其内联以维护闭包用法：（

    private Expression<Func<Message, bool>> UserSelector(string username, bool sent)
    {
        Func<Message, bool> innerFunc = message =>
        {
            if (sent)
            {
                return string.Equals(message.FromUser.Username, username, StringComparison.InvariantCultureIgnoreCase) &&
                        !message.SenderDeleted;
            }
            return string.Equals(message.ToUser.Username, username, StringComparison.InvariantCultureIgnoreCase) &&
                    !message.RecipientDeleted;
        };
        return message => innerFunc(message);
    }

编辑为将 string.Equals 与 StringComparison.InvariantCultureIgnoreCase 结合使用，用于具有不同的奇数边缘情况文化设置。）

Answer 2

你有Reshaper吗？很多时候我会写这样的东西作为 foreach 循环，看看 Resharper 是否可以重构它。不过，我认为可读性是最重要的，尽管您应该评估您提出的任何解决方案的性能。

Answer 3

只要您将为此问题编写的描述写为评论，它就应该可以帮助任何试图阅读/理解它的人，正确吗？