Explore Developer Center's New Chatbot! MongoDB AI Chatbot can be accessed at the top of your navigation to answer all your MongoDB questions.

Join us at AWS re:Invent 2024! Learn how to use MongoDB for AI use cases.
MongoDB Developer
C#
plus
Sign in to follow topics
MongoDB Developer Centerchevron-right
Developer Topicschevron-right
Languageschevron-right
C#chevron-right

The C# Driver Version 3.0 is Here! What Do You Need to Know?

Luce Carter5 min read • Published Oct 18, 2024 • Updated Nov 04, 2024
.NETC#
Facebook Icontwitter iconlinkedin icon
Rate this article
star-empty
star-empty
star-empty
star-empty
star-empty
We have exciting news! For the first time in eight years, the MongoDB C# Driver has had a major version update. So to celebrate the release of 3.0, let’s take a look at some of the things you need to know, and some examples of exciting features and changes.
You can view the upgrade guide in our documentation to see how to move from 2.X to 3.0. We also have a section in the documentation on what’s new in 3.0.

Good to know

The C# Driver team has put a lot of love and time into this release and it addresses a lot of tech debt and technical features. Below is a list of a few things that are good to know about this release.

Merge of high and core

As a developer using the driver, you may not even realize this but as of an earlier minor release of the driver, it was split into two layers known as “high” and “core.” High is essentially a client of core and what is currently exposed to users. However, it has since become clear that core does not need to be public, so they have been merged into one assembly. This is all part of the tech debt the team wanted to address for 3.0.

LINQ V2 removal

LINQ has been on version 3 for a while now, so with the release of 3.0, the driver now supports V3 as standard and V2 has been removed. Previously, before V2.19, you would have to explicitly specify the use of V3 through a MongoClientSettings object.
Now, you do not need to use this and instead will get the benefits of V3 without having to specify it.

GridFS is now included in the driver

If you have scenarios where you are storing files that exceed the 16MB document limit, you may have found yourself using the GridFS package. This was previously a separate library but is now available out of the box with 3.0!

GUID changes

MongoDB supports GUID as a data type and in many MongoDB collections, GUID fields in a document use the same type under the hood, BsonBinaryData. In the documentation , it explains the different GuidRepresentationMode property values that handle the different subtypes of GUID that can be found in older collections.
In summary, V2 assumes that all GUIDs use the same BsonBinaryData subtype. This is the default in the C# driver 2.X. In V3, fields in the same document can use different GUID formats and representation is configured at the property level using the serializer.
As of the 3.0 driver release, V3 will become the default and support for V2 will be removed.
There are also changes to the default behavior of the GUID serializer which will now handle GUIDs by default as GuidReprensentation.Unspecified. This is to encourage being explicit about the GuidRepresentation type being used.

MongoClient disposable

Currently, the best practice advice for the usage of MongoClient is to give it a singleton lifetime scope. However, some issues were seen which require per-instance scope as lifetime scope was causing excessive memory usage and undisposed resources.
Now, an experimental feature has been introduced where a new MongoClient implements IDisposable which means that the class and any classes that implement the IMongoClient interface have access to a Dispose() method. Once disposed, any member connections will result in a ObjectDisposedException
However, calling Dispose will not dispose of the cluster and the underlying connections, for this you will still need to call ClusterRegistry.UnregisterAndDisposeCluster().

Date and time improvements

This new 3.0 release brings a lot of improvements to date- and time-related things. Don’t worry, we won’t be getting into a debate about time zones!

DateOnly and TimeOnly

First up is things around including or excluding date or time. In .NET 6 (released back in 2021), two new types were introduced called DateOnly and TimeOnly, which remove the need for a time or a date, depending on the type. This means we don’t have to make up a time like we had to do previously—for example, when it was only the date that mattered.
3.0 now supports these types on your model classes!

DateTimeOffset

