Question

我有以下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);

这将返回我要查找的内容，但是此列表的顺序由它在数据库中找到对象的顺序给出。

我想将查询结果解析为模型，还是将query [0]始终设为= home。

我可以分别询问值，但这似乎效率很低。

Answer 1

您可以使用：

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

使output [0]返回起始位置标识符的文本，或者：

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

这样您就可以输出output [“ home”]。Text，输出output [“ CV”]。Text等。

Answer 2

要求：我想将查询结果解析为模型还是将查询[0]始终设为= home。

就像其他人说的那样，您可以使用OrderBy或ToDictionary将“家庭”物品放在第一位。但是，这将多次枚举您的序列。特别是OrderBy会在发现它们在Order中相等之前对其进行几次比较。

但是，如果您只想将一个项目放在“首页”上，为什么还要比较所有这些项目？

考虑为您的类创建一个扩展函数，该函数将仅枚举一次即可完成您想要的操作。参见Extension Methods Demystified

static IEnumerable<string>PutWordFirst(this IEnumerable<string> source, string word)
{
     List<string> nonWords = new List<string>();
     foreach(var text in source)
     {
         if (text == word)
         {
            yield return word;
         }
         else
         {
            nonWords.Add(text);
         }
    }

    foreach (var nonWord in nonWords) yield return nonWord;
 }

用法：

var query = query = context.MapTextToLanguages
    .Where(language => ...)
    .Select(language => ...)
    .PutWordFirst("home");

如果要使用此泛型：此函数首先将具有特定属性的项目放进去：

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;
 }

以及没有比较器的版本：

static IEnumerable<TSource> WhereItemFirst<TSource, TKey>(this IEnumerable<TSource> source,
       Func<TSource, TKey> keySelector, TKey keyValue)
{
    // call the function above with null comparer, uses the default comparer
    return source.WhereItemFirst(keySelector, keyValue, null);
}

用法：将住在我住址的人放在首位：

var myAddress = GetMyAddress();
var persons = GetPersons();
var myFamilyFirst = persons.WhereItemFirst(person => person.Address, myAddress);

参数keySelector从每个人中提取他的Address。将提取的Address与myAddress进行比较。如果匹配，则首先返回。

解析数据库LINQ的结果

2 个答案: