Adrienne Tacke

Learn how to use Azure Key Vault as your remote key management system with MongoDB's client-side field level encryption, step-by-step.

Integrate Azure Key Vault with MongoDB Client-Side Field Level Encryption

Learn how to use MongoDB client-side field level encryption (CSFLE) with a C# application.

How to Use MongoDB Client-Side Field Level Encryption (CSFLE) with C#

## Can I deploy MongoDB on Heroku?

Yes! It's easy to set up and free to use with [MongoDB Atlas](https://www.mongodb.com/cloud/atlas).

As we begin building more cloud-native applications, choosing the right services and tools can be quite overwhelming. Luckily, when it comes to choosing a cloud database service, [MongoDB Atlas](https://www.mongodb.com/cloud/atlas) may be the easiest choice yet!

When paired with [Heroku](https://www.heroku.com/), one of the most popular [PaaS](https://en.wikipedia.org/wiki/Platform_as_a_service) solutions for developers, you'll be able to build and deploy fully managed cloud applications in no time. The best part? MongoDB Atlas integrates easily with Heroku applications. All you need to do is set your Atlas cluster's connection string to a Heroku config variable.  That's really all there is to it!

If you're already familiar with MongoDB, using MongoDB Atlas with your cloud applications is a natural choice. MongoDB Atlas is a fully-managed cloud database service for MongoDB that automates the management of MongoDB clusters in the cloud. Offering features such as automated backup, auto-scaling, multi-AZ fault tolerance, and a full suite of management and analytics tools, Atlas is the most sophisticated DBaaS anywhere, and is just a few clicks away.

To see how quick it is to get up and running with MongoDB Atlas, just follow the next few steps to set up your first free cluster. Then, see how quickly you can connect your new Atlas cluster to your Heroku application by following the step-by-step instructions later on in this tutorial.

## Prerequisites

This tutorial assumes the following:

-   You are familiar with MongoDB and have written applications that use MongoDB.
-   You are familiar with Heroku and know how to deploy Heroku apps.  -   You have the [Heroku CLI](https://devcenter.heroku.com/articles/heroku-cli) installed.
-   You are familiar with and have [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) installed.

With these assumptions in mind, let's get started!

## Setting up your Atlas Cluster in 5 steps (or less!)

### Step 1: Create an Atlas account

>💡 If you already created a MongoDB account using your email address, you can skip this step! [Sign into your account](https://account.mongodb.com/account/login) instead.

You can [register for an Atlas account](https://www.mongodb.com/cloud/atlas/register) with your email address or your Google Account.

![MongoDB Atlas Signup](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/atlas-signup.png)

### Step 2: Create your organization and project

After registering, Atlas will prompt you to create an organization and project where you can deploy your cluster.

![MongoDB Atlas Create Cluster](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/create-cluster.png)

### Step 3: Deploy Your first cluster

You'll now be able to select from a range of cluster options. For this tutorial, we'll select the Shared Clusters option, which is Atlas's Free Tier cluster. Click "Create a cluster" under the Shared Clusters option:

On the next page, you'll be prompted to choose a few options for your cluster:

*Cloud provider & region*

Choose where you want to deploy your cluster to. It is important to select the available region closest to your application, and ideally the same region, in order to minimize latency. In our case, let's choose the N. Virginia (us-east-1) region, with AWS as our cloud provider (since we're deploying on Heroku, and that is where Heroku hosts its infrastructure):

![MongoDB Atlas Cloud Provider Region Selection](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/cloud-provider-region-selection.png)

*Cluster tier*

Here, you'll see the cluster tiers available for the shared clusters option. You can view a comparison of RAM, Storage, vCPU, and Base Price between the tiers to help you choose the right tier. For our tutorial, leave the default M0 Sandbox tier selected:

![MongoDB Atlas Cluster Tier Selection](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/cluster-tier-selection.png)

*Additional settings*

Depending on the tier you choose, some additional options may be available for you. This includes the MongoDB version you wish to deploy and, for M2 clusters and up, Backup options. For this tutorial, select the latest version, MongoDB 4.4:

![MongoDB Atlas Cluster Additional Settings](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/cluster-additional-settings.png)

*Cluster name*

Lastly, you can give your cluster a name. Keep in mind that once your cluster is created, you won't be able to change it! Here, we'll name our cluster `leaflix-east` to help us know which project and region this cluster will be supporting:

![MongoDB Atlas Cluster Name](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/cluster-name.png)

That's it! Be sure to review your options one last time before clicking the "Create Cluster" button.

![MongoDB Atlas Create Cluster](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/create-cluster.png)

### Step 4: Create a database user for your cluster

Atlas requires clients to authenticate as MongoDB database users to access clusters, so let's create one real quick for your cluster.

![MongoDB Atlas Add Database User](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/add-database-user.gif)

As you can see in the GIF above, creating a database user is straightforward. First navigate to the "Database Access" section (located under "Security" in the left-hand navigation bar). Click on "Create a new Database User". A prompt will appear where you can choose this user's authentication method and database user privileges.

Select the "Password" authentication method and give this user a username and password. As a convenience, you can even autogenerate a secure password right in Atlas, which we highly recommend.

>💡 After autogenerating your password, be sure to click Copy and store it in a safe place for now. We'll need it later when connecting to our cluster!

Choose a built-in role for this user. For this tutorial, I'm choosing "Atlas admin" which grants the most privileges.

Finally, click the "Add User" button. You've created your cluster's first database user!

### Step 5: Grant authorized IP addresses access to your cluster

The last step in setting up your cluster is to choose which IP addresses are allowed to access it. To quickly get up and running, set your cluster to allow access from anywhere:

![MongoDB Atlas Allow Access from Anywhere](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/allow-access-anywhere.gif)

**Congratulations! You've just successfully set up your Atlas cluster!**

>💡 Note: You probably don't want to allow this type of access in a production environment. Instead, you'll want to identify the exact IP addresses you know your application will be hosted on and explicitly set which IP addresses, or IP ranges, should have access to your cluster.  After setting up your Heroku app, follow the steps in the "Configuring Heroku IP Addresses in Atlas" section below to see how to add the proper IP addresses for your Heroku app.

## Configuring Heroku to point to MongoDB Atlas Cluster using config vars

Quickly setting up our Atlas cluster was pretty exciting, but we think you'll find this section even more thrilling!

Atlas-backed, Heroku applications are simple to set up. All you need to do is create an application-level config var that holds your cluster's connection string. Once set up, you can securely access that config var within your application!

Here's how to do it:

### Step 1: Log into the Heroku CLI

``` bash
heroku login
```

This command opens your web browser to the Heroku login page. If you're already logged in, just click the "Log in" button. Alternatively, you can use the -i flag to log in via the command line.

### Step 2: Clone My Demo App

To continue this tutorial, I've created a [demo Node application](https://github.com/adriennetacke/mongodb-atlas-heroku-leaflix-demo) that uses MongoDB Atlas and is an app I'd like to deploy to Heroku.  Clone it, then navigate to its directory:

``` bash
git clone https://github.com/adriennetacke/mongodb-atlas-heroku-leaflix-demo.git

cd mongodb-atlas-heroku-leaflix-demo
```

### Step 3: Create the Heroku app

``` bash
heroku create leaflix
```

As you can see, I've named mine `leaflix`.

### Get your Atlas Cluster connection string

Head back to your Atlas cluster's dashboard as we'll need to grab our connection string.

Click the "Connect" button.

Choose the "Connect your application" option.

Here, you'll see the connection string we'll need to connect to our cluster. Copy the connection string.

Paste the string into an editor; we'll need to modify it a bit before we can set it to a Heroku config variable.

As you can see, Atlas has conveniently added the username of the database user we previously created. To complete the connection string and make it valid, replace the \<password> with your own database user's password and `<dbname>` with `sample_mflix`, which is the sample dataset our demo application will use.

>💡 If you don't have your database user's password handy, autogenerate a new one and use that in your connection string. Just remember to update it if you autogenerate it again! You can find the password by going to Database Access \> Clicking "Edit" on the desired database user \> Edit Password \> Autogenerate Secure Password

### Set a MONGODB_URI config var

Now that we've properly formed our connection string, it's time to store it in a Heroku config variable. Let's set our connection string to a config var called MONGODB_URI:

``` bash
heroku config:set MONGODB_URI="mongodb+srv://yourUsername:yourPassword@yourClusterName.n9z04.mongodb.net/sample_mflix?retryWrites=true&w=majority"
```

Some important things to note here:

-   This command is all one line.
-   Since the format of our connection string contains special characters, it is necessary to wrap it within quotes.

That's all there is to it! You've now properly added your Atlas cluster's connection string as a Heroku config variable, which means you can securely access that string once your application is deployed to Heroku.

>💡 Alternatively, you can also add this config var via your app's "Settings" tab in the Heroku Dashboard. Head to your [apps](https://dashboard.heroku.com/apps) \> leaflix \> Settings. Within the Config Vars section, click the "Reveal Config Vars" button, and add your config var there.

![Heroku Config Dashboard](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/config-var-dashboard.png)

The last step is to modify your application's code to access these variables.

## Connecting your app to MongoDB Atlas Cluster using Heroku config var values

In our demo application, you'll see that we have hard-coded our Atlas cluster connection string. We should refactor our code to use the Heroku config variable we previously created.

[Config vars are exposed to your application's code as environment variables](https://devcenter.heroku.com/articles/config-vars#accessing-config-var-values-from-code).  Accessing these variables will depend on your application's language; for example, you'd use `System.getenv('key')` calls in Java or `ENV['key']` calls in Ruby.

Knowing this, and knowing our application is written in Node, we can access our Atlas cluster via the `process.env` property, made available to us in Node.js. In the `server.js` file, change the uri constant to this:

``` bash
const uri = process.env.MONGODB_URI;
```

That's it! Since we've added our Atlas cluster connection string as a Heroku config var, our application will be able to access it securely once it's deployed.

Save that file, commit that change, then deploy your code to Heroku.

``` bash
git commit -am "fix: refactor hard coded connection string to Heroku config var"

git push heroku master
```

Your app is now deployed! You can double check that at least one instance of Leaflix is running by using this command:

``` bash
heroku ps:scale web=1
```

If you see a message that says `Scaling dynos... done, now running web at 1:Free`, you'll know that at least one instance is up and running.

Finally, go visit your app. You can do so with this useful command:

``` bash
heroku open
```

If all is well, you'll see something like this:

![Leaflix App](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/leaflix-deployed.png)

When you click on the "Need a Laugh?" button, our app will randomly choose a movie that has the "Comedy" genre in its genres field. This comes straight from our Atlas cluster and uses the `sample_mflix` dataset.

## Configuring Heroku IP addresses in MongoDB Atlas

We have our cluster up and running and our app is deployed to Heroku!

To get us through the tutorial, we initially configured our cluster to accept connections from any IP address. Ideally you would like to restrict access to only your application, and there are a few ways to do this on Heroku.

The first way is to use an add-on to provide a static outbound IP address for your application that you can use to restrict access in Atlas. You can find some listed here:

<https://elements.heroku.com/addons/categories/network>

Another way would be to use Heroku Private Spaces and use the static outbound IPs for your space. This is a more expensive option, but does not require a separate add-on.

There are some documents and articles out there that suggest you can use IP ranges published by either AWS or Heroku to allow access to IPs originating in your AWS region or Heroku Dynos located in those regions.  While this is possible, it is not recommended as those ranges are subject to change over time. Instead we recommend one of the two methods above.

Once you have the IP address(es) for your application, you can use them to configure your firewall in Atlas.

Head to your Atlas cluster, delete any existing IP ranges, then add them to your allow list:

![MongoDB Atlas Add Select IP Range](https://mongodb-devhub-cms.s3.us-west-1.amazonaws.com/old_images/heroku/add-ip-range.gif)

Of course, at all times you will be communicating between your application and your Atlas database securely via TLS encryption.

## Conclusion

We've accomplished quite a bit in a relatively short time! As a recap:

-   We set up and deployed an Atlas cluster in five steps or less.
-   We created a Heroku config variable to securely store our Atlas connection string, enabling us to connect our Atlas cluster to our Heroku application.
-   We learned that Heroku config variables are exposed to our application's code as environment variables.
-   We refactored the hard-coded URI string in our code to point to a `process.env.MONGODB_URI` variable instead.

Have additional questions or a specific use case not covered here? Head over to [MongoDB Developer's Community Forums](https://developer.mongodb.com/community/forums/) and start a discussion! We look forward to hearing from you.

And to learn more about [MongoDB Atlas](https://www.mongodb.com/cloud/atlas), check out this great [Intro to MongoDB Atlas in 10 Minutes](https://youtu.be/xrc7dIO_tXk) by fellow developer advocate [Jesse Hall](https://twitter.com/codestackr)!


Learn how to deploy MongoDB Atlas on Heroku for fully managed cloud applications.

How to Deploy MongoDB on Heroku



<div class="introduction">

Back in September 2020, my colleagues [Nic
Raboy](https://www.nraboy.com/), [Karen
Huaulme](https://twitter.com/youoldmaid), and I decided to learn how to
build a game. At the time, [Fall Guys](https://fallguys.com/) was what
our team enjoyed playing together, so we set a goal for ourselves to
build a similar game. We called it Plummeting People! Every week, we'd
stream our process live on [Twitch](https://www.twitch.tv/mongodb).

As you can imagine, building a game is not an easy task; add to that
fact that we were all mostly new to game development and you have a
whirlwind of lessons learned while learning in public. After spending
the last four months of 2020 building and streaming, I've compiled the
lessons learned while going through this process, starting from the
first stream.

>
>
>📺️ Watch the full series
>[here](https://www.youtube.com/playlist?list=PL7P4hb5hUZ6ogzGCo6DtueW6LAZDeyKr_)
>(YouTube playlist)! And the
>[repo](https://github.com/mongodb-developer/plummeting-people-game) is
>available too.
>
>

</div>

<div class="content">

## Stream 1: Designing a Strategy to Develop a Game with Unity and MongoDB

As with most things in life, ambitious endeavors always start out with
some excitement, energy, and overall enthusiasm for the new thing ahead.
That's exactly how our game started! Nic, Karen, and I had a wonderful
stream setting the foundation for our game. What were we going to build?
What tools would we use? What were our short-term and long-term goals?
We laid it all out on a nice Jamboard. We even incorporated our chat's
ideas and suggestions!

>
>
>:youtube[]{vid=XAvy2BouZ1Q}
>
>Watch us plan our strategy for Plummeting People here!
>
>

### Lessons Learned

-   It's always good to have a plan; it's even better to have a flexible
    plan.
-   Though we separated our ideas into logical sections on our Jamboard,
    it would have been more helpful to have rough deadlines and a
    solidified understanding of what our minimum viable product (MVP)
    was going to be.

## Stream 2: Create a User Profile Store for a Game with MongoDB, Part 1

>
>
>:youtube[]{vid=XUQCOf3NuJQ}
>
>

## Stream 3: Create a User Profile Store for a Game with MongoDB, Part 2

>
>
>:youtube[]{vid=QgzA_9tXxy4}
>
>

### Lessons Learned

-   Sometimes, things will spill into an additional stream, as seen
    here. In order to fully show how a user profile store could work, we
    pushed the remaining portions into another stream, and that's OK!

## Stream 4: 2D Objects and 2D Physics

>
>
>:youtube[]{vid=wDRf2jHrCPM}
>
>

## Stream 5: Using Unity's Tilemap Creator

>
>
>:youtube[]{vid=TnJOSwvVZDo}
>
>

### Lessons Learned

-   Teammates get sick every once in a while! As you saw in the last two
    streams, I was out, and then Karen was out. Having an awesome team
    to cover you makes it much easier to be consistent when it comes to
    streaming.
-   Tilemap editors are a pretty neat and non-intimidating way to begin
    creating custom levels in Unity!

## Stream 6: Adding Obstacles and Other Physics to a 2D Game

>
>
>:youtube[]{vid=-gO9tvNgpu4}
>
>

### Lessons Learned

-   As you may have noticed, we changed our streaming schedule from
    weekly to every other week, and that helped immensely. With all of
    the work we do as Developer Advocates, setting the ambitious goal of
    streaming every week left us no time to focus and learn more about
    game development!
-   Sometimes, reworking the schedule to make sure there's **more**
    breathing room for you is what's needed.

## Stream 7: Making Web Requests from Unity

>
>
>:youtube[]{vid=UkpaRWkPbU4}
>
>

## Stream 8: Programmatically Generating GameObjects in Unity

>
>
>:youtube[]{vid=YLc28Xlvyt0}
>
>

### Lessons Learned

-   As you become comfortable with a new technology, it's OK to go back
    and improve what you've built upon! In this case, we started out
    with a bunch of game objects that were copied and pasted, but found
    that the proper way was to 1) create prefabs and 2) programmatically
    generate those game objects.
-   Learning in public and showing these moments make for a more
    realistic display of how we learn!

## Stream 9: Talking Some MongoDB, Playing Some Fall Guys

>
>
>:youtube[]{vid=BAjUOCRj03g}
>
>

### Lessons Learned

-   Sometimes, you gotta play video games for research! That's exactly
    what we did while also taking a much needed break.
-   It's also always fun to see the human side of things, and that part
    of us plays a lot of video games!

## Stream 10: A Recap on What We've Built

>
>
>:youtube[]{vid=_VfGoJjQ0kU}
>
>

### Lessons Learned

-   After season one finished, it was rewarding to see what we had
    accomplished so far! It sometimes takes a reflective episode like
    this one to see that consistent habits do lead to something.
-   Though we didn't get to everything we wanted to in our Jamboard, we
    learned way more about game development than ever before.
-   We also learned how to improve for our next season of game
    development streams. One of those factors is focusing on one full
    game a month! You can [catch the first one
    here](https://youtu.be/8S0NuFwFazY), where Nic and I build an
    infinite runner game in Unity.

</div>

<div class="summary">

## Summary

I hope this article has given you some insight into learning in public,
what it takes to stream your learning process, and how to continue
improving!

>
>
>📺️ Don't forget to watch the full season
>[here](https://www.youtube.com/playlist?list=PL7P4hb5hUZ6ogzGCo6DtueW6LAZDeyKr_)
>(YouTube playlist)! And poke around in the code by cloning our
>[repo](https://github.com/mongodb-developer/plummeting-people-game).
>
>

If you're interested in learning more about game development, check out
the following resources:

-   [Creating a Multiplayer Drawing Game with Phaser and
    MongoDB](https://developer.mongodb.com/how-to/creating-multiplayer-drawing-game-phaser/)
-   [Build an Infinite Runner Game with Unity and the Realm Unity
    SDK](https://developer.mongodb.com/how-to/build-infinite-runner-game-unity-realm-unity-sdk/)
-   [Developing a Side-Scrolling Platformer Game with Unity and MongoDB
    Realm](https://developer.mongodb.com/how-to/developing-side-scrolling-platformer-game-unity-mongodb-realm/)

If you have any questions about any of our episodes from this season, I
encourage you to join the [MongoDB
Community](http://community.mongodb.com). It's a great place to ask
questions! And if you tag me `@adriennetacke`, I'll be able to see your
questions.

Lastly, be sure to follow us on [Twitch](https://www.twitch.tv/mongodb)
so you never miss a stream! Nic and I will be doing our next game dev
stream on March 26, so see you there!

</div>


After learning how to build a game in public, see what lessons Adrienne learned while building a game with MongoDB and Unity

Lessons Learned from Building a Game with MongoDB and Unity

If you've ever glanced at a map to find the closest lunch spots to you, you've most likely used a geospatial query under the hood! In this tutorial, we'll learn how to store geospatial data in MongoDB Atlas and how to work with geospatial queries in the MongoDB C# driver.

MongoDB Geospatial Queries in C#

Learn how to use the Union All ($unionWith) aggregation pipeline stage, newly released in MongoDB 4.4.

How to Use the Union All Aggregation Pipeline Stage in MongoDB 4.4

# 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

Learn everything you need to know about multi-cloud clusters on MongoDB Atlas.