Shulou(Shulou.com)06/02 Report--

This article will explain in detail how to use MongoDB in the .NET Core detailed tutorials. The content of the article is of high quality, so the editor will share it with you for reference. I hope you will have some understanding of the relevant knowledge after reading this article.

Now let's take a look at document sorting, specify how to skip or limit the number of documents returned, and how to project.

Limit

When we query a document, we sometimes do not want to return all the documents that meet the filtering criteria, but only some of them. This is the specific application of the limit method. For MongoDB, you can limit the number of documents by calling the limit method of IFindFluent returned by Find. Therefore, if I query students under 40 years old in the database, I will get the following information:

S/N: 1 Id: 582489339798f091295b9094, FirstName: Gregor, LastName: Felix

S/N: 2 Id: 582489339798f091295b9095, FirstName: Machiko, LastName: Elkberg

S/N: 3 Id: 582489339798f091295b9096, FirstName: Julie, LastName: Sandal

S/N: 4 Id: 583da304f03a84d4d4f4678d, FirstName: Peter, LastName: Cyborg

To limit the result to a maximum of two students, I called the Limit () method and passed an argument with a value of 2:

Int count = 1

Await collection.Find (x = > x.Age)

< 40) .Limit(2) .ForEachAsync( student =>

{

Console.WriteLine ($"count N: {count}\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}")

Count++

});

Then you get the following output, which returns only two documents:

S/N: 1, Id: 582489339798f091295b9094, FirstName: Gregor, LastName: Felix

S/N: 2, Id: 582489339798f091295b9095, FirstName: Machiko, LastName: Elkberg

Skip

If we want to tell the database how many documents to skip, we use the skip method in the fluent interface. Therefore, it is similar to the code we used earlier, but tells the database to return all code under the age of 40 and skip the first one.

Int count = 1

Await collection.Find (x = > x.Age)

< 40) .Skip(1) .ForEachAsync( student =>

{

Console.WriteLine ($"count N: {count}\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}")

Count++

});

S/N: 1, Id: 582489339798f091295b9095, FirstName: Machiko, LastName: Elkberg

S/N: 2, Id: 582489339798f091295b9096, FirstName: Julie, LastName: Sandal

S/N: 3, Id: 583da304f03a84d4d4f4678d, FirstName: Peter, LastName: Cyborg

You'll notice that Gregor Felix was skipped. With skip and sort, we can add paging to our application.

Suppose we want to retrieve each student in the collection, showing up to two students on one page. We can achieve this through the following process:

Track the current page and the maximum number of documents to retrieve.

Determine the total number of pages.

Then retrieve the document and apply skip and limit accordingly.

We can do this using the following code and print the results of each page to the console:

Var client = new MongoClient ()

Var db = client.GetDatabase ("schoool")

Var collection = db.GetCollection ("students")

Int currentPage = 1, pageSize = 2

Double totalDocuments = await collection.CountAsync (FilterDefinition.Empty)

Var totalPages = Math.Ceiling (totalDocuments / pageSize)

For (int I = 1; I

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}")

Count++

});

Console.WriteLine ()

CurrentPage++

}

We get the following results in the console window:

Page 1

S/N: 1, Id: 58469c732adc9f5370e50c9c, FirstName: Gregor, LastName: Felix

S/N: 2, Id: 58469c732adc9f5370e50c9d, FirstName: Machiko, LastName: Elkberg

Page 2

S/N: 1, Id: 58469c732adc9f5370e50c9e, FirstName: Julie, LastName: Sandal

S/N: 2, Id: 58469c732adc9f5370e50c9f, FirstName: Peter, LastName: Cyborg

Page 3

S/N: 1, Id: 58469c732adc9f5370e50ca0, FirstName: James, LastName: Cyborg

In this way, we get three pages because we have a total of five records and retrieve up to two documents per page.

Sort

The Sort method of the fluent interface takes SortDefinition as a parameter, which can be implicitly converted from string or BsonDocument, just like FilterDefinition. Therefore, if we want to use a string as the sort definition, sorted by last name in ascending order, it will be:

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.Sort ("{LastName: 1}")

