LINQ：如何返回与 min() 不同的字段

Question

我正在使用列表 (masterList) 中的 IEnumerable 字典 (data.Tags)。

这是我正在做的一个典型查询（有效）：

var tagList = 
    (from data in masterList
    from tag in data.Tags
    where tag.id == 0x10
    select tag).Distinct(new TagComparer());

tag 类具有字段Id、Value 和TranslatedValue。我想根据Id 进行搜索，使用Value 确定哪个是最小值，然后返回TranslatedValue（而不是Value）。

到目前为止，我的所有尝试都会抛出 ArgumentException，例如：

var tagList = 
    (from data in masterList
    from tag in data.Tags
    where tag.id == 0x10
    select new
    {
       tag.Value,
       tag.TranslatedValue
    };
return tagList.Min().TranslatedValue;

有没有优雅的解决方案？

Answer 1

您可以使用OrderBy 对元素进行升序排序（将最小值放在第一位），Select 获取您的翻译值，然后使用First 获取该最小元素：

var minVal = (from data in masterList 
             from tag in data.Tags
             where tag.id == 0x10
             select tag)
             .Distinct(new TagComparer())
             .OrderBy(t => t.Value) // lowest value will be first in the list
             .First() // take the first element, which is the min
             .TranslatedValue

Answer 2

当我之前遇到这个确切问题时，我的回答比这里的其他人更复杂一些，但它在这些情况下工作得很好并且性能更高一些；开发一个 ObjectWithMin() 扩展方法，该方法将返回包含指定投影最小值的整个对象。这是一个基本算法；它只迭代可枚举一次并线性执行而不是在 nlogn-time 中执行：

public static T ObjectWithMin<T, TResult>(this IEnumerable<T> elements, Func<T, TResult> projection)
        where TResult : IComparable<TResult>
    {
        if (elements == null) throw new ArgumentNullException("elements", "Sequence is null.");
        if (!elements.Any()) throw new ArgumentException("Sequence contains no elements.");

        var seed = elements.Select(t => new { Object = t, Projection = projection(t) }).First();

        return elements.Aggregate(seed,
                                  (s, x) =>
                                  projection(x).CompareTo(s.Projection) < 0
                                      ? new {Object = x, Projection = projection(x)}
                                      : s
            ).Object;
    }

用法：

var tagList = 
    (from data in masterList
    from tag in data.Tags
    where tag.id == 0x10
    select new
    {
       tag.Value,
       tag.TranslatedValue
    };
return tagList.ObjectWithMin(x=>x.Value).TranslatedValue;

Answer 3

您可以使用custom MinElement extension that was posted here

Answer 4

您可以为您的标记类实现IComparable<T>，并将比较基于Value 属性。然后，您可以选择最小标签并从中获取TranslatedValue，而不是选择最小的Value。

一些代码来说明我的意思：

class tag : IComparable<tag>
{
    public int Id { get; set; }

    public int Value { get; set; }

    public int TranslatedValue { get; set; }

    public int CompareTo(tag other)
    {
        if (other.Value > this.Value)
            return -1;
        if (other.Value < this.Value)
            return 1;
        return 0;
    }

    public override string ToString()
    {
        return string.Format("Id:{0}, Value: {1}, TranslatedValue: {2}", Id, Value, TranslatedValue);
    }
}

这会将您的标记类设置为实现IComparable<T>。要使用它来获取TranslatedValue，它很简单：

int minTranslatedValue = tags.Min().TranslatedValue;

其中tags 是某种IEnumerable<Tag> 集合。

Answer 5

您应该能够按一个属性排序，获取第一项，然后获取另一个属性：

return
  masterList
  .SelectMany(data => data.Tags)
  .Where(tag => tag.id == 0x10)
  .OrderBy(tag => tag.Value)
  .First()
  .TranslatedValue;