FGV.Lib.Persistence.MongoDb 1.0.0

FGV.Lib.Persistence.MongoDb

A lightweight, flexible MongoDB persistence library that provides a robust repository pattern implementation for .NET applications. This library simplifies MongoDB database operations while promoting clean architecture and separation of concerns.

Features

• Generic repository pattern implementation for MongoDB
• Async/await support for all operations
• CRUD operations (Create, Read, Update, Delete)
• Filtering by expression
• Pagination support
• Strongly-typed document mapping
• Flexible configuration options

Installation

Via NuGet Package Manager

Install-Package FGV.Lib.Persistence.MongoDb

Via .NET CLI

dotnet add package FGV.Lib.Persistence.MongoDb

Via PackageReference in .csproj

<PackageReference Include="FGV.Lib.Persistence.MongoDb" Version="x.x.x" />

Configuration

Adding MongoDB to your services (Dependency Injection)

In your Startup.cs or Program.cs file:

using FGV.Lib.Persistence.MongoDb;
using FGV.Lib.Persistence.MongoDb.Interface;

// ...

public void ConfigureServices(IServiceCollection services)
{
    // Configure MongoDB
    services.AddSingleton<IMongoClient>(sp => new MongoClient(Configuration.GetConnectionString("MongoDb")));
    
    // Register the repository
    services.AddScoped<IMongoRepository<YourEntity>, MongoRepository<YourEntity>>();
    
    // Alternative: register for multiple entity types
    // services.AddScoped(typeof(IMongoRepository<>), typeof(MongoRepository<>));
}

Configuration in appsettings.json

{
"ConnectionStrings": {
    "MongoDb": "mongodb://username:password@localhost:27017/yourdatabase"
},
"MongoDbSettings": {
    "DatabaseName": "YourDatabaseName",
    "CollectionNamingConvention": "PascalCase" // Optional
}
}

Usage

Define your entity

using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;

public class Product
{
    [BsonId]
    [BsonRepresentation(BsonType.ObjectId)]
    public string Id { get; set; }
    
    public string Name { get; set; }
    
    public decimal Price { get; set; }
    
    public string Category { get; set; }
    
    public bool IsAvailable { get; set; }
}

Basic CRUD Operations

// Inject the repository in your constructor
private readonly IMongoRepository<Product> _productRepository;

public ProductService(IMongoRepository<Product> productRepository)
{
    _productRepository = productRepository;
}

// Create
public async Task AddProductAsync(Product product)
{
    await _productRepository.InsertAsync(product);
}

// Read (Get by ID)
public async Task<Product> GetProductByIdAsync(string id)
{
    return await _productRepository.GetByIdAsync(id);
}

// Read (Get all)
public async Task<IEnumerable<Product>> GetAllProductsAsync()
{
    return await _productRepository.GetAllAsync();
}

// Update
public async Task UpdateProductAsync(Product product)
{
    await _productRepository.UpdateAsync(product);
}

// Delete
public async Task DeleteProductAsync(string id)
{
    await _productRepository.DeleteAsync(id);
}

Filtering and Querying

// Get products by category
public async Task<IEnumerable<Product>> GetProductsByCategoryAsync(string category)
{
    return await _productRepository.FilterByAsync(p => p.Category == category);
}

// Get available products with price less than specified amount
public async Task<IEnumerable<Product>> GetAvailableProductsUnderPriceAsync(decimal maxPrice)
{
    return await _productRepository.FilterByAsync(p => p.Price < maxPrice && p.IsAvailable);
}

// Get single product that matches criteria
public async Task<Product> GetUniqueProductAsync(string name)
{
    return await _productRepository.FindOneAsync(p => p.Name == name);
}

Advanced Usage

Custom Collection Name

[BsonCollection("custom_products")]
public class Product
{
    // Properties...
}

Pagination

// Get products with pagination
public async Task<IEnumerable<Product>> GetProductsPagedAsync(int pageNumber, int pageSize)
{
    return await _productRepository.GetAllAsync(pageNumber, pageSize);
}

Working with Count

// Count all products
public async Task<long> CountAllProductsAsync()
{
    return await _productRepository.CountAsync();
}

// Count products that match a condition
public async Task<long> CountAvailableProductsAsync()
{
    return await _productRepository.CountAsync(p => p.IsAvailable);
}

License

This project is licensed under the MIT License - see the LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.