从数据库LINQ解析结果

我有以下LINQ查询：

var query = (from c in _context.MapTextToLanguage
             where c.LanguageId == defaultLanguage
             where (c.Identifier == "home" || c.Identifier == "CV" || 
             c.Identifier == "contact" || c.Identifier == "manage" || 
             c.Identifier == "register" || c.Identifier == "login" || 
             c.Identifier == "logout" || c.Identifier == "about")
             select c.Text);

这将返回我要查找的内容，但此列表的顺序由它在数据库中查找对象的顺序决定

我想知道查询的结果是否可以解析为一个模型，或者查询[0]始终是=home

我可以单独要求这些值，但这似乎效率低下

您可以使用：

var output = query.OrderByDescending(x => x == "home");

要使输出[0]返回主标识符的文本，或者：

//adjust your query to select c rather than c.Text
var output = query.ToDictionary(x => x.Identifier);

因此，您可以执行输出[“主页”]。文本、输出[“CV”]。文本等操作。

您可以使用：

var output = query.OrderByDescending(x => x == "home");

要使输出[0]返回主标识符的文本，或者：

//adjust your query to select c rather than c.Text
var output = query.ToDictionary(x => x.Identifier);

这样你就可以输出[“主页”]。文本，输出[“简历”]。文本等等

要求：我想知道查询的结果是否可以解析为一个模型，或者查询[0]始终是=home

正如其他人所说，您可以使用

OrderBy

或

ToDictionary

将“主”项放在第一位。但是，这将多次枚举您的序列。尤其是OrderBy会对项目进行多次比较，然后才发现它们在顺序上是相等的

但是，如果你只想把一个项目放在“家”的前面，为什么要比较所有这些项目呢

考虑为类创建一个扩展函数，通过只枚举一次来完成所需的操作。看

如果需要此泛型：将具有特定属性的项放在第一位的函数：

static IEnumerable<TSource> WhereItemFirst<TSource, TKey>(this IEnumerable<TSource> source,
       Func<TSource, TKey> keySelector,
       TKey keyValue,
       IEqualityComparer<TKey> keyComparer)
{
    // TODO: exception if source, keySelector, keyValue null

    // if keyComparer null, use default comparer to compare TKeys
    if (keyComparer == null) keyComparer = EqualityComparer<TKey>.Default;

    List<TSource> nonKeyItems = new List<TSource>();
    foreach(var item in source)
    {
        if (comparer.Equals(keySelector(item), keyValue))
        {
            // return the item with a value equal to keyValue
            yield return item;
        }
        else
        {
            nonKeyItems.Add(item);
        }
    }

    // return the nonKey items:
    foreach (var nonKeyItem in nonKeyItems) yield return nonKeyItem;
 }

参数

keySelector

从每个人的

地址中提取。将提取的
地址
与
我的地址
进行比较。如果匹配，则首先返回

要求：我想知道查询的结果是否可以解析为一个模型，或者查询[0]始终是=home

正如其他人所说，您可以使用
OrderBy
或
ToDictionary
将“主”项放在第一位。但是，这将多次枚举您的序列。尤其是OrderBy会对项目进行多次比较，然后才发现它们在顺序上是相等的

但是，如果你只想把一个项目放在“家”的前面，为什么要比较所有这些项目呢

考虑为类创建一个扩展函数，通过只枚举一次来完成所需的操作。看

如果需要此泛型：将具有特定属性的项放在第一位的函数：

static IEnumerable<TSource> WhereItemFirst<TSource, TKey>(this IEnumerable<TSource> source,
       Func<TSource, TKey> keySelector,
       TKey keyValue,
       IEqualityComparer<TKey> keyComparer)
{
    // TODO: exception if source, keySelector, keyValue null

    // if keyComparer null, use default comparer to compare TKeys
    if (keyComparer == null) keyComparer = EqualityComparer<TKey>.Default;

    List<TSource> nonKeyItems = new List<TSource>();
    foreach(var item in source)
    {
        if (comparer.Equals(keySelector(item), keyValue))
        {
            // return the item with a value equal to keyValue
            yield return item;
        }
        else
        {
            nonKeyItems.Add(item);
        }
    }

    // return the nonKey items:
    foreach (var nonKeyItem in nonKeyItems) yield return nonKeyItem;
 }

参数
keySelector
从每个人的
地址中提取。将提取的
地址
与
我的地址
进行比较。如果匹配，则首先返回。
是，可以。你认为哪一个更快？谢谢我会使用.ToDictionary，因为代码更清晰，但我认为降序的顺序稍微快一点，如果速度真的很重要，我总是建议运行您自己的testsYes，这是可行的。你认为哪一个更快？谢谢我会使用.ToDictionary，因为代码更清晰，但我认为降序的顺序稍微快一点，如果速度真的很重要，我总是建议运行您自己的测试。我很糟糕，它没有很好的公式化。我想要的是整个序列每次都相等。谢谢你的回答！我的错是，它没有很好的表述。我想要的是整个序列每次都相等。谢谢你的回答！
var myAddress = GetMyAddress();
var persons = GetPersons();
var myFamilyFirst = persons.WhereItemFirst(person => person.Address, myAddress);