问题

Here's the translated code part you requested:

假设我有一个类

```csharp
public class Movie
{
    public string Title { get; set; }
    public string Genre { get; set; }
    public int Rating { get; set; }
}

和一个电影文本文件，它将被解析为一个 List<Movie>

The_Godfather 动作 96
The_Dark_Knight 戏剧 24
Cleopatra 喜剧 61
Sabotage 动作 88
Inception 戏剧 86
The_Matrix 喜剧 14
Life_Is_Beautiful 戏剧 19
City_of_God 恐怖 12
Raven 喜剧 30
Breaking_Wind 喜剧 59
City_Lights 纪录片 46
Born_Wild 戏剧 55

和一个函数

public static Dictionary<string, Movie> HighestRatingForEachGenre(List<Movie> movies)

我想要按流派分组，然后为每个流派返回标题和电影对象。

我可以轻松地使用 foreach 循环来完成这个任务。

我对 LINQ 还不太熟悉，不知道从哪里开始。

基本方法如下：

Dictionary<string, Movie> result = new Dictionary<string, Movie>();
foreach (Movie movie in movies)
{
    if (result.ContainsKey(movie.Genre))
    {
        if (result[movie.Genre].Rating < movie.Rating) result.Remove(movie.Genre);
        else continue;
    }
    result.Add(movie.Genre, movie);
}
return result;

<details>
<summary>英文:</summary>

Suppose I have a class 

public class Movie
{
public string Title { get; set; }
public string Genre { get; set; }
public int Rating { get; set; }
}

and a text file of movies, that'll be parse into a list<Movie>

The_Godfather Action 96
The_Dark_Knight Drama 24
Cleopatra Comedy 61
Sabotage Action 88
Inception Drama 86
The_Matrix Comedy 14
Life_Is_Beautiful Drama 19
City_of_God Horror 12
Raven Comedy 30
Breaking_Wind Comedy 59
City_Lights Documentary 46
Born_Wild Drama 55

and a function 

public static Dictionary<string, Movie> HighestRatingForEachGenre(List<Movie> movies)

<strike>I want to return the highest rating for each genre using LINQ.</strike> 

I want to group by genre then return a title and movie object for each genre.

I could do this with a foreach loop easily.
 
I'm still new to LINQ and have no idea where to look. 


basic approach

        Dictionary<string, Movie> result = new Dictionary<string, Movie>();
        foreach (Movie movie in movies)
        {
            if (result.ContainsKey(movie.Genre))
            {
                if (result[movie.Genre].Rating < movie.Rating) result.Remove(movie.Genre);
                else continue;
            }
            result.Add(movie.Genre, movie);
        }
        return result;

</details>


# 答案1
**得分**: 2

为了获得您期望的结果，您的LINQ表达式需要依次执行三个操作：

1. 按类型对电影进行分组
2. 从每个组中提取最高评分的电影
3. 将结果集映射到一个字典中

第一步是按类型对电影进行分组，可以使用 `movies.GroupBy(m => m.Genre)` 完成。这将生成一个组的集合，每个组都有 (1) 一个共同的类型作为键 和 (2) 一个包含共同类型的电影的集合。`m => m.Genre` 部分是一个 *lambda函数*，选择了定义所需分组的属性。

接下来，在每个组内，您希望选择评分最高的电影。可以通过结合使用 `Select(...)`, `.OrderBy(...)` 和 `.First()` 来完成，如 `.Select(grp => grp.OrderByDescending(m => m.Rating).First())`。

最后，`.ToDictionary(...)` 可以构建结果的字典，指定 `m => m.Genre` 作为字典键选择器。

将所有这些组合在一起如下：

```csharp
var highestRatingForEachGenre = movies
    .GroupBy(m => m.Genre)
    .Select(grp => grp.OrderByDescending(m => m.Rating).First())
    .ToDictionary(m => m.Genre);

（最后两行实际上可以在 .ToDictionary() 函数的一个更高级的形式中合并，但我认为将它们作为单独的步骤更容易阅读和理解。）

以上使用了LINQ的方法语法来执行操作。也可以使用LINQ的查询语法来完成相同的操作。（由于我很少使用查询语法，所以无法立即提供一个快速的示例。）

我建议您阅读每个使用的方法的文档，以便了解上述操作的工作原理。

var highestRatingForEachGenre = movies
    .GroupBy(m => m.Genre)
    .Select(grp => grp.OrderByDescending(m => m.Rating).First())
    .ToDictionary(m => m.Genre);

答案2

得分: 1

GroupBy 返回一个由分组组成的 IEnumerable<T>。每个分组本身是一个包含在该分组中的元素的 IEnumerable<T>，而每个分组还具有一个 Key - 用于标识每个分组的值。这是您进行分组的属性。

可通过使用 ToDictionary 将可枚举的分组序列转换为所需的字典，其中分组的键是键，而具有最高评分的电影是值。要获取具有最高评分的电影，您可以在 .NET 6+ 中使用 MaxBy。

Dictionary<string, Movie> HighestRatingForEachGenre(List<Movie> movies) =>
    return movies.GroupBy(x => x.Genre)
               .ToDictionary(
                   g => g.Key, // 字典的键是分组的键
                   g => g.MaxBy(m => m.Rating) // 字典的值按此计算
               );

Dictionary<string, Movie> HighestRatingForEachGenre(List<Movie> movies) =>
    return movies.GroupBy(x => x.Genre)
               .ToDictionary(
                   g => g.Key, // dictionary's key is the group's key
                   g => g.MaxBy(m => m.Rating) // dictionary's value is computed like this
               );

答案3

得分: -1

我会稍微修改@T N的答案：

var 每个类型的最高评分 = 电影.GroupBy(s => s.类型).Select(s => new
{
    s.Key,
    最高评分 = s.Max(r => r.评分)
}).ToDictionary(s => s.Key, s => s.最高评分);

foreach (var 电影 in x)
{
    Console.WriteLine($"在{电影.Key}中最高评分是{电影.Value}");
}

将OrderBy和First合并为单个Max调用。

var highestRatingForEachGenre  = movies.GroupBy(s => s.Genre).Select(s => new
{
    s.Key,
    MaxRating = s.Max(r => r.Rating)
}).ToDictionary(s => s.Key, s => s.MaxRating);

foreach (var movie in x)
{
    Console.WriteLine($"Highest rating in {movie.Key} is {movie.Value}" );
}