LINQ - 如果存在则选择这些，否则回退到这些

Question

考虑本地化文本，存储在此表中：

表格文本

• 文本标识
• 语言
• 价值

现在我想为 TextId 1 选择一个文本。如果在“丹麦语”中没有此 TextId 的文本，我想回退到“英语”。

我可以这样做：

var texts = MyDb.Texts.Where(x=>x.TextId == 1 & x.Language == "Danish");

if (!texts.Any()){
    texts = MyDb.Texts.Where(x=>x.TextId == 1 & x.Language == "English");
}

...但是我必须重复 Where 子句的其余部分，这意味着我在重复自己（在这个例子中并没有那么糟糕，但可能还有更多子句）。

有没有更简单的方法来做到这一点？

Answer 1

一种解决方案是检索所需 id 的所有文本，然后加入语言偏好映射：

var languages = new[]
                    {
                        new {Language = "Danish", Priority = 1},
                        new {Language = "English", Priority = 2}
                    };
var id = 1;
var text = (from t in db.Texts.Where(t => t.TextId == id).AsEnumerable()
            join l in languages on t.Language equals l.Language
            orderby l.Priority
            select t).FirstOrDefault();

如果您只有两种语言，那么这可以更简单地完成并避免返回任何不必要的行：

var id = 1;
var text = (from t in db.Texts
            let priority = t.Language == "Danish" ? 1 : 2
            where t.TextId == id
            orderby priority
            select t).FirstOrDefault();

如果您想支持动态数量的语言，您可以动态构建优先级表达式（使用 System.Linq.Expressions）。这将导致一个数据库调用，该调用将只返回您想要的一条记录：

var id = 1;
var text = db.Texts.Where(t => t.TextId == id).OrderBy(CreatePriorityExpression()).FirstOrDefault();

private static Expression<Func<Text, int>> CreatePriorityExpression()
{
    var languages = new[]
                        {
                            new {Language = "Danish", Priority = 1},
                            new {Language = "English", Priority = 2}
                        };

    // Creates an expression of nested if-else statements & translates to a SQL CASE 
    var param = Expression.Parameter(typeof(Text));
    var lang = Expression.PropertyOrField(param, "Language");
    Expression ex = Expression.Constant(languages.Last().Priority);
    foreach (var l in languages.Reverse().Skip(1))
        ex = Expression.Condition(Expression.Equal(lang, Expression.Constant(l.Language)), Expression.Constant(l.Priority), ex);
    return Expression.Lambda<Func<Text, int>>(ex, param);
}

Answer 2

我建议使用过滤器模式，您可以在其中针对 IEnumerable 编写扩展方法。这样一来，您的大部分逻辑就被封装到您可以反复使用的方法中：

public static class TextExtensions
    {
        [System.Runtime.CompilerServices.Extension]
        public static IEnumerable<Text> ByTextId(this IEnumerable<Text> qry, int textId)
        {
            return qry.Where(t => t.TextId == textId);
        }

        [System.Runtime.CompilerServices.Extension]            
        public static IEnumerable<Text> ByLanguage(this IEnumerable<Text> qry, string language)
        {
            return qry.Where(t => t.Language == language);
        }
    }

然后你的代码变成：

var texts = MyDB.Texts.ByTextId(1).ByLanguage("Danish");

然后重复就不再是问题了。我还建议让自己成为一个静态类来保存各种语言值以避免硬编码：

public static class LanguageValues
{
    public static string English
    {
        get
        {
            return "English";
        }
    }

    public static string Danish
    {
        get
        {
            return "Danish";
        }
    }
}

然后你的代码变成：

var texts = MyDB.Texts.ByTextId(1).ByLanguage(LanguageValues.Danish);

您可以将其与 DefaultIfEmpty 方法结合使用，该方法为您提供：

var texts = MyDB.Texts.DefaultIfEmpty(MyDB.Texts.ByTextId(1).ByLanguage(LanguageValues.English).Single()).ByTextId(1).ByLanguage(LanguageValues.Danish);

然后将其放入一个单独的扩展方法中以供重复使用：

[System.Runtime.CompilerServices.Extension]
public static IEnumerable<Text> GetValueOrDefault(this IEnumerable<Text> qry, int textId, string language)
{
    return qry.DefaultIfEmpty(qry.ByTextId(textId).ByLanguage(LanguageValues.English).Single()).ByTextId(textId).ByLanguage(language);
}

您现在可以简单地调用：

var text = MyDB.Texts.GetValueOrDefault(1, LanguageValues.Danish);

请注意，这可以用作任何查询的最后一步，所以这样的事情也可以工作：

var text = MyDB.Texts.Where(<some funky clause>).Where(<some other funky clause>).GetValueOrDefault(1,LanguageValues.Danish);

正如人们所指出的那样，如果您使用多种备份语言，则有比在原始问题中一次检查一种语言更好的方法，但是这种过滤器模式可以很好地工作，只需定义正确的过滤您的用例和策略。

Answer 3

就像我在上面的评论中所说的那样，它并不完全漂亮，但它应该可以工作:)

public string GetText(string lang, string fallback)
{
    // lang precedes fallback
    if (lang.CompareTo(fallback) < 1)
    {
        return MyDb.Texts.Where(x => x.Language == lang || x.Language == fallback).OrderBy(x => x.Language).FirstOrDefault();
    }
    else
    {
        return MyDb.Texts.Where(x => x.Language == lang || x.Language == fallback).OrderByDescending(x => x.Language).FirstOrDefault();
    }
}

Answer 4

如果您主要关心的是避免重复您的 where 子句，那么最简单的方法是将您的 where 子句拆分，如下所示：

var alltexts = MyDb.Texts.Where(x => x.TextId == 1);
var text = alltexts.Any(x => x.Language == "Danish")
         ? alltexts.Where(x => x.Language == "Danish")
         : alltexts.Where(x => x.Language == "English")

如果你能保证你最多只有一个匹配的条目（对于本地化表来说，这可能是真的）你可以进一步简化它（并将整个东西包装在一个函数中以便于重用）：

public Text GetLocalizedText(Func<Text, bool> predicate, string language )
{
    var temp = MyDb.Texts.Where(predicate);
    return temp.SingleOrDefault(x => x.Language == language)
        ?? temp.Single(x => x.Language == "English");
}

var caption = GetLocalizedText(x => x.TextId == 1, "Danish")