In this session, we will build a data-driven ASP.NET web app using the MongoDB driver to connect to MongoDB Atlas. You will learn how to incorporate the driver in your project and use both standard CRUD methods and the Aggregation Framework to work with the data.

We will keep this project small enough that attendees can follow along on their own laptops if they want (but they must have Visual Studio 2019 installed ahead of time). This session assumes only a basic familiarity with C# and MongoDB.

CSharp

Build an ASP.NET app with the Mongo C# Driver

Nic Raboy

If you've been keeping up with my development content, you'll remember that I recently wrote [Build Your First .NET Core Application with MongoDB Atlas](https://www.mongodb.com/developer/how-to/build-first-dotnet-core-application-mongodb-atlas/), which focused on building a console application that integrated with MongoDB. While there is a fit for MongoDB in console applications, many developers are going to find it more valuable in web applications.

In this tutorial, we're going to expand upon the previous and create a RESTful API with endpoints that perform basic create, read, update, and delete (CRUD) operations against MongoDB Atlas.

## The Requirements

To be successful with this tutorial, you'll need to have a few things taken care of first:

- A deployed and configured MongoDB Atlas cluster, M0 or higher
- .NET Core 6+

We won't go through the steps of deploying a MongoDB Atlas cluster or configuring it with user and network rules. If this is something you need help with, check out a [previous tutorial](https://www.mongodb.com/developer/article/5-different-ways-deploy-free-database-mongodb-atlas/) that was published on the topic.

We'll be using .NET Core 6.0 in this tutorial, but other versions may still work. Just take the version into consideration before continuing.

## Create a Web API Project with the .NET Core CLI

To kick things off, we're going to create a fresh .NET Core project using the web application template that Microsoft offers. To do this, execute the following commands from the CLI:

```bash
dotnet new webapi -o MongoExample
cd MongoExample
dotnet add package MongoDB.Driver
```

The above commands will create a new web application project for .NET Core and install the latest MongoDB driver. We'll be left with some boilerplate files as part of the template, but we can remove them.

Inside the project, delete any file related to `WeatherForecast` and similar.

## Designing a Document Model and Database Service within .NET Core

Before we start designing each of the RESTful API endpoints with .NET Core, we need to create and configure our MongoDB service and define the data model for our API.

We'll start by working on our MongoDB service, which will be responsible for establishing our connection and directly working with documents within MongoDB. Within the project, create "Models/MongoDBSettings.cs" and add the following C# code:

```csharp
namespace MongoExample.Models;

public class MongoDBSettings {

    public string ConnectionURI { get; set; } = null!;
    public string DatabaseName { get; set; } = null!;
    public string CollectionName { get; set; } = null!;

}
```

The above `MongoDBSettings` class will hold information about our connection, the database name, and the collection name. The data we plan to store in these class fields will be found in the project's "appsettings.json" file. Open it and add the following:

```json
{
    "Logging": {
        "LogLevel": {
            "Default": "Information",
            "Microsoft.AspNetCore": "Warning"
        }
    },
    "AllowedHosts": "*",
    "MongoDB": {
        "ConnectionURI": "ATLAS_URI_HERE",
        "DatabaseName": "sample_mflix",
        "CollectionName": "playlist"
    }
}
```

Specifically take note of the `MongoDB` field. Just like with the [previous example project](https://www.mongodb.com/developer/how-to/build-first-dotnet-core-application-mongodb-atlas/), we'll be using the "sample_mflix" database and the "playlist" collection. You'll need to grab the `ConnectionURI` string from your MongoDB Atlas Dashboard.

![MongoDB Atlas Connection String](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_atlas_connection_string_801c3bdc01.jpg "MongoDB Atlas Connection String")

With the settings in place, we can move onto creating the service.

Create "Services/MongoDBService.cs" within your project and add the following:

```csharp
using MongoExample.Models;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using MongoDB.Bson;

namespace MongoExample.Services;

public class MongoDBService {

    private readonly IMongoCollection<Playlist> _playlistCollection;

    public MongoDBService(IOptions<MongoDBSettings> mongoDBSettings) {
        MongoClient client = new MongoClient(mongoDBSettings.Value.ConnectionURI);
        IMongoDatabase database = client.GetDatabase(mongoDBSettings.Value.DatabaseName);
        _playlistCollection = database.GetCollection<Playlist>(mongoDBSettings.Value.CollectionName);
    }

    public async Task<List<Playlist>> GetAsync() { }
    public async Task CreateAsync(Playlist playlist) { }
    public async Task AddToPlaylistAsync(string id, string movieId) {}
    public async Task DeleteAsync(string id) { }

}
```

In the above code, each of the asynchronous functions were left blank on purpose. We'll be populating those functions as we create our endpoints. Instead, make note of the constructor method and how we're taking the passed settings that we saw in our "appsettings.json" file and setting them to variables. In the end, the only variable we'll ever interact with for this example is the `_playlistCollection` variable.

With the service available, we need to connect it to the application. Open the project's "Program.cs" file and add the following at the top:

```csharp
using MongoExample.Models;
using MongoExample.Services;

var builder = WebApplication.CreateBuilder(args);

builder.Services.Configure<MongoDBSettings>(builder.Configuration.GetSection("MongoDB"));
builder.Services.AddSingleton<MongoDBService>();
```

You'll likely already have the `builder` variable in your code because it was part of the boilerplate project, so don't add it twice. What you'll need to add near the top is an import to your custom models and services as well as configuring the service.

Remember the `MongoDB` field in the "appsettings.json" file? That is the section that the `GetSection` function is pulling from. That information is passed into the singleton service that we created.

With the service created and working, with the exception of the incomplete asynchronous functions, we can focus on creating a data model for our collection.

Create "Models/Playlist.cs" and add the following C# code:

```csharp
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;

namespace MongoExample.Models;

public class Playlist {

    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string? Id { get; set; }

    public string username { get; set; } = null!;

    [BsonElement("items")]
    [JsonPropertyName("items")]
    public List<string> movieIds { get; set; } = null!;

}
```

There are a few things happening in the above class that take it from a standard C# class to something that can integrate seamlessly into a MongoDB document.

First, you might notice the following:

```csharp
[BsonId]
[BsonRepresentation(BsonType.ObjectId)]
public string? Id { get; set; }
```

We're saying that the `Id` field is to be represented as an ObjectId in BSON and the `_id` field within MongoDB. However, when we work with it locally in our application, it will be a string.

The next thing you'll notice is the following:

```csharp
[BsonElement("items")]
[JsonPropertyName("items")]
public List<string> movieIds { get; set; } = null!;
```

Even though we plan to work with `movieIds` within our C# application, in MongoDB, the field will be known as `items` and when sending or receiving JSON, the field will also be known as `items` instead of `movieIds`.

You don't need to define custom mappings if you plan to have your local class field match the document field directly. Take the `username` field in our example. It has no custom mappings, so it will be `username` in C#, `username` in JSON, and `username` in MongoDB.

Just like that, we have a MongoDB service and document model for our collection to work with for .NET Core.

## Building CRUD Endpoints that Interact with MongoDB Using .NET Core

When building CRUD endpoints for this project, we'll need to bounce between two different locations within our project. We'll need to define the endpoint within a controller and do the work within our service.

Create "Controllers/PlaylistController.cs" and add the following code:

```csharp
using System;
using Microsoft.AspNetCore.Mvc;
using MongoExample.Services;
using MongoExample.Models;

namespace MongoExample.Controllers; 

[Controller]
[Route("api/[controller]")]
public class PlaylistController: Controller {
    
    private readonly MongoDBService _mongoDBService;

    public PlaylistController(MongoDBService mongoDBService) {
        _mongoDBService = mongoDBService;
    }

    [HttpGet]
    public async Task<List<Playlist>> Get() {}

    [HttpPost]
    public async Task<IActionResult> Post([FromBody] Playlist playlist) {}

    [HttpPut("{id}")]
    public async Task<IActionResult> AddToPlaylist(string id, [FromBody] string movieId) {}

    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(string id) {}

}
```

In the above `PlaylistController` class, we have a constructor method that gains access to our singleton service class. Then we have a series of endpoints for this particular controller. We could add far more endpoints than this to our controller, but it's not necessary for this example.

Let's start with creating data through the POST endpoint. To do this, it's best to start in the "Services/MongoDBService.cs" file:

```csharp
public async Task CreateAsync(Playlist playlist) {
    await _playlistCollection.InsertOneAsync(playlist);
    return;
}
```

We had set the `_playlistCollection` in the constructor method of the service, so we can now use the `InsertOneAsync` method, taking a passed `Playlist` variable and inserting it. Jumping back into the "Controllers/PlaylistController.cs," we can add the following:

```csharp
[HttpPost]
public async Task<IActionResult> Post([FromBody] Playlist playlist) {
    await _mongoDBService.CreateAsync(playlist);
    return CreatedAtAction(nameof(Get), new { id = playlist.Id }, playlist);
}
```

What we're saying is that when the endpoint is executed, we take the `Playlist` object from the request, something that .NET Core parses for us, and pass it to the `CreateAsync` function that we saw in the service. After the insert, we return some information about the interaction.

It's important to note that in this example project, we won't be validating any data flowing from HTTP requests.

Let's jump to the read operations.

Head back into the "Services/MongoDBService.cs" file and add the following function:

```csharp
public async Task<List<Playlist>> GetAsync() {
    return await _playlistCollection.Find(new BsonDocument()).ToListAsync();
}
```

The above `Find` operation will return all documents that exist in the collection. If you wanted to, you could make use of the `FindOne` or provide filter criteria to return only the data that you want. We'll explore filters shortly.

With the service function ready, add the following endpoint to the "Controllers/PlaylistController.cs" file:

```csharp
[HttpGet]
public async Task<List<Playlist>> Get() {
    return await _mongoDBService.GetAsync();
}
```

Not so bad, right? We'll be doing the same thing for the other endpoints, more or less.

The next CRUD stage to take care of is the updating of data. Within the "Services/MongoDBService.cs" file, add the following function:

```csharp
public async Task AddToPlaylistAsync(string id, string movieId) {
    FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("Id", id);
    UpdateDefinition<Playlist> update = Builders<Playlist>.Update.AddToSet<string>("movieIds", movieId);
    await _playlistCollection.UpdateOneAsync(filter, update);
    return;
}
```

Rather than making changes to the entire document, we're planning on adding an item to our playlist and nothing more. To do this, we set up a match filter to determine which document or documents should receive the update. In this case, we're matching on the id which is going to be unique. Next, we're defining the update criteria, which is an `AddToSet` operation that will only add an item to the array if it doesn't already exist in the array.

The `UpdateOneAsync` method will only update one document even if the match filter returned more than one match.

In the "Controllers/PlaylistController.cs" file, add the following endpoint to pair with the `AddToPlayListAsync` function:

```csharp
[HttpPut("{id}")]
public async Task<IActionResult> AddToPlaylist(string id, [FromBody] string movieId) {
    await _mongoDBService.AddToPlaylistAsync(id, movieId);
    return NoContent();
}
```

In the above PUT endpoint, we are taking the `id` from the route parameters and the `movieId` from the request body and using them with the `AddToPlaylistAsync` function.

This brings us to our final part of the CRUD spectrum. We're going to handle deleting of data.

In the "Services/MongoDBService.cs" file, add the following function:

```csharp
public async Task DeleteAsync(string id) {
    FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("Id", id);
    await _playlistCollection.DeleteOneAsync(filter);
    return;
}
```

The above function will delete a single document based on the filter criteria. The filter criteria, in this circumstance, is a match on the id which is always going to be unique. Your filters could be more extravagant if you wanted.

To bring it to an end, the endpoint for this function would look like the following in the "Controllers/PlaylistController.cs" file:

```csharp
[HttpDelete("{id}")]
public async Task<IActionResult> Delete(string id) {
    await _mongoDBService.DeleteAsync(id);
    return NoContent();
}
```

We only created four endpoints, but you could take everything we did and create 100 more if you wanted to. They would all use a similar strategy and can leverage everything that MongoDB has to offer.

## Conclusion

You just saw how to create a simple four endpoint RESTful API using .NET Core and MongoDB. This was an expansion to the [previous tutorial](https://www.mongodb.com/developer/how-to/build-first-dotnet-core-application-mongodb-atlas/), which went over the same usage of MongoDB, but in a console application format rather than web application.

Like I mentioned, you can take the same strategy used here and apply it towards more endpoints, each doing something critical for your web application.

Got a question about the driver for .NET? Swing by the [MongoDB Community Forums](https://community.mongodb.com)!

Learn how to create a RESTful web API with .NET Core that interacts with MongoDB through each of its endpoints.

Create a RESTful API with .NET Core and MongoDB

Robert Walters

>Update 10/2019: This article's code example has been updated to include
the required handing of the session handle to database methods.

<div class="introduction">

C# applications connected to a MongoDB database use the MongoDB .NET driver. To add the .NET driver to your Visual Studio Application, in the NuGet Package Manager, search for "MongoDB".

<figure>
<img src="https://www.mongodb.com/developer/images/driverdownload.png" width="300" />
</figure>

Make sure you choose the latest version (>=2.7) of the driver, and press *Install*.

Prior to MongoDB version 4.0, MongoDB was transactionally consistent at the document level. These existing atomic single-document operations provide the transaction semantics to meet the data integrity needs of the majority of applications. This is because the flexibility of the document model allows developers to easily embed related data for an entity as arrays and sub-documents within a single, rich document. That said, there are some cases where splitting the content into two or more collections would be appropriate, and for these cases, [multi-document ACID transactions](https://www.mongodb.com/transactions) makes it easier than ever for developers to address the full spectrum of use cases with MongoDB. For a deeper discussion on MongoDB document model design, including how to represent one-to-many and many-to-many relationships, check out [this article on data model design](https://docs.mongodb.com/manual/core/data-model-design).

In the following code we will create a Product object and perform a MongoDB transaction that will insert some sample data into MongoDB then update the prices for all products by 10%.

``` csp
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver;
using System;
using System.Threading.Tasks;

namespace MongoDBTransaction
{
    public static class Program
    {
        public class Product
        {
            [BsonId]
            public ObjectId Id { get; set; }
            [BsonElement("SKU")]
            public int SKU { get; set; }
            [BsonElement("Description")]
            public string Description { get; set; }
            [BsonElement("Price")]
            public Double Price { get; set; }
        }

        // replace with your connection string if it is different
        const string MongoDBConnectionString = "mongodb://localhost"; 

        public static async Task Main(string[] args)
        {
            if (!await UpdateProductsAsync()) { Environment.Exit(1); }
            Console.WriteLine("Finished updating the product collection");
            Console.ReadKey();
        }

        private static async Task<bool> UpdateProductsAsync()
        {
            // Create client connection to our MongoDB database
            var client = new MongoClient(MongoDBConnectionString);

            // Create the collection object that represents the "products" collection
            var database = client.GetDatabase("MongoDBStore");
            var products = database.GetCollection<Product>("products");

            // Clean up the collection if there is data in there
            await database.DropCollectionAsync("products");

            // collections can't be created inside a transaction so create it first
            await database.CreateCollectionAsync("products"); 

            // Create a session object that is used when leveraging transactions
            using (var session = await client.StartSessionAsync())
            {
                // Begin transaction
                session.StartTransaction();

                try
                {
                    // Create some sample data
                    var tv = new Product { Description = "Television", 
                                    SKU = 4001, 
                                    Price = 2000 };
                    var book = new Product { Description = "A funny book", 
                                    SKU = 43221, 
                                    Price = 19.99 };
                    var dogBowl = new Product { Description = "Bowl for Fido", 
                                    SKU = 123, 
                                    Price = 40.00 };

                    // Insert the sample data 
                    await products.InsertOneAsync(session, tv);
                    await products.InsertOneAsync(session, book);
                    await products.InsertOneAsync(session, dogBowl);

                    var resultsBeforeUpdates = await products
                                    .Find<Product>(session, Builders<Product>.Filter.Empty)
                                    .ToListAsync();
                    Console.WriteLine("Original Prices:\n");
                    foreach (Product d in resultsBeforeUpdates)
                    {
                        Console.WriteLine(
                                    String.Format("Product Name: {0}\tPrice: {1:0.00}", 
                                        d.Description, d.Price)
                        );
                    }

                    // Increase all the prices by 10% for all products
                    var update = new UpdateDefinitionBuilder<Product>()
                            .Mul<Double>(r => r.Price, 1.1);
                    await products.UpdateManyAsync(session, 
                            Builders<Product>.Filter.Empty, 
                            update); //,options);

                    // Made it here without error? Let's commit the transaction
                    await session.CommitTransactionAsync();
                }
                catch (Exception e)
                {
                    Console.WriteLine("Error writing to MongoDB: " + e.Message);
                    await session.AbortTransactionAsync();
                    return false;
                }

                // Let's print the new results to the console
                Console.WriteLine("\n\nNew Prices (10% increase):\n");
                var resultsAfterCommit = await products
                        .Find<Product>(session, Builders<Product>.Filter.Empty)
                        .ToListAsync();
                foreach (Product d in resultsAfterCommit)
                {
                    Console.WriteLine(
                        String.Format("Product Name: {0}\tPrice: {1:0.00}", 
                                                    d.Description, d.Price)
                    );
                }

                return true;
            }
        }
    }
}
```

Source Code available on [Gist](https://gist.github.com/codepope/1366893d703a0be57953545619e87eea). Successful execution yields the following:

<figure>
<img src="https://www.mongodb.com/developer/images/ExecutionResults-5aao2jdet7.png" width="400" />
</figure>

## Key points:

-   You don't have to match class properties to JSON objects - just define a class object and insert it directly into the database. There is no need for an Object Relational Mapper (ORM) layer.
-   MongoDB transactions use snapshot isolation meaning only the client involved in the transactional session sees any changes until such time as the transaction is committed.
-   The MongoDB .NET Driver makes it easy to leverage transactions and leverage LINQ based syntax for queries.

Additional information about using C# and the .NET driver can be found in the [C# and .NET MongoDB Driver](https://docs.mongodb.com/ecosystem/drivers/csharp/) documentation.

Walk through an example of how to use transactions in C#.

Working with MongoDB Transactions with C# and the .NET Framework

Adrienne Tacke

# Introducing the MongoDB Analyzer for .NET
Correct code culprits at compile time!

As C# and .NET developers, we know that it can sometimes be frustrating to work idiomatically with MongoDB queries and aggregations. Without a way to see if your LINQ query or Builder expression corresponds to the [MongoDB Query API](https://www.mongodb.com/mongodb-query-api) (formerly known as MQL) during development, you previously had to wait for runtime errors in order to troubleshoot your queries. We knew there had to be a way to work more seamlessly with C# and MongoDB.

That’s why we’ve built the [MongoDB Analyzer for .NET](https://docs.mongodb.com/mongodb-analyzer/current/)! Instead of mentally mapping the idiomatic version of your query in C# to the MongoDB Query API, the MongoDB Analyzer can do it for you - and even provide the generated Query API expression right in your IDE. The MongoDB Analyzer even surfaces useful information and helpful warnings on invalid expressions at compile time, bringing greater visibility to the root causes of bugs. And when used together with the recently released [LINQ3](https://mongodb.github.io/mongo-csharp-driver/2.14/reference/driver/crud/linq3/) provider (now supported in [MongoDB C#/.NET Driver](https://docs.mongodb.com/drivers/csharp/) 2.14.0 and higher), you can compose and understand queries in a much more manageable way.

Let’s take a look at how to install and use the new MongoDB Analyzer as a NuGet package. We’ll follow with some code samples so you can see why this is a must-have tool for Visual Studio!

## Install MongoDB Analyzer as a NuGet Package
In Visual Studio, install the `MongoDB.Analyzer` [NuGet package](https://www.nuget.org/packages/MongoDB.Analyzer/1.0.0):

*Package Manager*

```
Install-Package MongoDB.Analyzer -Version 1.0.0
```

*.NET CLI*

```
dotnet add package MongoDB.Analyzer --version 1.0.0
```

Once installed, it will be added to your project’s Dependencies list, under Analyzers:
![MongoDB.Analyzer shown within the Dependencies/Analyzers folder](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_analyzer_dependencies_c12f40e5e3.png)

After installing and once the analyzer has run, you’ll find all of the diagnostic warnings output to the Error List panel. As you start to inspect your code, you’ll also see that any unsupported expressions will be highlighted.

## Inspecting Information Messages and Warnings
As you write LINQ or Builders expressions, an information tooltip can be accessed by hovering over the three grey dots under your expression:

*Accessing the tooltip for a LINQ expression*
![Accessing the tooltip for a LINQ expression](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_linq_tooltip_0c75054f92.gif)

This tooltip displays the corresponding Query API language to the expression you are writing and updates in real-time! With the translated query at your tooltips, you can confirm the query being generated (and executed!) is the one you expect. 

This is a far more efficient process of composing and testing queries—focus on the invalid expressions instead of wasting time translating your code for the Query API! And if you ever need to copy the resulting queries generated, you can do so right from your IDE (from the Error List panel).

Another common issue the MongoDB Analyzer solves is surfacing unsupported expressions and invalid queries at compile time. You’ll find all of these issues listed as warnings:

*Unsupported expressions shown as warnings in Visual Studio’s Error List*
![Unsupported expressions shown as warnings in Visual Studio’s Error List](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/error_list_warnings_2b5ab48b2a.png)

This is quite useful as not all LINQ expressions are supported by the MongoDB C#/.NET driver. Similarly, supported expressions will differ depending on which version of LINQ you use.

## Code Samples—See the MongoDB Analyzer for .NET in Action
Now that we know what the MongoDB Analyzer can do for us, let’s see it live!

### Builder Expressions
These are a few examples that show how Builder expressions are analyzed. As you’ll see, the MongoDB Analyzer provides immediate feedback through the tooltip. Hovering over your code shows you the supported Query API language that corresponds to the query/expression you are writing.

*Builder Filter Definition - Filter movies by matching genre, score that is greater than or equal to minimum score, and a match on the title search term.*
![GIF showing a builder filter being implemented. Alternates between hovering over expression to show the tooltip and corresponding MongoDB Query API expression generated and adding to the builder filter.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_builder_filter_2f9735637d.gif)

*Builder Sort Definition - Sort movies by score (lowest to highest) and title (from Z to A).*
![GIF showing a builder sort definition being implemented. Tooltip is then shown with genereated MongoDB Query API expression.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_builder_sort_9754e9c33b.gif)

*Unsupported Builder Expression - Highlighted and shown as warning in Error List.*
![GIF showing unsupported builder expression being implemented. After being written, unsupported code is correctly highlighted; tooltip is shown warning developer of the unsupported expression and the warning is added to the Error List panel of the IDE.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_builder_unsupported_85c6967ea9.gif)

### LINQ Queries
The MongoDB Analyzer uses the default LINQ provider of the C#/.NET driver (LINQ2). Expressions that aren’t supported in LINQ2 but are supported in LINQ3 will show the appropriate warnings, as you’ll see in one of the following examples. If you’d like to switch the LINQ provider the MongoDB Analyzer uses, set` “DefaultLinqVersion”: “V3” `in the `mongodb.analyzer.json` file.

*LINQ Filter Query - Aggregation pipeline.*
![GIF showing a LINQ query being implemented with multiple conditions. Afterward, a tooltip with the corresponding MongoDB Query API expression is shown.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_linq_aggregation_79fa4031ee.gif)

*LINQ Query - Get movie genre statistics; uses aggregation pipeline to group by and select a dynamic object.*
![GIF showing a LINQ query being implemented that uses a group by statement and selection of a dynamic object. Afterward, a tooltip with the corresponding MongoDB Query API expression is shown.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_linq_groupby_select_f4711d32cd.gif)

*Unsupported LINQ Expression - GetHashCode() method unsupported.*
 ![GIF showing unsupported LINQ expression being implemented. After being written, unsupported code is correctly highlighted; tooltip is shown warning developer of the unsupported expression and the warning is added to the Error List panel of the IDE.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_linq_unsupported_bbd62a00fc.gif)

*Unsupported LINQ Expression - Method referencing a lambda parameter unsupported.*
![GIF showing unsupported LINQ expression being implemented. After being written, unsupported code is correctly highlighted; tooltip is shown warning developer of the unsupported expression and the warning is added to the Error List panel of the IDE.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_linq_unsupported_2_ea584e3fac.gif)

*Unsupported LINQ2, but supported LINQ3 Expression - Trim() is not supported in LINQ2, but is supported in LINQ3.*
![GIF showing an expression that is unsupported in LINQ2, but supported in LINQ3, being implemented. After being written, unsupported code is correctly highlighted; tooltip warns developer of the unsupported expression in LINQ2 but not LINQ3 and the warning is added to the Error List panel of the IDE.](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_only_linq3_bc033bd4f1.gif)

## MongoDB Analyzer + New LINQ3 Provider = 💚
If you’d rather not see those “unsupported in LINQ2, but supported in LINQ3” warnings, now is also a good time to update to the [latest MongoDB C#/.NET driver](https://www.nuget.org/packages/mongodb.driver) (2.14.1) which has LINQ3 support! While the full transition from LINQ2 to LINQ3 continues, you can explicitly configure your [MongoClient](https://mongodb.github.io/mongo-csharp-driver/2.14/getting_started/quick_tour/#mongoclient) to use the new LINQ provider like so:

```csharp
var connectionString = "mongodb://localhost";
var clientSettings = MongoClientSettings.FromConnectionString(connectionString);
clientSettings.LinqProvider = LinqProvider.V3;
var client = new MongoClient(clientSettings);
```

## Integrate MongoDB Analyzer for .NET into Your Pipelines
The MongoDB Analyzer can also be used from the CLI which means integrating this static analysis tool into your continuous integration and continuous deployment pipelines is seamless! For example, running `dotnet build` from the command line will output MongoDB Analyzer warnings to the terminal:

*Running dotnet build command outputs warnings from the MongoDB Analyzer*
![*Running dotnet build command outputs warnings from the MongoDB Analyzer*](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mdb_analyzer_build_output_terminal_52965c0a24.gif)

Adding this as a step in your build pipeline can be a valuable gate check for your build. You’ll save yourself a potential headache and catch unsupported expressions and invalid queries much earlier.

Another idea: Output a Static Analysis Results Interchange Format ([SARIF](https://github.com/microsoft/sarif-tutorials/blob/main/docs/1-Introduction.md#:%7E:text=What%20is%20SARIF%3F,for%20use%20by%20simpler%20tools)) file and use it to generate explain plans for all of your queries. SARIF is a standard, JSON-based format for the output of static analysis tools, making a SARIF file an ideal place to grab the supported queries generated by the MongoDB Analyzer. 

To output a SARIF file for your project, you’ll need to add the `ErrorLog` option to your `.csproj` file. You’ll be able to find it at the root of your project (unless you’ve specified otherwise) the next time you build your project.

With this file, you can load it via a [mongosh](https://docs.mongodb.com/mongodb-shell/) script, process the file to find and “clean” the found MongoDB Query API expressions, and generate [explain plans](https://docs.mongodb.com/manual/reference/method/db.collection.explain/#mongodb-method-db.collection.explain) for the list of queries. What can you do with this? A great example would be to output a build warning (or outright fail the build) if you catch any missing indexes! Adding steps like these to your build and using the information from the expain plans, you can prevent potential performance issues from ever making it to production.

## We Want to Hear From You!
With the release of the MongoDB Analyzer for .NET, we hope to speed up your development cycle and increase your productivity in three ways: 1) by making it easier for you to see how your idiomatic queries map to the MongoDB Query API, 2) by helping you spot unsupported expressions and invalid queries faster (at compile time, baby), and 3) by streamlining your development process by enabling static analysis for your MongoDB queries in your CI/CD pipelines!

We’re quite eager to see the .NET and C# communities use this tool and are even more eager to hear your feedback. The MongoDB Analyzer is ready for you to install as a [NuGet package](https://www.nuget.org/packages/MongoDB.Analyzer/1.0.0) and can be added to any existing project that uses the MongoDB .NET driver. We want to continue improving this tool and that can only be done with your help. If you find any issues, are missing critical functionality, or have an edge case that the MongoDB Analyzer doesn’t fulfill, [please let us know](https://feedback.mongodb.com/forums/940188-mongodb-analyzer-for-net)! You can alsopost in our [Community Forums](https://www.mongodb.com/community/forums/).

**Additional Resources**

* [MongoDB Analyzer Docs](https://docs.mongodb.com/mongodb-analyzer/current/)

Say hello to the MongoDB Analyzer for .NET. This tool translates your C# queries to their MongoDB Query API equivalent and warns you of unsupported expressions and invalid queries at compile time, right in Visual Studio.

Introducing the MongoDB Analyzer for .NET

So you're a .NET Core developer or you're trying to become one and you'd like to get a database included into the mix. MongoDB is a great choice and is quite easy to get started with for your .NET Core projects.

In this tutorial, we're going to explore simple CRUD operations in a .NET Core application, something that will make you feel comfortable in no time!

## The Requirements

To be successful with this tutorial, you'll need to have a few things ready to go.

- .NET Core installed and configured.
- MongoDB Atlas cluster, M0 or better, deployed and configured.

Both are out of the scope of this particular tutorial, but you can refer to [this tutorial](https://www.mongodb.com/developer/article/5-different-ways-deploy-free-database-mongodb-atlas/) for more specific instructions around MongoDB Atlas deployments. You can validate that .NET Core is ready to go by executing the following command:

```bash
dotnet new console --output MongoExample
```

We're going to be building a console application, but we'll explore API development in a later tutorial. The "MongoExample" project is what we'll use for the remainder of this tutorial.

## Installing and Configuring the MongoDB Driver for .NET Core Development

When building C# applications, the common package manager to use is NuGet, something that is readily available in Visual Studio. If you're using Visual Studio, you can add the following:

```bash
Install-Package MongoDB.Driver -Version 2.14.1
```

However, I'm on a Mac, use a variety of programming languages, and have chosen Visual Studio Code to be the IDE for me. There is no official NuGet extension for Visual Studio Code, but that doesn't mean we're stuck.

Execute the following from a CLI while within your project directory:

```bash
dotnet add package MongoDB.Driver
```

The above command will add an entry to your project's "MongoExample.csproj" file and download the dependencies that we need. This is valuable whether you're using Visual Studio Code or not.

If you generated the .NET Core project with the CLI like I did, you'll have a "Program.cs" file to work with. Open it and add the following code:

```csharp
using MongoDB.Driver;
using MongoDB.Bson;

MongoClient client = new MongoClient("ATLAS_URI_HERE");

List<string> databases = client.ListDatabaseNames().ToList();

foreach(string database in databases) {
    Console.WriteLine(database);
}
```

The above code will connect to a MongoDB Atlas cluster and then print out the names of the databases that the particular user has access to. The printing of databases is optional, but it could be a good way to make sure everything is working correctly.

If you're wondering where to get your `ATLAS_URI_HERE` string, you can find it in your MongoDB Atlas dashboard and by clicking the connect button on your cluster.

![MongoDB Atlas Connection String](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_atlas_connection_string_801c3bdc01.jpg "MongoDB Atlas Connection String")

The above image should help when looking for the Atlas URI.

## Building a POCO Class for the MongoDB Document Model

When using .NET Core to work with MongoDB documents, you can make use of the `BsonDocument` class, but depending on what you're trying to do, it could complicate your .NET Core application. Instead, I like to work with classes that are directly mapped to document fields. This allows me to use the class naturally in C#, but know that everything will work out on its own for MongoDB documents.

Create a "playlist.cs" file within your project and include the following C# code:

```csharp
using MongoDB.Bson;

public class Playlist {

    public ObjectId _id { get; set; }
    public string username { get; set; } = null!;
    public List<string> items { get; set; } = null!;

    public Playlist(string username, List<string> movieIds) {
        this.username = username;
        this.items = movieIds;
    }

}
```

In the above `Playlist` class, we have three fields. If you want each of those fields to map perfectly to a field in a MongoDB document, you don't have to do anything further. To be clear, the above class would map to a document that looks like the following:

```json
{
    "_id": ObjectId("61d8bb5e2d5fe0c2b8a1007d"),
    "username": "nraboy",
    "items": [ "1234", "5678" ]
}
```

However, if you wanted your C# class field to be different than the field it should map to in a MongoDB document, you'd have to make a slight change. The `Playlist` class would look something like this:

```csharp
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

public class Playlist {

    public ObjectId _id { get; set; }

    [BsonElement("username")]
    public string user { get; set; } = null!;

    public List<string> items { get; set; } = null!;

    public Playlist(string username, List<string> movieIds) {
        this.user = username;
        this.items = movieIds;
    }

}
```

Notice the new import and the use of `BsonElement` to map a remote document field to a local .NET Core class field.

There are a lot of other things you can do in terms of document mapping, but they are out of the scope of this particular tutorial. If you're curious about other mapping techniques, check out the [documentation](https://mongodb.github.io/mongo-csharp-driver/2.14/reference/bson/mapping/) on the subject.

## Implementing Basic CRUD in .NET Core with MongoDB

Since we're able to connect to Atlas from our .NET Core application and we have some understanding of what our data model will look like for the rest of the example, we can now work towards creating, reading, updating, and deleting (CRUD) documents.

We'll start by creating some data. Within the project's "Program.cs" file, make it look like the following:

```csharp
using MongoDB.Driver;

MongoClient client = new MongoClient("ATLAS_URI_HERE");

var playlistCollection = client.GetDatabase("sample_mflix").GetCollection<Playlist>("playlist");

List<string> movieList = new List<string>();
movieList.Add("1234");

playlistCollection.InsertOne(new Playlist("nraboy", movieList));
```

In the above example, we're connecting to MongoDB Atlas, getting a reference to our "playlist" collection while noting that it is related to our `Playlist` class, and then making use of the `InsertOne` function on the collection.

If you ran the above code, you should see a new document in your collection with matching information.

So let's read from that collection using our C# code:

```csharp
// Previous code here ...

FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("username", "nraboy");

List<Playlist> results = playlistCollection.Find(filter).ToList();

foreach(Playlist result in results) {
    Console.WriteLine(string.Join(", ", result.items));
}
```

In the above code, we are creating a new `FilterDefinition` filter to determine which data we want returned from our `Find` operation. In particular, our filter will give us all documents that have "nraboy" as the `username` field, which may be more than one because we never specified if the field should be unique.

Using the filter, we can do a `Find` on the collection and convert it to a `List` of our `Playlist` class. If you don't want to use a `List`, you can work with your data using a cursor. You can learn more about cursors in the [documentation](https://mongodb.github.io/mongo-csharp-driver/2.14/apidocs/html/T_MongoDB_Driver_IFindFluent_2.htm).

With a `Find` out of the way, let's move onto updating our documents within MongoDB.

We're going to add to our "Program.cs" file with the following code:

```csharp
// Previous code here ...

FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("username", "nraboy");

// Previous code here ...

UpdateDefinition<Playlist> update = Builders<Playlist>.Update.AddToSet<string>("items", "5678");

playlistCollection.UpdateOne(filter, update);

results = playlistCollection.Find(filter).ToList();

foreach(Playlist result in results) {
    Console.WriteLine(string.Join(", ", result.items));
}
```

In the above code, we are creating two definitions, one being the `FilterDefinition` that we had created in the previous step. We're going to keep the same filter, but we're adding a definition of what should be updated when there was a match based on the filter.

To clear things up, we're going to match on all documents where "nraboy" is the `username` field. When matched, we want to add "5678" to the `items` array within our document. Using both definitions, we can use the `UpdateOne` method to make it happen.

There are more update operations than just the `AddToSet` function. It is worth checking out the [documentation](https://docs.mongodb.com/manual/reference/operator/update/) to see what you can accomplish.

This brings us to our final basic CRUD operation. We're going to delete the document that we've been working with.

Within the "Program.cs" file, add the following C# code:

```csharp
// Previous code here ...

FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("username", "nraboy");

// Previous code here ...

playlistCollection.DeleteOne(filter);
```

We're going to make use of the same filter we've been using, but this time in the `DeleteOne` function. While we could have more than one document returned from our filter, the `DeleteOne` function will only delete the first one. You can make use of the `DeleteMany` function if you want to delete all of them.

Need to see it all together? Check this out:

```csharp
using MongoDB.Driver;

MongoClient client = new MongoClient("ATLAS_URI_HERE");

var playlistCollection = client.GetDatabase("sample_mflix").GetCollection<Playlist>("playlist");

List<string> movieList = new List<string>();
movieList.Add("1234");

playlistCollection.InsertOne(new Playlist("nraboy", movieList));

FilterDefinition<Playlist> filter = Builders<Playlist>.Filter.Eq("username", "nraboy");

List<Playlist> results = playlistCollection.Find(filter).ToList();

foreach(Playlist result in results) {
    Console.WriteLine(string.Join(", ", result.items));
}

UpdateDefinition<Playlist> update = Builders<Playlist>.Update.AddToSet<string>("items", "5678");

playlistCollection.UpdateOne(filter, update);

results = playlistCollection.Find(filter).ToList();

foreach(Playlist result in results) {
    Console.WriteLine(string.Join(", ", result.items));
}

playlistCollection.DeleteOne(filter);
```

The above code is everything that we did. If you swapped out the Atlas URI string with your own, it would create a document, read from it, update it, and then finally delete it.

## Conclusion

You just saw how to quickly get up and running with MongoDB in your .NET Core application! While we only brushed upon the surface of what is possible in terms of MongoDB, it should put you on a better path for accomplishing your project needs.

If you're looking for more help, check out the [MongoDB Community Forums](https://community.mongodb.com) and get involved.

Learn how to quickly and easily start building .NET Core applications that interact with MongoDB Atlas for create, read, update, and delete (CRUD) operations.

Build Your First .NET Core Application with MongoDB Atlas

Dominic Frei

Persisting data is an important part of most games. Unity offers only a limited set of solutions, which means we have to look around for other options as well. In this tutorial series, we will explore the options given to us by Unity and third-party libraries.

Saving Data in Unity3D Using BinaryReader and BinaryWriter

# Using LINQ to Query MongoDB in a .NET Core Application

If you've been keeping up with my series of tutorials around .NET Core and MongoDB, you'll likely remember that we explored [using the Find operator to query for documents](https://www.mongodb.com/developer/how-to/build-first-dotnet-core-application-mongodb-atlas/) as well as [an aggregation pipeline](https://www.mongodb.com/developer/how-to/joining-collections-mongodb-dotnet-core-aggregation-pipeline/). Neither of these previously explored subjects are too difficult, but depending on what you're trying to accomplish, they could be a little messy. Not to mention, they aren't necessarily "the .NET way" of doing business.

This is where LINQ comes into the mix of things!

With Language Integrated Queries (LINQ), we can use an established and well known C# syntax to work with our MongoDB documents and data.

In this tutorial, we're going to look at a few LINQ queries, some as a replacement to simple queries using the MongoDB Query API and others as a replacement to more complicated aggregation pipelines.

## The requirements

To be successful with this tutorial, you should already have the following ready to go:

- [.NET Core](https://dotnet.microsoft.com/en-us/download/dotnet/6.0) 6+
- [MongoDB Atlas](https://www.mongodb.com/cloud/atlas/signup), the free tier or better

When it comes to MongoDB Atlas, you'll need to have a cluster deployed and properly configured with user roles and network rules. If you need help with this, take a look at my [previous tutorial](https://www.mongodb.com/developer/article/5-different-ways-deploy-free-database-mongodb-atlas/) on the subject. You will also need the sample datasets installed.

While this tutorial is part of a series, you don't need to have read the others to be successful. However, you'd be doing yourself a favor by checking out the other ways you can do business with .NET Core and MongoDB.

## Creating a new .NET Core console application with the CLI

To keep this tutorial simple and easy to understand, we're going to create a new console application and work from that.

Execute the following from the CLI to create a new project that is ready to go with the MongoDB driver:

```bash
dotnet new console -o MongoExample
cd MongoExample
dotnet add package MongoDB.Driver
```

For this tutorial, our MongoDB Atlas URI string will be stored as an environment variable on our computer. Depending on your operating system, you can do something like this:

```bash
export ATLAS_URI="YOUR_ATLAS_URI_HERE"
```

The Atlas URI string can be found in your MongoDB Atlas Dashboard after clicking the "Connect" button and choosing your programming language.

Open the project's **Program.cs** file and add the following C# code:

```csharp
using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Linq;

MongoClientSettings settings = MongoClientSettings.FromConnectionString(
    Environment.GetEnvironmentVariable("ATLAS_URI")
);

settings.LinqProvider = LinqProvider.V3;

MongoClient client = new MongoClient(settings);
```

In the above code, we are explicitly saying that we want to use LINQ Version 3 rather than Version 2, which is the default in MongoDB. While you can accomplish many LINQ-related tasks in MongoDB with Version 2, you'll get a much better experience with Version 3.

## Writing MongoDB LINQ queries in your .NET Core project

We're going to take it slow and work our way up to bigger and more complicated queries with LINQ.

In case you've never seen the "sample_mflix" database that is part of the sample datasets that MongoDB offers, it's a movie database with several collections. We're going to focus strictly on the "movies" collection which has documents that look something like this:

```json
{
    "_id": ObjectId("573a1398f29313caabceb515"),
    "title": "Batman",
    "year": 1989,
    "rated": "PG-13",
    "runtime": 126,
    "plot": "The Dark Knight of Gotham City begins his war on crime with his first major enemy being the clownishly homicidal Joker.",
    "cast": [ "Michael Keaton", "Jack Nicholson", "Kim Basinger" ]
}
```

There are quite a bit more fields to each of the documents in that collection, but the above fields are enough to get us going.

To use LINQ, we're going to need to create mapped classes for our collection. In other words, we won't want to be using `BsonDocument` when writing our queries. At the root of your project, create a **Movie.cs** file with the following C# code:

```csharp
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

[BsonIgnoreExtraElements]
public class Movie {

    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }

    [BsonElement("title")]
    public string Title { get; set; } = null!;

    [BsonElement("year")]
    public int Year { get; set; }

    [BsonElement("runtime")]
    public int Runtime { get; set; }

    [BsonElement("plot")]
    [BsonIgnoreIfNull]
    public string Plot { get; set; } = null!;

    [BsonElement("cast")]
    [BsonIgnoreIfNull]
    public List<string> Cast { get; set; } = null!;

}
```

We used a class like the above in our previous tutorials. We've just defined a few of our fields, mapped them to BSON fields in our database, and told our class to ignore any extra fields that may exist in our database that we chose not to define in our class.

Let's say that we want to return movies that were released between 1980 and 1990. If we weren't using LINQ, we'd be doing something like the following in our **Program.cs** file:

```csharp
using MongoDB.Bson;
using MongoDB.Driver;

MongoClient client = new MongoClient(
    Environment.GetEnvironmentVariable("ATLAS_URI")
);

IMongoCollection<Movie> moviesCollection = client.GetDatabase("sample_mflix").GetCollection<Movie>("movies");

BsonDocument filter = new BsonDocument{
    { 
        "year", new BsonDocument{
            { "$gt", 1980 },
            { "$lt", 1990 }
        } 
    }
};

List<Movie> movies = moviesCollection.Find(filter).ToList();

foreach(Movie movie in movies) {
    Console.WriteLine($"{movie.Title}: {movie.Plot}");
}
```

However, since we want to use LINQ, we can update our **Program.cs** file to look like the following:

```csharp
using MongoDB.Driver;
using MongoDB.Driver.Linq;

MongoClientSettings settings = MongoClientSettings.FromConnectionString(
    Environment.GetEnvironmentVariable("ATLAS_URI")
);

settings.LinqProvider = LinqProvider.V3;

MongoClient client = new MongoClient(settings);

IMongoCollection<Movie> moviesCollection = client.GetDatabase("sample_mflix").GetCollection<Movie>("movies");

IMongoQueryable<Movie> results =
            from movie in moviesCollection.AsQueryable()
            where movie.Year > 1980 && movie.Year < 1990
            select movie;

foreach(Movie result in results) {
    Console.WriteLine("{0}: {1}", result.Title, result.Plot);
}
```

In the above code, we are getting a reference to our collection and creating a LINQ query. To break down the LINQ query to see how it relates to MongoDB, we have the following:

1. The "WHERE" operator is the equivalent to doing a "$MATCH" or a filter within MongoDB. The documents have to match the criteria in this step.
2. The "SELECT" operator is the equivalent to doing a projection or using the "$PROJECT" operator. We're defining which fields should be returned from the query—in this case, all fields that we've defined in our class.

To diversify our example a bit, we're going to change the match condition to match within an array, something non-flat.

Change the LINQ query to look like the following:

```csharp
var results =
            from movie in moviesCollection.AsQueryable()
            where movie.Cast.Contains("Michael Keaton")
            select new { movie.Title, movie.Plot };
```

A few things changed in the above code along with the filter. First, you'll notice that we are matching on the `Cast` array as long as "Michael Keaton" exists in that array. Next, you'll notice that we're doing a projection to only return the movie title and the movie plot instead of all other fields that might exist in the data.

We're going to make things slightly more complex now in terms of our query. This time we're going to do what would have been a MongoDB aggregation pipeline, but this time using LINQ.

Change the C# code in the **Program.cs** file to look like the following:

```csharp
using MongoDB.Driver;
using MongoDB.Driver.Linq;

MongoClientSettings settings = MongoClientSettings.FromConnectionString(
    Environment.GetEnvironmentVariable("ATLAS_URI")
);

settings.LinqProvider = LinqProvider.V3;

MongoClient client = new MongoClient(settings);

IMongoCollection<Movie> moviesCollection = client.GetDatabase("sample_mflix").GetCollection<Movie>("movies");

var results = 
            from movie in moviesCollection.AsQueryable()
            where movie.Cast.Contains("Ryan Reynolds")
            from cast in movie.Cast
            where cast == "Ryan Reynolds"
            group movie by cast into g
            select new { Cast = g.Key, Sum = g.Sum(x => x.Runtime) };

foreach(var result in results) {
    Console.WriteLine("{0} appeared on screen for {1} minutes!", result.Cast, result.Sum);
}
```

In the above LINQ query, we're doing a series of steps, just like stages in an aggregation pipeline. These stages can be broken down like the following:

1. Match all documents where "Ryan Reynolds" is in the cast.
2. Unwind the array of cast members so the documents sit adjacent to each other. This will flatten the array for us.
3. Do another match on the now smaller subset of documents, filtering out only results that have "Ryan Reynolds" in them.
4. Group the remaining results by the cast, which will only be "Ryan Reynolds" in this example.
5. Project only the group key, which is the cast member, and the sum of all the movie runtimes.

If you haven't figured it out yet, what we attempted to do was determine the total amount of screen time Ryan Reynolds has had. We isolated our result set to only documents with Ryan Reynolds, and then we summed the runtime of the documents that were matched.

While the full scope of the MongoDB aggregation pipeline isn't supported with LINQ, you'll be able to accomplish quite a bit, resulting in a lot cleaner looking code. To get an idea of the supported operators, take a look at the [MongoDB LINQ documentation](https://mongodb.github.io/mongo-csharp-driver/2.5/reference/driver/crud/linq/#project).

## Conclusion

You just got a taste of LINQ with MongoDB in your .NET Core applications. While you don't have to use LINQ, as demonstrated in a few previous tutorials, it's common practice amongst C# developers.

Got a question about this tutorial? Check out the [MongoDB Community Forums](https://community.mongodb.com) for help!

Learn how to use LINQ to interact with MongoDB in a .NET Core application.

Using LINQ to Query MongoDB in a .NET Core Application

When it comes to C#, it's not too difficult or time-consuming to create or consume RESTful APIs. In fact, I recently published a tutorial that demonstrated [how to create a RESTful API with .NET Core using MongoDB](https://www.mongodb.com/developer/languages/csharp/create-restful-api-dotnet-core-mongodb/) as the NoSQL database.

RESTful APIs are great, but what happens when you want to work with GraphQL and query your APIs rather than just consume them?

In this tutorial, we'll see how to use .NET Core to interact with a GraphQL API. To make things easier, we'll generate our API with MongoDB App Services.

## The requirements

For this particular tutorial, you'll need to have a few things available and configured prior to getting started.

- [.NET Core](https://dotnet.microsoft.com/en-us/download) 6+.
- A [MongoDB Cloud](https://cloud.mongodb.com) account with a free tier cluster (M0) or better deployed.

For reference, I'm using .NET Core 6.0.101, but any version of 6 or higher should work fine. We'll be using the CLI, but if you feel more comfortable using Visual Studio, that works too.

While it isn't 100% necessary to use MongoDB in this tutorial, MongoDB makes it extremely easy to get started with a GraphQL API because you can automatically generate an API from any of your databases with a few mouse clicks. For this reason, it will power the API for this example.

## Create a new .NET Core application with the CLI

To keep things simple and easy to understand, we're going to create and work with a console based .NET Core application. We'll be able to spend less time with the configuration, and more with the code that matters.

Assuming .NET Core is installed and you have access to the CLI, execute the following command:

```bash
dotnet new console --output MongoExample
```

The above line will generate a new console application inside a **MongoExample** directory.

We're not done yet though. We need to install a GraphQL dependency for querying an actual GraphQL API as well as a dependency for working with JSON data. From the CLI, execute the following:

```bash
dotnet add package GraphQL.Client
dotnet add package GraphQL.Client.Serializer.Newtonsoft
dotnet add package Newtonsoft.Json
```

At the end of the day, GraphQL is still accessed over HTTP, so a package isn't absolutely necessary, but having one will make life much easier.

We have a starting point for our project. The next time we visit our project, we'll be writing code to do all the magic.

## Quickly deploy a GraphQL API with MongoDB App Services

Getting a GraphQL API deployed is easy with MongoDB. We're going to assume that you have a MongoDB Cloud account with an Atlas cluster deployed. If you have no databases in your cluster, don't worry because you can use one of the sample sets that Atlas offers.

![Load MongoDB Sample Dataset](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/sample_dataset_d301a61d9f.jpg "Load MongoDB Sample Dataset")

When we start writing code, we're going to refer to the "sample_mflix" database that is part of the sample dataset. Feel free to adapt the tutorial to something of your own as well.

With the database ready to go, click on the "App Services" navigation tab and choose to create a new application. The name isn't important as long as you are pointing to the correct cluster.

Within the MongoDB App Services portal, click the "GraphQL" tab and choose the "Generate JSON Schema" button. Find the database and collection you want to use with GraphQL and click the "Generate a Schema" button. We're using the "sample_mflix" database and "movies" collection in this example. 

![MongoDB GraphQL Generate Schema](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/graphql_create_schema_2fc9b6f7ed.png "MongoDB GraphQL Generate Schema")

Don't forget to save after it generates!

Back in the "GraphQL" tab, you can now start querying your collection with GraphQL queries. You'll also notice your public GraphQL URL on the same page.

![MongoDB with GraphQL](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/mongodb_graphiql_example_d75f6ccf6c.png "MongoDB with GraphiQL")

We're not done yet because we also need to generate a key for our API.

Click the "Authentication" tab and choose to edit the "API Keys" in the list. Enable the provider and generate a key. Don't forget your key because it will be used when we start writing code.

Since we're planning to use authentication, we need to click the "Rules" tab and define a new access rule for the collection that we're using. For this example, add a new rule that says everyone can read, but not write. Change the rules to best meet your needs.

![MongoDB GraphQL Collection Rules](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/graphql_collection_rules_c613b0954e.png "MongoDB GraphQL Collection Rules")

Your GraphQL API is ready to go and you only had to do a few clicks within MongoDB!

## Query a GraphQL API with a few lines of C# code

We have a boilerplate .NET Core project and we have a GraphQL API to work with. Let's spend a little time putting some code together to query that API from the project.

It isn't a requirement, but it's a good idea to define a class for the GraphQL results. This will make your application more maintainable for the future. Within your project, create a new **GraphQLMovieResponse.cs** file with the following C# code:

```csharp
public class GraphQLMovieResponse {

    public Movie Movie { get; set; }

};

public class Movie {

    public string Title { get; set; }
    public string Plot { get; set; }

}
```

The idea behind this class is that we'll be working with data that looks like the following:

```json
{
    "data": {
        "movie": {
            "title": "The Terminator",
            "plot": "A human-looking indestructible cyborg is sent from 2029 to 1984 to assassinate a waitress, whose unborn son will lead humanity in a war against the machines, while a soldier from that war is sent to protect her at all costs."
        }
    }
}
```

Yes, there are more fields than just the `title` and `plot` fields in our collection and GraphQL schema. For the sake of this example, we're only going to map the fields we plan to use.

Open the project's **Program.cs** file and replace the contents with the following:

```csharp
using GraphQL;
using GraphQL.Client.Http;
using GraphQL.Client.Serializer.Newtonsoft;
using Newtonsoft.Json;

var graphQLHttpClientOptions = new GraphQLHttpClientOptions
{
    EndPoint = new Uri("YOUR_GRAPHQL_API_ENDPOINT_HERE")
};

var httpClient = new HttpClient();

httpClient.DefaultRequestHeaders.Add("apiKey", "YOUR_APP_SERVICES_API_KEY_HERE");

var graphQLClient = new GraphQLHttpClient(graphQLHttpClientOptions, new NewtonsoftJsonSerializer(), httpClient);

var movieRequest = new GraphQLRequest
{
    Query = @"
        {
            movie {
                title,
                plot
            }
        }
    "
};

var graphQLResponse = await graphQLClient.SendQueryAsync<GraphQLMovieResponse>(movieRequest);

Console.WriteLine("{0}: {1}", graphQLResponse.Data.Movie.Title, graphQLResponse.Data.Movie.Plot);
```

A few things are happening in the above code.

First, we're defining our endpoint URL, which in this example is the endpoint the MongoDB App Services provides when configuring GraphQL. Next we're adding an `apiKey` header to the request with our MongoDB App Services key that we defined for authentication. If your API doesn't require authentication, you won't need to add this.

Using the endpoint and key information, a client can be created. With the client, we can create a standard GraphQL query and send it.

The result of our request will be returned as a `GraphQLMovieResponse` like we had previously created. With this response, we can access each of the fields and use them however we want.

## Conclusion

You just saw how to work with a GraphQL API from your .NET Core application. This example was simple because we only did a single query, but you can easily review the [GraphQL specification](https://graphql.org/) to do more complex things.

To make things more exciting, we also saw how to deploy a GraphQL API using a few mouse clicks and MongoDB. This was made possible because of the MongoDB App Services.

Have a question regarding this tutorial? Visit the [MongoDB Community Forums](https://community.mongodb.com) and engage with developers that have similar interests.

.Net Framework

Featured

Interact with a GraphQL API from a .NET Core Application

Using LINQ to Query MongoDB in a .NET Core Application

Saving Data in Unity3D Using BinaryReader and BinaryWriter

All .Net Framework Content