ManagedCode.Database.AzureTables 2.0.2

Database

| Version | Package | Description | | ------- | ------- | ----------- | | | ManagedCode.Database.Core | Core | | | ManagedCode.Database.AzureTables | AzureTable | | | ManagedCode.Database.Cosmos | Cosmos DB | | | ManagedCode.Database.LiteDB | LiteDB | | | ManagedCode.Database.MongoDB | MongoDB | | | ManagedCode.Database.SQLite | SQLite |

Introduction

This library provides a unified interface for working with a variety of different document-oriented NoSQL databases. With this library, you can easily switch between different databases without having to change your code, making it easy to experiment with different options and find the best solution for your needs.

Motivation

Document-oriented NoSQL databases are a popular choice for many applications because of their flexibility and ease of use. However, each database has its own unique syntax and features, making it difficult to switch between them. This library aims to solve this problem by providing a consistent interface for working with multiple document-oriented NoSQL databases.

Features

• Provides a single, unified interface for working with multiple document-oriented NoSQL databases.
• Allows you to easily switch between different databases without having to change your code.
• Makes it easy to experiment with different options and find the best solution for your needs.

Usage

To use the library, simply import it and initialize a client for the database you want to use.

Contributing

We welcome contributions to this project. If you have an idea for a new feature or improvement, please open an issue to discuss it. If you want to submit a pull request, please make sure to follow the contribution guidelines and include tests for your changes.

OUTDATED--

Repository pattern implementation for C#.

A universal repository for working with multiple databases:

• InMemory
• Azure Tables
• CosmosDB
• LiteDB
• SQLite
• MSSQL
• PostgreSQL

General concept

We don't think you can hide the real database completely behind abstractions, so I recommend using your interfaces that will lend IReposity of the right type. And do the same with the direct implementation.

// declare the model as a descendant of the base type.
public class SomeModel : IItem<T>
{

}

// then create an interface
public interface ISomeRepository : IRepository<TId, TItem> where TItem : IItem<TId>
{
}

// create a class inherited from a repository of the desired type
public class SomeRepository : BaseRepository<TId, TItem> where TItem : class, IItem<TId>, new()
{
}

And then add your interface and dependency configuration class.

services
        .AddTransient<ISomeRepository, SomeRepository>()

This is to define the id type, and the object itself.

Azure Table

// declare the model as a descendant of the base type.
public class SomeModel : AzureTableItem
{

}


// then create an interface
public interface ISomeRepository : IAzureTableRepository<SomeModel>
{
}


// create a class inherited from a repository of the desired type
public class SomeRepository : AzureTableRepository<SomeModel>, ISomeRepository
{
    public SomeRepository(ILogger<SomeRepository> logger, IConfiguration config) : base(logger, 
        new AzureTableRepositoryOptions
        {
            ConnectionString = "connectionString"
        })
    {
    }
}

CosmosDB

// declare the model as a descendant of the base type.
public class SomeModel : CosmosDbItem
{

}


// then create an interface
public interface ISomeRepository : ICosmosDbRepository<SomeModel>
{
}


// create a class inherited from a repository of the desired type
public class SomeRepository : CosmosDbRepository<SomeModel>, ISomeRepository
{
    public SomeRepository(ILogger<SomeRepository> logger, IConfiguration config) : base(logger, 
        new CosmosDbRepositoryOptions
        {
            ConnectionString = "connectionString"
        })
    {
    }
}

LiteDB

// declare the model as a descendant of the base type.
public class SomeModel : LiteDbItem<string>
{

}


// then create an interface
public interface ISomeRepository : ILiteDbRepository<string, SomeModel>
{
}


// create a class inherited from a repository of the desired type
public class SomeRepository : LiteDbRepository<SomeModel>, ISomeRepository
{
    public SomeRepository(ILogger<SomeRepository> logger, IConfiguration config) : base(logger, 
        new LiteDbRepositoryOptions
        {
            ConnectionString = "connectionString"
        })
    {
    }
}

MongoDB

// declare the model as a descendant of the base type.
public class SomeModel : MongoDbItem<string>
{

}


// then create an interface
public interface ISomeRepository : IMongoDbRepository<SomeModel>
{
}


// create a class inherited from a repository of the desired type
public class SomeRepository : MongoDbRepository<SomeModel>, ISomeRepository
{
    public SomeRepository(ILogger<SomeRepository> logger, IConfiguration config) : base(logger, 
        new LiteDbRepositoryOptions
        {
            ConnectionString = "connectionString"
        })
    {
    }
}

SQLite

// declare the model as a descendant of the base type.
public class SomeModel : SQLiteItem
{

}


// then create an interface
public interface ISomeRepository : ISQLiteRepository<string, SomeModel>
{
}


// create a class inherited from a repository of the desired type
public class SomeRepository : SQLiteRepository<SomeModel>, ISomeRepository
{
    public SomeRepository(ILogger<SomeRepository> logger, IConfiguration config) : base(logger, 
        new SQLiteRepositoryOptions
        {
            ConnectionString = "connectionString"
        })
    {
    }
}