LiteDB

LiteDB: A .NET NoSQL Document Store in a Single Data File

LiteDB is a lightweight, fast, and embedded NoSQL database for .NET. It stores data in a single data file with a .db extension and supports various data types including collections, documents, and Bson types. LiteDB is ideal for desktop, mobile, and small web applications where a full-fledged database server like SQL Server or MongoDB might be overkill.

Key Features of LiteDB

• Serverless NoSQL Document Store: LiteDB operates as an embedded database, eliminating the need for a separate server. This makes it ideal for applications where simplicity and resource efficiency are paramount.

• Simple API: The API of LiteDB is designed to be user-friendly, resembling the familiar structure of MongoDB. This allows developers to quickly learn and utilize the database for various data management tasks.

• 100% C# Code: LiteDB is entirely written in C#, ensuring compatibility and performance within the .NET ecosystem. It's distributed as a single DLL, keeping the footprint minimal (less than 450 KB).

• Thread-Safe: LiteDB is designed to be thread-safe, allowing multiple threads to access and modify the database concurrently without compromising data integrity.

• ACID Compliance: LiteDB adheres to the ACID (Atomicity, Consistency, Isolation, Durability) properties, guaranteeing reliable and consistent data transactions.

• Transaction Support: Full transaction support ensures that multiple operations within a transaction are treated as a single unit, ensuring data consistency even in the event of failures.

• Data Recovery: LiteDB employs a write-ahead log (WAL) file for data recovery. This mechanism safeguards data integrity by ensuring that all write operations are logged before being applied to the main data file.

• Data Encryption: LiteDB offers data file encryption using DES (Data Encryption Standard) or AES (Advanced Encryption Standard) cryptography, safeguarding sensitive data stored within the database.

• POCO Mapping: LiteDB allows developers to map their Plain Old CLR Objects (POCOs) to BsonDocument using attributes or a fluent mapper API. This simplifies data representation and interaction with the database.

• File and Stream Storage: Similar to GridFS in MongoDB, LiteDB enables the storage of files and stream data within the database. This feature extends its capabilities beyond traditional document storage.

• Single Data File: Like SQLite, LiteDB stores all data in a single file, simplifying deployment and management.

• Indexing: LiteDB supports indexing of document fields for fast search and retrieval.

• LINQ Support: Queries can be constructed using LINQ (Language Integrated Query), providing a familiar and powerful way to interact with the data.

• SQL-like Commands: LiteDB offers SQL-like commands for accessing and transforming data, offering flexibility in data manipulation.

• LiteDB Studio: A dedicated GUI tool, LiteDB Studio, provides a user-friendly interface for managing and visualizing database data.

• Open Source and Free: LiteDB is available under the MIT license, making it free to use for both personal and commercial projects.

Setup LiteDB Dependency: Ensure you have LiteDB installed in your project. You can install it via NuGet:

dotnet add package LiteDB

1. Configure Dependency Injection: In your Startup.cs or Program.cs (for .NET 6):

   public void ConfigureServices(IServiceCollection services)
   {
       services.AddSingleton<LiteDatabase>(new LiteDatabase("Filename=myDatabase.db"));
       services.AddScoped<LiteDbService>();
       services.AddControllers();
   }

2. Run the Application: Start your ASP.NET Core application. The endpoints provided in BlogController will allow you to interact with the Blog collection in your LiteDB database.

Example Endpoints

• GET /api/blog: Retrieve all blog entries.

• GET /api/blog/{id}: Retrieve a specific blog entry by its ID.

• POST /api/blog: Create a new blog entry.

• PUT /api/blog/{id}: Update an existing blog entry or create a new one if it does not exist.

• PATCH /api/blog/{id}: Partially update an existing blog entry.

• DELETE /api/blog/{id}: Delete a blog entry.

By following these steps, you can effectively use LiteDB in your ASP.NET Core project to handle CRUD operations with ease. If you have any further questions or need additional assistance, feel free to ask!

Summary

This guide covers setting up LiteDB in an ASP.NET Core project. LiteDB provides a simple, fast, and efficient way to manage data in applications where a full-fledged database might be unnecessary. The provided code shows how to create a service and controller to handle CRUD operations with LiteDB. By configuring dependency injection and using the provided endpoints, you can easily integrate LiteDB into your project.

Services/LiteDbService.cs

using LiteDB;
using System.Linq.Expressions;

public class LiteDbService
{
    private readonly LiteDatabase _db;

    public LiteDbService(LiteDatabase db)
    {
        _db = db;
    }

    public BsonValue Add<T>(T reqModel, string tableOrClassName)
    {
        if (tableOrClassName == null)
            tableOrClassName = typeof(T).Name;
        return _db.GetCollection<T>(tableOrClassName).Insert(reqModel);
    }

    public bool Update<T>(T reqModel, string tableOrClassName)
    {
        if (tableOrClassName == null)
            tableOrClassName = typeof(T).Name;
        return _db.GetCollection<T>(tableOrClassName).Update(reqModel);
    }