.ForEachAsync (

Student = >

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

In the string, we have {LastName:1}, where 1 tells it to sort in ascending order and-1 tells it to sort in descending order. If we run the application with the previously updated code, it returns James and Peter on the first page as a result, as shown below:

Page 1

S/N: 1, Id: 58469c732adc9f5370e50ca0, FirstName: James, LastName: Cyborg, Age: 39

S/N: 2, Id: 58469c732adc9f5370e50c9f, FirstName: Peter, LastName: Cyborg, Age: 39

Page 2

S/N: 1, Id: 58469c732adc9f5370e50c9d, FirstName: Machiko, LastName: Elkberg, Age: 23

S/N: 2, Id: 58469c732adc9f5370e50c9c, FirstName: Gregor, LastName: Felix, Age: 23

Page 3

S/N: 1, Id: 58469c732adc9f5370e50c9e, FirstName: Julie, LastName: Sandal, Age: 25

If we want to use BsonDocument to sort last names in descending order, this will be:

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.sort (new BsonDocument ("LastName",-1))

.ForEachAsync (

Student = >

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

The results contrary to the previous results are given.

Page 1

S/N: 1, Id: 58469c732adc9f5370e50c9e, FirstName: Julie, LastName: Sandal, Age: 25

S/N: 2, Id: 58469c732adc9f5370e50c9c, FirstName: Gregor, LastName: Felix, Age: 23

Page 2

S/N: 1, Id: 58469c732adc9f5370e50c9d, FirstName: Machiko, LastName: Elkberg, Age: 23

S/N: 2, Id: 58469c732adc9f5370e50ca0, FirstName: James, LastName: Cyborg, Age: 39

Page 3

S/N: 1, Id: 58469c732adc9f5370e50c9f, FirstName: Peter, LastName: Cyborg, Age: 39

We can also use SortDefinitionBuilder. Therefore, we can use the builder help method to update the code to create a sort definition, as follows:

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.sort (Builders.Sort.Descending ("LastName"))

.ForEachAsync (

Student = >

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

We can still get the same results, and we can also combine ascending and descending lists on different fields:

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.sort (Builders.Sort.Descending ("LastName") .Ascending ("FirstName"))

.ForEachAsync (

Student = >

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

Or when using strongly typed objects, use the expression tree:

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.sort (Builders.Sort.Descending (x = > x.LastName) .Ascending (x = > x.FirstName))

.ForEachAsync (

Student = >

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

We can also use the expression tree to specify methods for the SortBy, SortByDescending, ThenBy, and ThenByDescendingFLUENT interfaces. According to the previous example, this would be defined as:

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.SortByDescending (x = > x.LastName)

.ThenBy (x = > x.Age)

.ForEachAsync (

Student = >

{

Console.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

In most cases, we will use strongly typed objects because it is much easier to build queries using expression trees.

Projection projection

We can also use the Project method of the fluent interface for projection. We specify a projection similar to sorting and filtering.

Using an expression tree or projection definition results in a slightly different behavior. One of the differences is that when using projection definition syntax, you must explicitly tell it to exclude the _ id field, otherwise it will return it as part of the result set. Let's update the code and just return FirstName

Await collection.Find (FilterDefinition.Empty)

.Skip ((currentPage-1) * pageSize)

.Limit (pageSize)

.SortByDescending (x = > x.LastName)

.ThenBy (x = > x.Age)

.Project ("{FirstName: 1}")

.ForEachAsync (

Student = >

{

Debug.WriteLine ($"count N: {count},\ t Id: {student.Id}, FirstName: {student.FirstName}, LastName: {student.LastName}, Age: {student.Age}")

Count++

});

With the updated code, our application cannot be compiled. It gives us another difference: through the projection definition, it implicitly converts the document type from Student to bsondocument, so what we get is a fluent object, and the result will be a BsonDocument (even if we are using the Student type). If we want to work with Student, we must point out that we still want to keep the type as Student.

.Project ("{FirstName: 1}")

Therefore, by updating our code by setting Student to the type of method, we get the following output:

Page 1

S/N: 1, Id: 58469c732adc9f5370e50c9e, FirstName: Julie, LastName:, Age: 0

S/N: 2, Id: 58469c732adc9f5370e50c9c, FirstName: Gregor, LastName:, Age: 0

Page 2

S/N: 1, Id: 58469c732adc9f5370e50c9d, FirstName: Machiko, LastName:, Age: 0

S/N: 2, Id: 58469c732adc9f5370e50ca0, FirstName: James, LastName:, Age: 0

Page 3

S/N: 1, Id: 58469c732adc9f5370e50c9f, FirstName: Peter, LastName:, Age: 0

As you can see, although we only need FirstName, FirstName and Id are returned, while others remain at default values. To solve this problem, we explicitly told it to exclude the Id field and update the projection definition as follows:

.Project ("{FirstName: 1, _ id: 0}")

Then run it, and we just return FirstName, while the other values remain at default values:

Page 1

S/N: 1, Id: 000000000000000000000000, FirstName: Julie, LastName:, Age: 0

S/N: 2, Id: 000000000000000000000000, FirstName: Gregor, LastName:, Age: 0

Page 2

S/N: 1, Id: 000000000000000000000000, FirstName: Machiko, LastName:, Age: 0

S/N: 2, Id: 000000000000000000000000, FirstName: James, LastName:, Age: 0

Page 3

S/N: 1, Id: 000000000000000000000000, FirstName: Peter, LastName:, Age: 0

We can also use the projection generator. .Project (Builders.Projection.Include (x = > x.FirstName) .Exclude (x = > x.Id)) this is similar to sorting and filtering using a definition generator. We can also use the expression tree for projection and then project it to different results. The following code returns only first and last name and maps them to anonymous types:

Int count = 1

Await collection.Find (FilterDefinition.Empty)

.Project (x = > new {x.FirstName, x.LastName})

.ForEachAsync (

Student = >

{

Console.WriteLine ($"{count}.\ t FirstName: {student.FirstName}-LastName {student.LastName}")

Count++

});

Console.WriteLine ()

1. FirstName: Gregor-LastName Felix

2. FirstName: Machiko-LastName Elkberg

3. FirstName: Julie-LastName Sandal

4. FirstName: Peter-LastName Cyborg

5. FirstName: James-LastName Cyborg

You may have noticed that we do not explicitly indicate that we want to exclude Id, but are different from another approach, because in the strongly typed expression tree, it agrees to return only those fields that you specify and exclude other fields.

This is the end of the detailed tutorial on how to use MongoDB in .NET Core. I hope the above content can be of some help and learn more. If you think the article is good, you can share it for more people to see.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.