MongoFramework alternatives and similar packages
Based on the "ORM" category.
Alternatively, view MongoFramework alternatives based on common mentions on social networks and blogs.
-
TypeORM
ORM for TypeScript and JavaScript. Supports MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, SAP Hana, WebSQL databases. Works in NodeJS, Browser, Ionic, Cordova and Electron platforms. -
Dapper
DISCONTINUED. Dapper - a simple object mapper for .Net [Moved to: https://github.com/DapperLib/Dapper] -
Entity Framework
EF Core is a modern object-database mapper for .NET. It supports LINQ queries, change tracking, updates, and schema migrations. -
SqlSugar
.Net aot ORM Fastest ORM Simple Easy VB.NET Sqlite orm Oracle ORM Mysql Orm 虚谷数据库 postgresql ORm SqlServer oRm 达梦 ORM 人大金仓 ORM 神通ORM C# ORM , C# ORM .NET ORM NET5 ORM .NET6 ORM ClickHouse orm QuestDb ,TDengine ORM,OceanBase orm,GaussDB orm ,Tidb orm Object/Relational Mapping -
FreeSql
🦄 .NET aot orm, C# orm, VB.NET orm, Mysql orm, Postgresql orm, SqlServer orm, Oracle orm, Sqlite orm, Firebird orm, 达梦 orm, 人大金仓 orm, 神通 orm, 翰高 orm, 南大通用 orm, 虚谷 orm, 国产 orm, Clickhouse orm, DuckDB orm, TDengine orm, QuestDB orm, MsAccess orm. -
EFCore.BulkExtensions
Entity Framework EF Core efcore Bulk Batch Extensions with BulkCopy in .Net for Insert Update Delete Read (CRUD), Truncate and SaveChanges operations on SQL Server, PostgreSQL, MySQL, SQLite -
Dapper Extensions
Dapper Extensions is a small library that complements Dapper by adding basic CRUD operations (Get, Insert, Update, Delete) for your POCOs. For more advanced querying scenarios, Dapper Extensions provides a predicate system. The goal of this library is to keep your POCOs pure by not requiring any attributes or base class inheritance. -
Entity Framework 6
This is the codebase for Entity Framework 6 (previously maintained at https://entityframework.codeplex.com). Entity Framework Core is maintained at https://github.com/dotnet/efcore. -
SmartSql
SmartSql = MyBatis in C# + .NET Core+ Cache(Memory | Redis) + R/W Splitting + PropertyChangedTrack +Dynamic Repository + InvokeSync + Diagnostics -
NPoco
Simple microORM that maps the results of a query onto a POCO object. Project based on Schotime's branch of PetaPoco -
SQLProvider
A general F# SQL database erasing type provider, supporting LINQ queries, schema exploration, individuals, CRUD operations and much more besides. -
MongoDB.Entities
A data access library for MongoDB with an elegant api, LINQ support and built-in entity relationship management -
MongoDB Repository pattern implementation
DISCONTINUED. Repository abstraction layer on top of Official MongoDB C# driver -
DbExtensions
Data-access framework with a strong focus on query composition, granularity and code aesthetics. -
NReco.Data
Fast DB-independent DAL for .NET Core: abstract queries, SQL commands builder, schema-less data access, POCO mapping (micro-ORM). -
EntityFrameworkCore.SqlServer.SimpleBulks
Fast and simple bulk insert (retain client populated Ids or return db generated Ids), bulk update, bulk delete, bulk merge and bulk match for SQL Server. -
Linq.Expression.Optimizer
System.Linq.Expression expressions optimizer. http://thorium.github.io/Linq.Expression.Optimizer -
EntityFramework.DatabaseMigrator
EntityFramework.DatabaseMigrator is a WinForms utility to help manage Entity Framework 6.0+ migrations.
CodeRabbit: AI Code Reviews for Developers
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of MongoFramework or a related project?
README
[Icon](images/icon.png)
MongoFramework
An "Entity Framework"-like interface for MongoDB
Overview
MongoFramework tries to bring some of the nice features from Entity Framework into the world of MongoDB.
Some of the major features include:
- Entity mapping for collections, IDs and properties through attributes
- Indexing through attributes (including text and geospatial)
- Entity change tracking
- Changeset support (allowing for queuing multiple DB updates to run at once)
- Diff-updates (only changes to an entity to be written)
- Entity Buckets (clustering of small documents together, improving index performance)
- Runtime type discovery (serialize and deserialize without needing to specify every "known" type)
MongoFramework is currently built on-top of the official MongoDB C# driver.
Licensing and Support
MongoFramework is licensed under the MIT license. It is free to use in personal and commercial projects.
There are support plans available that cover all active Turner Software OSS projects. Support plans provide private email support, expert usage advice for our projects, priority bug fixes and more. These support plans help fund our OSS commitments to provide better software for everyone.
MongoFramework Extensions
These extensions are official packages that enhance the functionality of MongoFramework, integrating it with other systems and tools.
MongoFramework.Profiling.MiniProfiler
Supports profiling database reads and writes, pushing the data into MiniProfiler.
Documentation
Core Entity Mapping
The core mapping of entities and their properties is automatic however there are certain attributes you can apply to your properties to alter this behaviour.
These attributes (and a few others) are part of the System.ComponentModel.Annotations
package.
Attribute | Description |
---|---|
[Table("MyFancyEntity", Schema = "MyNamespace")] |
Map the Entity to the collection specified. When a schema is specified, it is prefixed onto the name with a "." (dot) separator. |
[Key] |
Map the property as the "Id" for the entity. Only required if your key doesn't have a common name like "Id" etc. |
[NotMapped] |
Unmaps the property from the entity when reading/writing. |
[Column("NewColumnName")] |
Remaps the property with the specified name when reading/writing. |
Indexing
MongoFramework supports indexing specified through the IndexAttribute
class. This is applied to the properties you want indexed and will apply the changes to the database when the context is saved.
public class IndexExample
{
public string Id { get; set; }
[Index("Email", IndexSortOrder.Ascending)]
public string EmailAddress { get; set; }
public string Name { get; set; }
}
The following variations of indexes are supported across various property types:
To support compound indexes, define indexes with the same name across multiple properties.
When doing this, you will want to control the order of the individual items in the compound index which is available through the IndexPriority
property on the attribute.
Special Index Types
MongoFramework supports Text and 2dSphere special indexes.
These special index types are selected through the IndexType
property on the Index attribute.
Please consult MongoDB's documentation on when the indexes are appropriate and their restrictions.
Contexts and Connections
Like Entity Framework, MongoFramework is built around contexts - specifically the MongoDbContext
.
An example context would look like:
public class MyContext : MongoDbContext
{
public MyContext(IMongoDbConnection connection) : base(connection) { }
public MongoDbSet<MyEntity> MyEntities { get; set; }
public MongoDbSet<MyOtherEntity> MyOtherEntities { get; set; }
}
While it mostly feels the same as creating contexts in Entity Framework, there are a number of differences still with the biggest being in the creation of contexts.
The IMongoDbConnection
is the core infrastructure that allows connection to MongoDB and is required to instantiate a context.
You can create an instance of a connection in two ways:
IMongoDbConnection connection;
//FromUrl
connection = MongoDbConnection.FromUrl(new MongoUrl("mongodb://localhost:27017/MyDatabase")); //MongoUrl comes from the official MongoDB driver
//FromConnectionString
connection = MongoDbConnection.FromConnectionString("mongodb://localhost:27017/MyDatabase");
Special Queries
You can perform text queries (with a Text index), geospatial distance queries (with a 2dSphere index) and geospatial intersecting queries.
myContext.MyDbSet.SearchText("text to search");
myContext.MyDbSet.SearchGeoIntersecting(e => e.FieldWithCoordinates, yourGeoJsonPolygon);
myContext.MyDbSet.SearchGeoNear(e => e.FieldWithCoordinates, yourGeoJsonPoint);
Each of these returns an IQueryable
which you can continue to narrow down the results like you would normally with LINQ.
For SearchGeoNear
specifically, there are optional parameters for setting the distance result field, the minimum distance and the maximum distance.
Entity Buckets
Entity buckets are a method of storing many smaller documents in fewer larger documents. MongoFramework provides various classes that help in creating and managing buckets. A typical setup for using an entity bucket might look like:
public class MyBucketGrouping
{
public string SensorId { get; set; }
public DateTime Date { get; set; }
}
public class MyBucketItem
{
public DateTime EntryTime { get; set; }
public int Value { get; set; }
}
public class MyContext : MongoDbContext
{
public MyContext(IMongoDbConnection connection) : base(connection) { }
[BucketSetOptions(bucketSize: 1000, entityTimeProperty: nameof(MyBucketItem.EntryTime))]
public MongoDbBucketSet<MyBucketGrouping, MyBucketItem> MyBuckets { get; set; }
}
The attribute BucketSetOptions
is required.
The bucketSize
is the maximum number of items in a single bucket.
The entityTimeProperty
identifies the property name in the sub-entity where a timestamp is stored.
Keep in mind the limitations of MongoDB (size of document) when determining the number of items in a bucket.
Managing buckets is very similar to managing normal entities though are currently limited to add data only.
using (var context = new MyContext(MongoDbConnection.FromConnectionString("mongodb://localhost:27017/MyDatabase")))
{
context.MyBuckets.AddRange(new MyBucketGrouping
{
SensorId = "ABC123",
Date = DateTime.Parse("2020-04-04")
}, new []
{
new MyBucketItem
{
EntryTime = DateTime.Parse("2020-04-04T01:00"),
Amount = 123
},
new MyBucketItem
{
EntryTime = DateTime.Parse("2020-04-04T02:00"),
Amount = 456
},
new MyBucketItem
{
EntryTime = DateTime.Parse("2020-04-04T03:00"),
Amount = 789
}
});
await context.SaveChangesAsync();
}
Extra Elements
Sometimes your model in the database will have more fields than the model you are deserializing to. You have two options to control the behaviour: ignore the fields or accept, mapping the extra fields to a specific dictionary.
To ignore the fields, you need to specify the IgnoreExtraElements
attribute on the entity's class definition.
To map the fields, you need to specify the ExtraElements
attribute on an IDictionary<string, object>
property.
Runtime Type Discovery
MongoFramework provides runtime type discovery in two methods: automatically for any properties of type object
and for any entities that specify the RuntimeTypeDiscovery
attribute on their class definition.
This type discovery means that you don't need to know what potential types extend any others which you would otherwise need to set via the BsonKnownTypes
attribute by the MongoDB driver.
[RuntimeTypeDiscovery]
public class KnownBaseModel
{
}
public class UnknownChildModel : KnownBaseModel
{
}
public class UnknownGrandChildModel : UnknownChildModel
{
}
Without the RuntimeTypeDiscovery
attribute in this scenario, the model will fail to deserialize properly from the database.
Complete Example
using MongoFramework;
using System.ComponentModel.DataAnnotations;
public class MyEntity
{
public string Id { get; set; }
public string Name { get; set; }
public string Description { get; set; }
}
public class MyContext : MongoDbContext
{
public MyContext(IMongoDbConnection connection) : base(connection) { }
public MongoDbSet<MyEntity> MyEntities { get; set; }
}
...
var connection = MongoDbConnection.FromConnectionString("YOUR_CONNECTION_STRING");
using (var myContext = new MyContext(connection))
{
var myEntity = myContext.MyEntities.Where(myEntity => myEntity.Name == "MongoFramework").FirstOrDefault();
myEntity.Description = "An 'Entity Framework'-like interface for MongoDB";
await myContext.SaveChangesAsync();
}
*Note that all licence references and agreements mentioned in the MongoFramework README section above
are relevant to that project's source code only.