    public bool Delete<T>(ObjectId Id, string tableOrClassName)
    {
        if (tableOrClassName == null)
            tableOrClassName = typeof(T).Name;
        return _db.GetCollection<T>(tableOrClassName).Delete(new BsonValue(Id));
    }

    public List<T> List<T>(string tableOrClassName)
    {
        if (tableOrClassName == null)
            tableOrClassName = typeof(T).Name;
        ILiteCollection<T> lst;
        if (tableOrClassName != null)
            lst = _db.GetCollection<T>(tableOrClassName);
        else
            lst = _db.GetCollection<T>();
        List<T> _list = lst.FindAll().ToList();
        return _list;
    }

    public T GetById<T>(Expression<Func<T, bool>> condition, string tableOrClassName)
    {
        ILiteCollection<T> lst;
        if (tableOrClassName != null)
            lst = _db.GetCollection<T>(tableOrClassName);
        else
            lst = _db.GetCollection<T>();
        var item = lst.Find(condition).FirstOrDefault();
        return item;
    }
}

Controllers/BlogController.cs

using DotNet8WebApi.LiteDbSample.Models.Blog;
using DotNet8WebApi.LiteDbSample.Services;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class BlogController : ControllerBase
{
	private readonly LiteDbService _liteDbService;
	private readonly string _tableName = "Blog";
	
	public BlogController(LiteDbService liteDbService)
	{
		_liteDbService = liteDbService;
	}
	
	[HttpGet]
	public IActionResult Get()
	{
		var lst = _liteDbService.List<BlogModel>(_tableName);
		return Ok(lst);
	}
	
	[HttpGet("{id}")]
	public IActionResult GetById(string id)
	{
		var item = _liteDbService.GetById<BlogModel>(x => x.BlogId == id, _tableName);
		if (item == null)
		{
			return NotFound("No Data Found.");
		}
		return Ok(item);
	}
	
	[HttpPost]
	public IActionResult Create()
	{
		var newBlog = new BlogModel
		{
			BlogId = Ulid.NewUlid().ToString(),
			BlogTitle = "LiteDb",
			BlogAuthor = "LiteDb",
			BlogContent = "LiteDb",
		};
		_liteDbService.Add(newBlog, _tableName);
		return Ok(newBlog);
	}
	
	[HttpPut("{id}")]
	public IActionResult Put(string id, BlogRequestModel reqModel)
	{
		var item = _liteDbService.GetById<BlogModel>(x => x.BlogId == id, _tableName);
	
		if (item == null)
		{
			// Create a new blog entry if it does not exist
			var newBlog = new BlogModel
			{
				BlogId = id,
				BlogTitle = reqModel.BlogTitle,
				BlogAuthor = reqModel.BlogAuthor,
				BlogContent = reqModel.BlogContent,
			};
			_liteDbService.Add(newBlog, _tableName);
			return CreatedAtAction(nameof(GetById), new { id = newBlog.BlogId }, newBlog);
		}
	
		// Update the existing blog entry
		item.BlogTitle = reqModel.BlogTitle;
		item.BlogAuthor = reqModel.BlogAuthor;
		item.BlogContent = reqModel.BlogContent;
	
		var result = _liteDbService.Update(item, _tableName);
		return Ok(result);
	}
	
	[HttpPatch("{id}")]
	public IActionResult Patch(string id, BlogRequestModel reqModel)
	{
		var item = _liteDbService.GetById<BlogModel>(x => x.BlogId == id, _tableName);
	
		if (!string.IsNullOrEmpty(reqModel.BlogTitle))
		{
			item.BlogTitle = reqModel.BlogTitle;
		}
	
		if (!string.IsNullOrEmpty(reqModel.BlogAuthor))
		{
			item.BlogAuthor = reqModel.BlogAuthor;
		}
	
		if (!string.IsNullOrEmpty(reqModel.BlogContent))
		{
			item.BlogContent = reqModel.BlogContent;
		}
	
		var result = _liteDbService.Update(item , _tableName);
		return Ok(result);
	}
	
	[HttpDelete("{id}")]
	public IActionResult Delete(string id)
	{
		var item = _liteDbService.GetById<BlogModel>(x => x.BlogId == id, _tableName);
		var result = _liteDbService.Delete<BlogModel>(item.Id!, _tableName);
		return Ok(result);
	}
}

Models/BlogModel.cs

using LiteDB;

public class BlogModel
{
    public ObjectId Id { get; set; }
    public string BlogId { get; set; }
    public string BlogTitle { get; set; }
    public string BlogAuthor { get; set; }
    public string BlogContent { get; set; }
}

Models/BlogRequestModel.cs

public class BlogRequestModel
{
    public string BlogTitle { get; set; }
    public string BlogAuthor { get; set; }
    public string BlogContent { get; set; }
}

Conclusion

LiteDB is a powerful and versatile NoSQL database for .NET applications. Its simplicity, performance, and feature-rich capabilities make it an excellent choice for a wide range of projects. Whether you need a lightweight database for local applications or a simple data store for small websites, LiteDB offers a reliable and efficient solution.