Fundamentos do pipeline de agregação do MongoDB C#

1
{
2
  "_id": ObjectId("573a139af29313caabcef0ad"),
3
  "imdb": {
4
    "rating": 8.2,
5
    "votes": 297933,
6
    "id": 112641
7
  },
8
  "year": 1995,
9
  "title": "Casino",
10
  "cast": [
11
    "Robert De Niro",
12
    "Sharon Stone",
13
    "Joe Pesci",
14
    "James Woods"
15
  ]
16
}

1
[
2
  {
3
    $match: {
4
      cast: "Robert De Niro"
5
    }
6
  },
7
  {
8
    $group: {
9
      _id: "$year",
10
      rating: { $avg: "$imdb.rating" }
11
    }
12
  },
13
  {
14
    $sort: {
15
      rating: -1
16
    }
17
  }
18
]

1
[
2
  {
3
    "_id": 1974,
4
    "rating": 9.1
5
  },
6
  {
7
    "_id": 1980,
8
    "rating": 8.3
9
  },
10
  {
11
    "_id": 1995,
12
    "rating": 8.25
13
  },
14
  {
15
    "_id": 1990,
16
    "rating": 8.25
17
  },
18
// ...
19
]

1
[BsonIgnoreExtraElements]
2
[BsonNoId]
3
public class Movie
4
{
5
    [BsonElement("title")]
6
    public required string Title { get; set; }
7
8
    [BsonElement("year")]
9
    public required int Year { get; set; }
10
11
    [BsonElement("cast")]
12
    public List<string> Cast { get; set; } = new();
13
14
    [BsonElement("imdb")]
15
    public Imdb Imdb { get; set; } = new();
16
}
17
18
[BsonIgnoreExtraElements]
19
public class Imdb
20
{
21
    [BsonElement("rating")]
22
    public double Rating { get; set; }
23
}
24
25
public class RatingByYear
26
{
27
    public int Year { get; set; }
28
29
    public double AvgRating { get; set; }
30
}

1
var pipeline = new EmptyPipelineDefinition<Movie>()
2
    .Match(x => x.Cast.Contains("Robert De Niro"))
3
    .Group(
4
        x => x.Year, 
5
        x => new RatingByYear() 
6
        { 
7
            Year = x.Key, 
8
            AvgRating = x.Average(y => y.Imdb.Rating)
9
        })
10
    .Sort(Builders<RatingByYear>.Sort.Descending(x => x.AvgRating));
11
var result = await (await movies.AggregateAsync(pipeline)).ToListAsync();

1
var result = await movies
2
    .Aggregate()
3
    .Match(x => x.Cast.Contains("Robert De Niro"))
4
    .Group(
5
        x => x.Year,
6
        x => new RatingByYear()
7
        {
8
            Year = x.Key,
9
            AvgRating = x.Average(y => y.Imdb.Rating)
10
        })
11
    .Sort(Builders<RatingByYear>.Sort.Descending(x => x.AvgRating))
12
    .ToListAsync();

1
var result = movies
2
    .AsQueryable()
3
    .Where(x => x.Cast.Contains("Robert De Niro"))
4
    .GroupBy(x => x.Year)
5
    .Select(x => new RatingByYear()
6
    {
7
        Year = x.Key,
8
        AvgRating = x.Average(y => y.Imdb.Rating)
9
    })
10
    .OrderByDescending(x => x.AvgRating)
11
    .ToList();

1
var result = (from m in movies.AsQueryable()
2
             where m.Cast.Contains("Robert De Niro")
3
             group m by m.Year into grp
4
             select new RatingByYear()
5
             {
6
                 Year = grp.Key,
7
                 AvgRating = grp.Average(y => y.Imdb.Rating)
8
             }
9
             into x
10
             orderby x.AvgRating descending
11
             select x)
12
             .ToList();