Database access with Dependency Injection (DI)

Starting from this version, static Starcounter 2.x style Db class has been removed.
The current release introduces new SC framework API based on dependency injection (DI), which has been for long time requested by the majority of our users.
In this release, database access and operations are provided via two main Starcounter services.
Starcounter.Database.ITransactor - provides database transactions and data manipulation (DML) API.
Starcounter.Database.IDdlExecutor - provides data definition (DDL) API.
The purpose of the current release is to polish the new SC framework API and approve it with the customers. In the future public releases we plan to introduce a so-called static API serving same purpose as Db class in Starcounter 2.x, yet free from known flaws and strictly built on top of the new SC framework API.
Why Dependency Injection (DI)?
One of the major disadvantages of the static classes usage is inability to test such code with unit tests. With Dependency Injection it is possible to mock tested services and write unit tests for the application.
Furthermore, current approach reduces possibilities for invalid database access:
Attempt to create a new database object without a transaction.
Attempt to access a database object without a transaction.
Attempt to execute a DDL statement within a transaction.
Read more about Dependency Injection - Design Patterns Explained – Dependency Injection with Code Examples.
Examples
Database DML & DDL operations
Previously Db.SQL method was responsible for all kind of SQL statements. This led to a confusion, when developers tried to execute DDL statements within a transaction and access database without a transaction.
1
Db.Transact(() =>
2
{
3
    // This is a valid database access.
4
    // DML operations require a database transaction.
5
    Db.SQL("SELECT i FROM Item i");
6
​
7
    // This is an invalid database access.
8
    // DDL operations cannot be executed within a transaction.
9
    Db.SQL("CREATE INDEX IX_Item ON Item (Name)");
10
​
11
    // This is a valid database object creation.
12
    // DML operations require a database transaction.
13
    var newItem = Db.Insert<Item>();
14
​
15
    // This is a valid database object access.
16
    // DML operations require a database transaction.
17
    var existingItem = Db.Get<Item>(1);
18
    existingItem.Name = "Valid";
19
});
20
​
21
// This is an invalid database object creation.
22
// A database transaction is required to create a database object.
23
var newItem = Db.Insert<Item>();
24
​
25
// This is an invalid database object access.
26
// DML operations require a database transaction.
27
var existingItem = Db.Get<Item>(1);
28
existingItem.Name = "Invalid";
Copied!
With introduction of the ITransactor and IDdlExecutor database services it is easier to follow the code flow and database interaction. The Insert and Get database operations are only available within a transaction.
ASP.NET Core DbAccessController sample
1
using System;
2
using System.Linq;
3
using Microsoft.AspNetCore.Mvc;
4
using Newtonsoft.Json;
5
using Starcounter.Database;
6
​
7
namespace DiSample
8
{
9
    // Define database class
10
    [Database]
11
    public abstract class Item
12
    {
13
        public abstract int Id { get; set; }
14
        public abstract string Name { get; set; }
15
    }
16
}
17
​
18
namespace DiSample.Controllers
19
{
20
    public class DbAccessController : Controller
21
    {
22
        private readonly IDdlExecutor _ddlExecutor;
23
        private readonly ITransactor _transactor;
24
​
25
        // The DbAccessController class requires
26
        // two services: IDdlExecutor & ITransactor.
27
        public DbAccessController(IDdlExecutor ddlExecutor, ITransactor transactor)
28
        {
29
            _ddlExecutor = ddlExecutor;
30
            _transactor = transactor;
31
        }
32
​
33
        // Perform Starcounter DML operations.
34
        // Select an Item with specified id.
35
        // Create one if there is no such item yet.
36
        // Return as JSON string.
37
        public string GetItem(int id)
38
        {
39
            string result = null;
40
​
41
            _transactor.Transact(db =>
42
            {
43
                Item item = db.Sql<Item>
44
                (
45
                    "SELECT i FROM DiSample.Item i WHERE i.Id = ?",
46
                    id
47
                ).FirstOrDefault();
48
​
49
                if (item == null)
50
                {
51
                    item = db.Insert<Item>();
52
                    item.Id = id;
53
                    item.Name = DateTime.Now.ToString();
54
                }
55
​
56
                result = JsonConvert.SerializeObject(item);
57
            });
58
​
59
            return result;
60
        }
61
​
62
        // Perform Starcounter DDL operation.
63
        public string CreateIndex()
64
        {
65
            _ddlExecutor.Execute("CREATE INDEX IX_DiSample_Item ON Item (Id)");
66
​
67
            return "Database index IX_DiSample_Item has been successfully created.";
68
        }
69
​
70
        // Perform Starcounter DDL operation.
71
        public string DropIndex()
72
        {
73
            _ddlExecutor.Execute("DROP INDEX IX_DiSample_Item ON Item");
74
​
75
            return "Database index IX_DiSample_Item has been successfully dropped.";
76
        }
77
    }
78
}
Copied!

Database creation options

Running Starcounter 3.0 applications under Docker

Last modified 2yr ago

Copy link

Contents

Why Dependency Injection (DI)?

Examples

ASP.NET Core DbAccessController sample