Historically, the driver has serialized DateTimeOffset as BSON arrays. This has now changed so that the default behavior is that under the hood, they are serialized as BSON documents.
If you want to return to the previous behavior, you can add the [BsonRepresentation(BsonType.Array)] attribute to the property in your model.

Updates to decimals

Previously, decimal and decimal128 were serialized as BSON string values. This meant having to do some manual extra code to treat it as a decimal in your code. In 3.0, this has been changed so that by default, it is stored as Decimal128 values.
There is an option to continue to use string if you prefer, though. Just add the attribute [BsonRepresentation(BsonType.String)] to your property.

BulkWrite API

There have also been changes to the BulkWrite API as part of the release of 3.0. These are aimed at improving developer experience by changing how it works and what it can be applied to.
Developers have been able to perform bulk write operations using BulkWrite() or BulkWriteAsync() for a while now, but this was only able to perform these operations on one collection at a time. Plus, it could only be done for a single write type, such as a batch of inserts, deletions, etc. You could still provide a mix of types to the call, but under the hood the driver would separate them out, leading to multiple database calls which isn't the most efficient as this leads to multiple round-trip calls. This meant that BulkWrite calls took much longer.
This has been changed as of 3.0. You can now perform multiple write operations, such as update or delete, with a single database call via the BulkWrite API.
You now use a BulkWriteModelclass that comes in the form of:
  • BulkWriteInsertOneModel<TDocument>
  • BulkWriteUpdateOneModel<TDocument>
  • BulkWriteUpdateManyModel<TDocument>
  • BulkWriteReplaceOneModel<TDocument>
  • BulkWriteDeleteOneModel<TDocument>
  • BulkWriteDeleteManyModel<TDocument>
You can replace TDocument with your POCO model class too. Be sure to visit the BulkWrite documentation to see more information and sample code relating to this change.

NuGet package refactoring

For a while now, we have supported client-side field level encryption (CSFLE), which adds an extra layer of security by encrypting your data before it is sent over the network to MongoDB.
This was done using the MongoDB.LibMongocrypt library. However, in 3.0, this has been changed slightly. The base CSFLE functionality can now be found in MongoDB.Driver.Encryption.
There has also been a change with the AWS authentication package which now has its own package. This means if you don’t want the AWS authentication functionality, you no longer have that excess code hiding in your published app.
In fact, this refactoring and moving out into different packages has led to some interesting stats for those that enjoy data:
  • In a simple CRUD application, the published folder size has gone from 38MB to 4MB!
  • Removed about 32% of the public APIs
  • Solution has six fewer projects, with 16 instead of 22
  • Reduced from 663K lines of code to 555K—a whopping reduction of 16%!
  • Removed about 200 .cs files
We have also deprecated the MongoDB.Driver.Legacy package in 2.X. This was available in 2.X to ease people migrating from 1.X. However, the continued presence of the 1.X API is leading to more confusion than we would want. In 3.0, this has been removed altogether.

Summary

How exciting! After eight years, we have a major release of the C# driver!
This article was just a teaser of some changes and things you should know. Of course, the best place to view all the latest and greatest is in our documentation.
Happy 3.0!
Top Comments in Forums
There are no comments on this article yet.
Start the Conversation

Facebook Icontwitter iconlinkedin icon
Rate this article
star-empty
star-empty
star-empty
star-empty
star-empty
Related
Tutorial

Saving Data in Unity3D Using PlayerPrefs


Sep 09, 2024 | 11 min read
Article

How to Set Up MongoDB Class Maps for C# for Optimal Query Performance and Storage Size


Aug 05, 2024 | 8 min read
Tutorial

Getting Started with MongoDB Atlas and Azure Functions using .NET and C#


Apr 02, 2024 | 8 min read
Tutorial

Query Your Data With ASP.NET Core, OData, and the MongoDB Entity Framework Core Provider


Jul 08, 2024 | 7 min read
Table of Contents