DEV Community: Emanuel Gustafzon

Dependency Injection Dotnet

Emanuel Gustafzon — Tue, 31 Dec 2024 17:36:28 +0000

Welcome to the last post of this series and congrats for getting this far. You should now have a solid understanding of Dependecy Injection so let's implement it in dotnet.

Lifetimes

Dotnet support different lifetimes, Transient, Scoped and Singleton.

You would tipically use Scoped in WebApps and Apis where the scoped lifetime is the lifetime of a HTTP Context. If you work in Maui or WPF etc you need to explicity create the scope and that adds extra complexity so normally you would use Transient or Singleton in those types of applications.

SetUp

You do the setup and configuration in Program.cs.

If you work in Maui or ASP.NET Core, you will see that Dependecy injection is already setup but in this example we use a Console App so we need to set it up ourselves.

Start off by downloading the following packages.

Microsoft.Extensions.Hosting
Microsoft.Extensions.DependencyInjection

Create the default builder and configure your services

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        // Add Your Services here
    }).Build();

Add collection of services

So as you can see below you can add a collection of services with a defined lifetime.

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        services.AddSingleton<MySingleTonService>();
        services.AddScoped<MyScopedService>();
        services.AddTransient<MyTransientService>();
    }).Build();

Add interfaces

You can also add a interface to the registered service which is also best practice.

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        services.AddSingleton<IMyService, MyService>();
    }).Build();

IServiceProvider

The collection of services we just configured implements the interface IServiceprovider.

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        // My Collection of registered services
    }).Build();

IServiceProvider serviceProvider = host.Services;

Put it all together

Create the Services and interfaces

In this example we have a notification service that is dependent on an email service.

public interface IEmailService
{
    public void SendEmail(string email, string message);
}

public class EmailService : IEmailService
{
    public void SendEmail(string email, string message)
    {
        Console.WriteLine($"Sending {message} to {email}");
    }
}
public interface INotificationService
{
    public void NotifyUser(User user, string message);
}

public class NotficationService : INotificationService
{
    IEmailService _emailService;

    public NotficationService(IEmailService emailService)
    {
        _emailService = emailService;
    }

    public void NotifyUser(User user, string message)
    {
        _emailService.SendEmail(user.Email, message);
    }
}
public class User
{
    public string Name { get; set; } = null!;
    public string Email { get; set; } = null!;
}

Register the services

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        services.AddTransient<IEmailService, EmailService>();
        services.AddTransient<INotificationService, NotficationService>();
    }).Build();

Access the Notification service

var notify =  host.Services.GetRequiredService<INotificationService>();
User user = new User { Name = "Emanuel", Email = "Emanuel@domain.com" };
notify.NotifyUser(user, "Hello There!");

// output: Sending Hello There! to Emanuel@domain.com

Use IServiceProvider to access services

You can also access services through IServiceProvider. Let us rewrite the Notification Service.

public class NotficationService : INotificationService
{
    IServiceProvider _serviceProvider;

    public NotficationService(IServiceProvider serviceProvider)
    {
        _serviceProvider = serviceProvider;
    }

    public void NotifyUser(User user, string message)
    {
        var emailService = _serviceProvider.GetRequiredService<IEmailService>();
        emailService.SendEmail(user.Email, message);
    }
}

This will work in the exact same way and we have more control over what services we want to access.

Different Lifetimes in action.

So in a Console App we need to create the scope explicity so let's do that.

For demostration purpose I will create a model that contains a unique ID and we will see how i singleton returns the same instance throughout the hole program and therefore the same ID. Scoped will return the same instance in the same scope and a transient will return a new instance everytime.

var host = Host.CreateDefaultBuilder()
    .ConfigureServices(services =>
    {
        services.AddScoped<UniqueIDSingelton>();
        services.AddScoped<UniqueIDScoped>();
        services.AddTransient<UniqueIDTransient>();
    }).Build();
public class UniqueIDSingelton
{
    public string ID = Guid.NewGuid().ToString();
}
public class UniqueIDScoped
{
    public string ID = Guid.NewGuid().ToString();
}
public class UniqueIDTransient
{
    public string ID = Guid.NewGuid().ToString();
}

Create two scopes.

var scope1 = host.Services.CreateScope();
var scope2 = host.Services.CreateScope();

Now let us see how a serviice with scoped lifetime behave.

var scope1 = host.Services.CreateScope();

var UniqueId1Scope1 = scope1.ServiceProvider.GetRequiredService<UniqueIDScoped>();
var UniqueId2Scope1 = scope1.ServiceProvider.GetRequiredService<UniqueIDScoped>();

Console.WriteLine(UniqueId1Scope1.ID == UniqueId2Scope1.ID); // true

var scope2 = host.Services.CreateScope();
var UniqueIdScope2 = scope2.ServiceProvider.GetRequiredService<UniqueIDScoped>();


Console.WriteLine(UniqueId1Scope1.ID == UniqueIdScope2.ID); // false

The instance will be the same in the same scope as you see.

let us move over to Singelton. You will see that even though I get the service in two different scopes the instance and therfore the ID is the same.

var scope1 = host.Services.CreateScope();
var singeltonScope1 = scope1.ServiceProvider.GetRequiredService<UniqueIDSingelton>();

var scope2 = host.Services.CreateScope();
var singeltonScope2 = scope1.ServiceProvider.GetRequiredService<UniqueIDSingelton>();

Console.WriteLine(singeltonScope1.ID == singeltonScope2.ID); // true

Last let's see Transient in action and how it gives a new instance everytime. Below we call the service twice in the same scope but the instance and therefore the ID is different.

var scope1 = host.Services.CreateScope();
var transient1 = scope1.ServiceProvider.GetRequiredService<UniqueIDTransient>();
var transient2 = scope1.ServiceProvider.GetRequiredService<UniqueIDTransient>();

Console.WriteLine(transient1.ID == transient2.ID); // false

Alright there you have Dependency Injection in Dotnet and as I told you in an ASP.NET Core Application you do not need to explicity create the scope because the scope is already configured to be the scope of a HTTP request and in other types of applications like Maui etc, you would rather use Transient and Singelton.

Hope you found it useful and happy coding!

Build your own DI Container in JavaScript.

Emanuel Gustafzon — Sat, 06 Jul 2024 13:14:13 +0000

What we will build

In this chapter we will implement our own DI Container in JavaScript.

We will create a checkout simulation and we are going to use our DI Container to handle the dependency injection.

The services

Here is the service classes and the flow of our application. We have a credit card, a shipping bag and then a class that handles the transaction and one that sends the order.

// Independent service
class CreditCard {
  owner;
  address;
  number;
  cvc;

  set(owner, address, number, cvc) {
    this.owner = owner;
    this.address = address;
    this.number = number;
    this.cvc = cvc;
  }
}
// Independent service
class ShoppingBag {
  items = [];
  total = 0;
  addItem(item) {
    this.items.push(item);
    this.total += item.price;
  }
}
// Dependent on credit card and shopping bag 
class Transaction {
  constructor(creditCard, shoppingBag) {
    this.creditCard = creditCard;
    this.shoppingBag = shoppingBag;
  }
  transfer() {
    console.log(`Transfering ${this.shoppingBag.total} to ${this.creditCard.owner}`);
  }
}

// dependent on credit card and shopping bag
class SendOrder {
  constructor(creditCard, shoppingBag) {
    this.creditCard = creditCard;
    this.shoppingBag = shoppingBag;
  }
  send() {
    console.log(`Sending ${this.shoppingBag.total} to ${this.creditCard.address}`);
  }
}

DI Container skeleton

class DIContainer {
  services = new Map();

  register() {}

  resolve() {}
}

The DI container will have two methods, one to register the services and their dependencies and one to resolve the services and their dependencies.

The services are to be saved in a map with key-value pairs of the name of the service and the service/instance.

Simple registration and resolving

class DIContainer {
  services = new Map();

  register(serviceName, serviceDefinition) {
    this.services.set(serviceName, {
      serviceDefinition
    });
  }

  resolve(serviceName) {
    const service = this.services.get(serviceName);

    if (!service) {
      throw new Error(`Service ${serviceName} not found`);
    }

    return new service.serviceDefinition();
  }
}

Here we simply register a service by adding a key-value pair in the map with the service name and the service definition. The service definition is the class.

This is now like an instance generator.


const container = new DIContainer();

container.register('creditCard', CreditCard);

const creditCard1 = container.resolve('creditCard');

const creditCard2 = container.resolve('creditCard');

creditCard1.set('John Doe', 'Street 12', '0000-0000-0000', '123');

creditCard2.set('Jane Smith', 'Street 2', '0000-0000-0000', '123');

console.log(creditCard1, creditCard2)

Resolve dependencies

An instance generator is not exciting so let’s add dependencies to the services.

These are the steps:

Add an array of all the names of the dependencies.
Resolve all the dependencies by looping over the array and calling the resolve function on all the services.
Add the resolved dependencies into the constructor of the service.

class DIContainer {
  services = new Map();

  register(serviceName, serviceDefinition, dependencies = []) {
    this.services.set(serviceName, {
      serviceDefinition,
      dependencies
    });
  }

  resolve(serviceName) {
    const service = this.services.get(serviceName);

    if (!service) {
      throw new Error(`Service ${serviceName} not found`);
    }

    const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency));

    return new service.serviceDefinition(...resolvedDependencies);
  }
}

Now it starts to be interesting. Go ahead and register the services with the dependencies array.

const container = new DIContainer();

container.register('creditCard', CreditCard);
container.register('shoppingBag', ShoppingBag);
container.register('transaction', Transaction, ['creditCard', 'shoppingBag'])

const creditCard= container.resolve('creditCard');
const shoppingBag = container.resolve('shoppingBag');

creditCard.set('John Doe', 'Street 12', '0000-0000-0000', '123');
shoppingBag.addItem({name: 'Apple', price: 1.99});

container.resolve('transaction').transfer();

It works BUT in the console, we get Transfering 0 to undefined.

That's because of scope. the data from the credit card and shopping bag does not persist because our container creates a new instance every time it is called. It has a transient scope.

Add Scope

Let's add scope to our container. by adding a scope parameter in the register function.

  register(serviceName, serviceDefinition, scope, dependencies = []) {
    this.services.set(serviceName, {
      serviceDefinition,
      scope,
      dependencies
    });
  }

Add Transient

Our container already provides transient services but let's add an if statement for when it is transient and add the logic there.

  resolve(serviceName) {
    const service = this.services.get(serviceName);

    if (!service) {
      throw new Error(`Service ${serviceName} not found`);
    }
    if (service.scope === 'transient') {
      const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency));

      return new service.serviceDefinition(...resolvedDependencies);
    }
  }

Add Singleton

Let's also add support for singleton services. By doing so check if an instance already exists and if it does return the existing instance and don't create a new one.

In the resister function insiste an instance key in services and set it to null.


register(serviceName, serviceDefinition, scope, dependencies = []) {
    this.services.set(serviceName, {
      serviceDefinition,
      scope,
      dependencies,
      instance: null // add instance property to store the instance of the service
    });
  }

In the resolve method add an if statement for singleton and always return the same instance.

if (service.scope === 'singleton') {
        if (!service.instance) {
            const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency));
            service.instance = new service.serviceDefinition(...resolvedDependencies);
        }
        return service.instance;
    }

Now let’s register the credit card and shopping bag as singleton and the transaction as transient.

const container = new DIContainer();

container.register('creditCard', CreditCard, 'singleton');
container.register('shoppingBag', ShoppingBag, 'singleton');
container.register('transaction', Transaction, 'transient',['creditCard', 'shoppingBag'])

const creditCard= container.resolve('creditCard');
const shoppingBag = container.resolve('shoppingBag');

creditCard.set('John Doe', 'Street 12', '0000-0000-0000', '123');
shoppingBag.addItem({name: 'Apple', price: 1.99});

container.resolve('transaction').transfer();

And we get Transfering 1.99 to John Doe in the console.

BUT we are not there yet because the shopping bag and credit card will always have the same instance you can set different values but the instance is the same. So new users cannot add new cards or shopping bags.

watch the code below. We cannot resolve the credit card and shopping bag in different contexts. Let's add 2 cards and 2 bags and you see what I mean.

const creditCard= container.resolve('creditCard');
const shoppingBag = container.resolve('shoppingBag');

const creditCard2 = container.resolve('creditCard');
const shoppingBag2 = container.resolve('shoppingBag');

creditCard.set('John Doe', 'Street 12', '0000-0000-0000', '123');
shoppingBag.addItem({name: 'Apple', price: 1.99});

creditCard2.set('Dan Scott', 'Street 90', '1111-1111-1111', '321');
shoppingBag2.addItem({name: 'Orange', price: 2.99});

container.resolve('transaction').transfer();

Add Request/Scoped

We need to add an HTTP context to our container. Let's add a context parameter to the resolve method and a Map hashtable to save the scoped services.

class DIContainer {
  services = new Map();
  scopedServices = new Map(); // save the scoped services

  register(serviceName, serviceDefinition, scope, dependencies = []) {}

  // Add context
  resolve(serviceName, context = null) {}

}

Cool, add an if statement for scoped lifetimes in the resolve method.

Check if there is a context otherwise throw an error.

check if the current context already exists in the scopedServices Map otherwise create it.

    if(service.scope === 'scoped') {
        if (!context) {
                throw new Error('Scoped services requires a context.');
            }

            if (!this.scopedServices.has(context)) {
                // key value pair of context and a new map with the services
                this.scopedServices.set(context, new Map());
            }
    }

Now we have saved the context, let's find the saved context, add the service name and its instance, as well as the dependencies names and instances, and then resolve them.

    if(service.scope === 'scoped') {
        if (!context) {
                throw new Error('Scoped services requires a context.');
            }

            if (!this.scopedServices.has(context)) {
                this.scopedServices.set(context, new Map());
            }
            const contextServices = this.scopedServices.get(context);

            if (!contextServices.has(serviceName)) {
                const resolvedDependencies = service.dependencies.map(dependency=> this.resolve(dependency, context)); // Don't forget to include context
                const instance = new service.serviceDefinition(...resolvedDependencies);
                  contextServices.set(serviceName, instance);
            }

            return contextServices.get(serviceName);
    }

The structure of the scoped services looks like this:

{ 
context1: {
            serviceName: instance,
            serviceName: instance
           },
context2: {
            serviceName: instance,
            serviceName: instance
           }
}

We also need to pass the context to all dependencies being resolved. so let's do that also for transient and singleton services.

if (service.scope === 'transient') {
      // pass the context into dependencies
      const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency, context)); 

      return new service.serviceDefinition(...resolvedDependencies);
    }

if (service.scope === 'singleton') {
        if (!service.instance) {
            // pass the context into dependencies
            const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency, context));
            service.instance = new service.serviceDefinition(...resolvedDependencies);
        }
        return service.instance;
    }

Remove context

Now let's add a function that cleans up the scoped services.

We add one extra method to our DI Container called clearContext.

clearContext(context) {
          this.scopedServices.delete(context);
          console.log("Deleted context");
      }

Let's try it out.

We simulate a httpContext by creating an httpContextobject and sending it as an argument to the resolve function.

const container = new DIContainer();

container.register('creditCard', CreditCard, 'scoped');
container.register('shoppingBag', ShoppingBag, 'scoped');
container.register('transaction', Transaction, 'transient',['creditCard', 'shoppingBag'])
container.register('sendOrder', SendOrder, 'transient',['creditCard', 'shoppingBag'])

const httpContext = {
  headers: {
    "content-type": "application/json"
  },
  body: {
    url: "https://www.myStore.com/checkout"
  }
}
const httpContext2 = {
  headers: {
    "content-type": "application/json"
  },
  body: {
    url: "https://www.myStore.com/checkout"
  }
}

const creditCard = container.resolve('creditCard', httpContext);
const shoppingBag = container.resolve('shoppingBag', httpContext);

const creditCard2 = container.resolve('creditCard', httpContext2);
const shoppingBag2 = container.resolve('shoppingBag', httpContext2);

creditCard.set('John Doe', 'Street 12', '0000-0000-0000', '123');
shoppingBag.addItem({name: 'Apple', price: 1.99});

creditCard2.set('Dan Scott', 'Street 90', '1111-1111-1111', '321');
shoppingBag2.addItem({name: 'Orange', price: 2.99});

container.resolve('transaction', httpContext).transfer();
container.resolve('transaction', httpContext2).transfer();

container.clearContext(httpContext);
container.clearContext(httpContext2);

In the console you should see:

Transfering 1.99 to John Doe Transfering 2.99 to Dan Scott Deleted context Deleted context

Thanks for reading and happy coding!

Full example

class DIContainer {
  services = new Map();
  scopedServices = new Map();

  register(serviceName, serviceDefinition, scope, dependencies = []) {
    this.services.set(serviceName, {
      serviceDefinition,
      scope,
      dependencies,
      instance: null 
    });
  }
  resolve(serviceName, context = null) {
    const service = this.services.get(serviceName);

    if (!service) {
      throw new Error(`Service ${serviceName} not found`);
    }
    if (service.scope === 'transient') {
      const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency, context));

      return new service.serviceDefinition(...resolvedDependencies);
    }

    if (service.scope === 'singleton') {
        if (!service.instance) {
            const resolvedDependencies = service.dependencies.map(dependency => this.resolve(dependency, context));
            service.instance = new service.serviceDefinition(...resolvedDependencies);
        }
        return service.instance;
    }
    if(service.scope === 'scoped') {
        if (!context) {
                throw new Error('Scoped services requires a context.');
            }

            if (!this.scopedServices.has(context)) {
                this.scopedServices.set(context, new Map());
            }
            const contextServices = this.scopedServices.get(context);

            if (!contextServices.has(serviceName)) {
                const resolvedDependencies = service.dependencies.map(dependency=> this.resolve(dependency, context)); 
                const instance = new service.serviceDefinition(...resolvedDependencies);
                  contextServices.set(serviceName, instance);
            }

            return contextServices.get(serviceName);
    }
  }
  clearContext(context) {
        this.scopedServices.delete(context);
        console.log('Deleted context');
    }
}

// Independent service
class CreditCard {
  owner;
  address;
  number;
  cvc;

  set(owner, address, number, cvc) {
    this.owner = owner;
    this.address = address;
    this.number = number;
    this.cvc = cvc;
  }
}
// Independent service
class ShoppingBag {
  items = [];
  total = 0;
  addItem(item) {
    this.items.push(item);
    this.total += item.price;
  }
}
// Dependent on credit card and shopping bag 
class Transaction {
  constructor(creditCard, shoppingBag) {
    this.creditCard = creditCard;
    this.shoppingBag = shoppingBag;
  }
  transfer() {
    console.log(`Transfering ${this.shoppingBag.total} to ${this.creditCard.owner}`);
  }
}

// dependent on credit card and shopping bag
class SendOrder {
  constructor(creditCard, shoppingBag) {
    this.creditCard = creditCard;
    this.shoppingBag = shoppingBag;
  }
  send() {
    console.log(`Sending ${this.shoppingBag.total} to ${this.creditCard.address}`);
  }
}

const container = new DIContainer();

container.register('creditCard', CreditCard, 'scoped');
container.register('shoppingBag', ShoppingBag, 'scoped');
container.register('transaction', Transaction, 'transient',['creditCard', 'shoppingBag'])
container.register('sendOrder', SendOrder, 'transient',['creditCard', 'shoppingBag'])

const httpContext = {
  headers: {
    "content-type": "application/json"
  },
  body: {
    url: "https://www.myStore.com/checkout"
  }
}
const httpContext2 = {
  headers: {
    "content-type": "application/json"
  },
  body: {
    url: "https://www.myStore.com/checkout"
  }
}

const creditCard = container.resolve('creditCard', httpContext);
const shoppingBag = container.resolve('shoppingBag', httpContext);

const creditCard2 = container.resolve('creditCard', httpContext2);
const shoppingBag2 = container.resolve('shoppingBag', httpContext2);

creditCard.set('John Doe', 'Street 12', '0000-0000-0000', '123');
shoppingBag.addItem({name: 'Apple', price: 1.99});

creditCard2.set('Dan Scott', 'Street 90', '1111-1111-1111', '321');
shoppingBag2.addItem({name: 'Orange', price: 2.99});

container.resolve('transaction', httpContext).transfer();
container.resolve('transaction', httpContext2).transfer();

container.clearContext(httpContext);
container.clearContext(httpContext2);

What is a DI Container?

Emanuel Gustafzon — Fri, 05 Jul 2024 14:54:14 +0000

In the last post in this series we learned about dependency injection.

We saw that we needed to manually create an instance of the database connection class before creating an instance of the post routes class. Then, we passed the connection instance into the constructor of the posts object.

Imagine, though, if we could just create an instance of the post routes class, and the system itself would automatically know that the posts class depends on a database connection and create that instance for us 💡.

There you have it! A Dependency Injection Container is doing just that.

A DI Container is responsible for creating instances of classes and managing their dependencies. Here’s a more detailed breakdown:

Registering Services

First, you register your classes with the container and specify their dependencies. For example, you tell the container that PostRoutes depends on a DatabaseConnection.

Resolving Services

When you ask the container to resolve a service (i.e., create an instance of a class), the container:

Creates an instance of the class.
Resolves all the dependencies that the class needs by creating instances of those dependencies as well.

This means that the container automatically creates and injects instances of all the required dependencies, simplifying the process of creating complex objects with multiple dependencies.

The lifetime of instances.

You need to keep in mind how long an instance live before it gets renewed. We call this scope.

The 3 most common scopes are transient, singleton and request or even called scoped in .NET.

Singleton

The singleton scope means that the DI Container creates one instance of the service and keeps that same instance throughout the program’s lifetime. Every time you resolve the service, you get the same instance. This is useful for services that maintain state or are expensive to create and should be shared across the entire application.

Example: Logging Service

A logging service that logs messages to the console can be a good use case for a singleton service. A logging service keeps the same state and stay consistent throughout the program.

Transient

Transient scope means that the DI Container creates a new instance of the service each time it is resolved. This is useful for lightweight, stateless services where each operation should be independent of others.

Example: Unique ID Generation Service

A service that generates unique IDs might be a good use case for a transient service. Each request to this service should produce a new, unique value without retaining any state from previous requests.

Scoped or Request

Scoped services last as long as the HttpContext lasts. This scope is particularly useful in web applications.

When working in the backend, you receive HTTP requests from clients. Each request has a context, known as the HttpContext, which lasts from when the client sends the request to the backend until the backend sends a response back to the client. During this period, multiple operations might occur, such as connecting to a database, fetching data to authorize the user, retrieving various resources, etc.

Example: Database Connection Service

For a database connection service, you want the same instance to be used throughout the entire HttpContext to avoid losing the connection during the request processing. This ensures that the database connection remains consistent and efficient throughout the lifecycle of the request.

Stay tuned because in the next chapter we will start building our own DI container in JavaScript.

Dependency Injection made simple.

Emanuel Gustafzon — Fri, 05 Jul 2024 11:17:54 +0000

Dependency Injection is an intimitating word. But actually the concept is quite simple.

Dependency Injection is a way of handling objects that are dependent on other objects

We will make an implementation in JavaScript and then in C# with interfaces.

Let’s start with a simple example of an object being dependent of another object.

class DatabaseConnection {
  connect() {
    console.log("Connected to database");
  }
}

class PostsRouter {
  get() {
    const db = new DatabaseConnection();
    db.connect();
    console.log("Posts retrieved");
  }
}
const posts = new PostsRouter;
posts.get();

In the example above the posts router is dependent on the database connection.

BUT there is a problem here. Even though this solution works, it’s not flexible. The code is, as we say tightly coupled.

What if you have two different database connections? One for SQLite and one for MySQL? To change the connection object you need to change the code in the posts route.

That’s when dependency injection comes in.

Dependency injection is basically nothing more than passing an object into the constructor or setter of a class that depends on that object.

Let’s try that!

class SQLiteConnection {
  connect() {
    console.log("Connected to SQlite");
  }
}

class MySqlConnection {
  connect() {
    console.log("Connected to MySQL");
  }
}

class PostsRouter {
  constructor(connection) {
    this.connection = connection;
  }
  get() {
    this.connection.connect();
    console.log("Posts retrieved");
  }
}

const mySql = new MySqlConnection;
const sqlite = new SQLiteConnection;

const mysqlPosts = new PostsRouter(mySql);

const sqlitePosts = new PostsRouter(sqlite);

mysqlPosts.get();
sqlitePosts.get();

You see! This makes the code more flexible. The connection object is decoupled from the posts object. You can pass any object to the constructor.

Benefits

The code is decoupled and easier to manage.
The code is easier to test. You can create a mock object and pass it to the post router.

Interfaces

You might have noticed that our implementation worked fine in JavaScript because we don’t need to think about types.

But many times we work with strongly typed languages like TypeScript, C# and Java.

So the issue is when we send the connection object into the posts object we need to define a type.

That’s why we need interfaces. Interfaces is like classes but there is no implementation of methods or properties it’s just the types.

Let’s implement an interface for the connection objects.

interface IDb {
  public void connect();
}

This is the structure of the connection object. It has a public method called connect and it returns void and has no parameters.

Now the connection classes can inherit from IDb to enforce the same structure.


class SQLiteConnection : IDb {
  public void connect() {
    Console.WriteLine("Connected to SQlite");
  }
}

class MySqlConnection : IDb {
  public void connect() {
    Console.WriteLine("Connected to MySQL");
  }
}

It’s worth noticing, that a class can inherit multiple interfaces in most languages.

Now we can pass the connection objects in the constructor of the posts route object using IDb as the type.


class PostsRouter {
  IDb _connection;

  public PostsRouter(IDb connection) {
    this._connection = connection;
  }
  public void get() {
    this._connection.connect();
    Console.WriteLine("Posts retrieved");
  }
}

I hope this explanation made sense to you!

Here is the full example.


using System;

interface IDb {
  public void connect();
}

class SQLiteConnection : IDb {
  public void connect() {
    Console.WriteLine("Connected to SQlite");
  }
}

class MySqlConnection : IDb {
  public void connect() {
    Console.WriteLine("Connected to MySQL");
  }
}

class PostsRouter {
  IDb _connection;

  public PostsRouter(IDb connection) {
    this._connection = connection;
  }
  public void get() {
    this._connection.connect();
    Console.WriteLine("Posts retrieved");
  }
}

class Program {
  public static void Main (string[] args) {
    IDb sqlConnection = new SQLiteConnection();
    IDb mySqlConnection = new MySqlConnection();

    PostsRouter posts = new PostsRouter(sqlConnection);
    PostsRouter posts2 = new PostsRouter(mySqlConnection);
    posts.get();
    posts2.get();
  }
}

Understand DI Containers: Intro

Emanuel Gustafzon — Fri, 05 Jul 2024 09:59:37 +0000

I’m excited to start this new series and dig deeper into dependency injection!!

We are going to use JavaScript and C# in this series.

After this tutorial we will have a solid understanding of DI Containers and be able to adopt our knowledge when we work with frameworks like .Net, Spring Boot and Nest.JS etc 😎.

What we will learn.

What is Dependency Injection.
What are interfaces.
Create a DI Container from scratch with different life cycles using JavaScript.
Use the DI Container in .NET.

We are going to take it one step at the time, stay tuned!

SQL Course: Challanges

Emanuel Gustafzon — Tue, 02 Jul 2024 10:25:44 +0000

Alright, great job for coming this far. It’s time for some challenges to finalize our social media database.

Challenges overview

Query all posts and order them based on number of likes.
Query a users followers profiles and the posts they have liked.
Add comments to the posts.

Here is the tables we have created so far and the inserted data.

CREATE TABLE Users 
(
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  Username VARCHAR(255) UNIQUE NOT NULL,
  Password VARCHAR(255) NOT NULL,
  CHECK (LENGTH(Password) > 5)
);
-- one to one field user and profile
CREATE TABLE Profiles
(
  UserID INTEGER NOT NULL PRIMARY KEY,
  Img VARCHAR(1),
  Bio TEXT,
  FOREIGN KEY (UserID) REFERENCES Users(ID)
);
-- one to many field user and post
CREATE TABLE Posts
(
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  UserID INTEGER NOT NULL,
  Title VARCHAR(255) NOT NULL,
  Content TEXT NOT NULL,
  FOREIGN KEY (UserID) REFERENCES Users(ID)
);
-- many to many field user likes posts
CREATE TABLE Likes
(
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  PostID INTEGER,
  UserID INTEGER, 
  FOREIGN KEY (PostID) REFERENCES Posts(ID),
  FOREIGN KEY (UserID) REFERENCES Users(ID)
);
-- many to many field user follows users
CREATE TABLE Follows
  (
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  OwnerID INTEGER,
  FollowingID INTEGER,
  FOREIGN KEY (OwnerID) REFERENCES Users(ID),
  FOREIGN KEY (FollowingID) REFERENCES Users(ID)
  );

INSERT INTO Users (Username, Password) VALUES 
  ('Ben', 'secret'),
  ('Jim', 'secret'),
  ('Luk', 'secret');

INSERT INTO Profiles (UserID, Img, BIO) VALUES
  (1, '😎', 'I am a cool guy'), --Ben
  (2, '🥳', 'I love party'), --Jim
  (3, '🤠', 'I am a cowboy'); --Luk

INSERT INTO Posts (UserID, Title, Content) VALUES 
   (1, 'sql', 'sql content'),
   (1, 'java', 'java content'),
   (2, 'NLP', 'NLP Content'),
   (2, 'rust', 'rust content');

INSERT INTO Likes (UserID, PostID) VALUES
  (1, 1), -- Ben likes sql
  (2, 1), -- Jim likes sql
  (3, 1), -- Luk likes sql
  (1, 2), -- Ben likes Java
  (3, 3); -- Luk likes NLP

INSERT INTO Follows (OwnerID, FollowingID) VALUES
  (1, 2), -- ben follow jim
  (2, 1), -- jim folliw ben
  (2, 3), -- jim follow luk
  (3, 1), -- luk follow ben
  (1, 3); -- ben follow luk

Challenge 1

Query all posts and order them after number of likes.
The posts with the most likes should come first.
The tricky part is to include posts that have 0 likes.

Tip: Use a right join.

Expected result:

A table of post title, post content and number of likes.

Challenge 2

In this challenge you will get some starter code.

This code return all user profiles, Jim follows.

SELECT 
followsUser.Username,
followsProfile.Img,
followsProfile.Bio
FROM Follows f 
JOIN Users u ON f.OwnerID = u.ID
JOIN Users followsUser ON f.FollowingID = followsUser.ID
JOIN Profiles followsProfile ON followsProfile.UserID = followsUser.ID
WHERE u.Username = 'Jim';

Your challenge is to add on to this. So that it returns the profile and the posts the followed users have liked.

Expected result:

A table of, username, profile image, profile bio, the user’s post with title and content.

Challenge 3

We want a feature where users can comment on posts.

Each comment is associated with one post and one user.

Share your solutions in comments. Thanks for reading and happy coding!

SQL Course: Self Join

Emanuel Gustafzon — Mon, 01 Jul 2024 21:45:41 +0000

It’s time to add followers to our database application.

We will establish one more many-to-many relationship. Our join table will be the followers table.

The interesting thing with this table is that is the two foreign keys are referencing the same table, the users table. Therefore we need to query the followers with a self join.

Create the join table

The OwnerID is the user who follow another user.
The FollowingID is the user who is being followed.

CREATE TABLE Follows
  (
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  OwnerID INTEGER,
  FollowingID INTEGER,
  FOREIGN KEY (OwnerID) REFERENCES Users(ID),
  FOREIGN KEY (FollowingID) REFERENCES Users(ID)
  );

Insert data

Ex user with ID 1, Ben follow user with ID 2, Jim.

INSERT INTO Follows (OwnerID, FollowingID) VALUES
  (1, 2),
  (2, 1),
  (2, 3);

Query with self join.

In this query we retrieve all users and the users they follow and then group by user.

SELECT 
owner.username, followsUser.Username
FROM Follows f
JOIN Users owner ON f.OwnerID = owner.ID
JOIN Users followsUser ON f.FollowingID = followsUser.ID
GROUP BY owner.username, followsUser.Username;

We can also get all the users a particular user is following.

SELECT 
owner.username, followsUser.Username
FROM Follows f
JOIN Users owner ON f.OwnerID = owner.ID
JOIN Users followsUser ON f.FollowingID = followsUser.ID
WHERE owner.Username = 'Ben';

SQL Course: Many-to-many relationship and Nested Joins.

Emanuel Gustafzon — Mon, 01 Jul 2024 20:24:21 +0000

You have learned about one-to-one and one-to-many relationships and they are quite straight forward. Many-to-Many works a bit different because you need an extra table, so called join table.

In this example we will let users like posts in the database. To achieve this functionality we need to create a many-to-many relationship because a user can like many posts and a post can have many likes.

To establish this relationship we need a join table that holds a reference to the user who likes the post and the post that is being liked.

Create a likes table that function as a join table.

CREATE TABLE Likes
(
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  PostID INTEGER,
  UserID INTEGER, 
  FOREIGN KEY (PostID) REFERENCES Posts(ID),
  FOREIGN KEY (UserID) REFERENCES Users(ID)
);

Insert data to the likes table.

We add the user’s ID and the post’s ID. Ex user 1, Ben likes post 1 about sql.

INSERT INTO Likes (UserID, PostID) VALUES
  (1, 1),
  (2, 1),
  (3, 1), 
  (1, 2),
  (2, 2),
  (3, 3);

Nested Join

To be able to query data from a many-to-many relationship we need nested joins.

Select the fields to retrieve.
Use the join table as starting point, our likes table.
Join the related data, in our case the users and the posts.

SELECT 
u.Username, p.Title, p.Content
FROM Likes l
JOIN Users u ON l.UserID = u.ID
JOIN Posts p ON l.PostID = p.ID;

To make the result more readable let’s group users and the posts they liked together.

SELECT 
u.Username, p.Title, p.Content
FROM Likes l
JOIN Users u ON l.UserID = u.ID
JOIN Posts p ON l.PostID = p.ID
GROUP BY u.ID, p.ID;

Result:

SQL Course: One-to-many Relationships and Left Joins

Emanuel Gustafzon — Mon, 01 Jul 2024 19:05:57 +0000

In the last chapter we learned about one-to-one fields and inner joins. In this chapter we learn about one-to-many relationships and left joins. If you followed the last chapter this should be easy.

We will create a posts table and a post is related to one user and a user can have many posts. That is why it is called a one-to-many relationship.

Prerequisites with links

Left Joins

Create the posts table

We create the post table with its own primary key and a foreign key to the user's table.

By letting the posts table have an independent primary key there is no restriction of multiple posts having the same foreign key.

CREATE TABLE Posts
(
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  UserID INTEGER NOT NULL,
  Title VARCHAR(255) NOT NULL,
  Content TEXT NOT NULL,
  FOREIGN KEY (UserID) REFERENCES Users(ID)
);

Insert data to the posts table

INSERT INTO Posts (UserID, Title, Content) VALUES 
   (1, 'sql', 'sql content'),
   (1, 'java', 'java content'),
   (2, 'NLP', 'NLP content'),
   (2, 'rust', 'rust content');

Query with a left join.

We will make a query where we get all the users and if the user has a post we retrieve that post.

SELECT u.Username, p.Title, p.Content
FROM Users u
LEFT JOIN Posts p ON u.ID = p.UserID;

SQL Course: One-to-one Relationships and Inner Joins.

Emanuel Gustafzon — Mon, 01 Jul 2024 17:28:37 +0000

In this chapter, we will set up a user and a profile table and create a one-to-one relationship between them.

A user can create a user with a username and password and then create a profile with a profile image and bio. A user can only have one profile and a profile can only be related to one user. That is why it is called a one-to-one relationship.

If you use Replit, create the template for SQLite and you are good to go.

Prerequisites with links

Press the links to read more about the topic;

Create the tables.

Leave out the primary and foreign keys in the profile table for now. We use the constraint CHECK to make sure the password has a length of more than 5 characters.

CREATE TABLE Users 
(
  ID INTEGER PRIMARY KEY AUTOINCREMENT,
  Username VARCHAR(255) UNIQUE NOT NULL,
  Password VARCHAR(255) NOT NULL,
  CHECK (LENGTH(Password) > 5)
);

CREATE TABLE Profiles 
(
  Img VARCHAR(1),
  Bio TEXT
);

Establish the one-to-one relationship.

To make sure a user only can create one profile, we can use the user’s primary key as the profile’s primary and foreign key. This way the profile is dependent on the user.

CREATE TABLE Profiles
(
  UserID INTEGER NOT NULL PRIMARY KEY,
  Img VARCHAR(1),
  Bio TEXT,
  FOREIGN KEY (UserID) REFERENCES Users(ID)
);

Insert data to the user and profile.

INSERT INTO Users (Username, Password) VALUES 
  ('Ben', 'secret'),
  ('Jim', 'secret'),
  ('Luk', 'secret');

INSERT INTO Profiles (UserID, Img, BIO) VALUES
  (1, '😎', 'I am a cool guy'),
  (2, '🥳', 'I love party'),
  (3, '🤠', 'I am a cowboy');

Query user and profile information using inner join.

We use Aliases to give the temporary names u for Users and p for Profiles.
Use SELECT to choose what fields you want selected from the database.
Join the Profiles with the Users where the ID's match.

SELECT u.Username, p.Img, p.Bio
FROM Profiles p
JOIN Users u ON p.UserID = u.ID;

Result:
Ben|😎|I am a cool guy
Jim|🥳|I love party
Luk|🤠|I am a cowboy

SQL Course: Get Started.

Emanuel Gustafzon — Mon, 01 Jul 2024 13:27:30 +0000

Learn SQL in a funny way by building a social media database. The database will contain users, profiles, posts with likes and users will also be able to follow each other.

I will reference to w3schools.com during this series so you can learn a bit more about the theory and this series will teach you how to put it into practice.

Setup

I am using SQLite for this course. If you use another database it’s fine but maybe the syntax will be slightly different. But w3schools gives examples of different syntax.

I am also using Replit for this tutorial as IDE. You can easily create an account and create a new Repl with the SQLite template. That makes it easy to set up and you can also code in your browser or on your phone or IPad so you can take this tutorial on the go.

https://replit.com/

What we will learn

Creating Tables with primary and foreign keys.
One to one relationships.
One to many relationships.
Many to many relationships.
Query data.
Inner joins, left joins and self joins and nested joins.

C# pass delegate methods as arguments.

Emanuel Gustafzon — Thu, 27 Jun 2024 09:55:02 +0000

With delegates you can pass methods as argument a to other methods.

The delegate object holds references to other methods and that reference can be passed as arguments.

This is a key functionality when working within the functional programming paradigm.

We can create callbacks by utilizing this technique.

A function that receives one more multiple functions as argument or/and returns a function is called higher order functions.

Below is an example of a Map function that receives a int array and a callback function. You can then customize the callback to modify each element in the array. The Map method returns a new array with each item modified.

class Program {
    // define Callback delegate obj
    public delegate int Callback(int valueToModify);

    // Map function that takes a cb to modify each item in array and returns a new modified array
    public static int[] Map(int[] arr, Callback callback) {
    int[] newArr = new int[arr.Length];
    for (int i = 0; i < arr.Length; i++) {
        newArr[i] = callback(arr[i]);
        }

    return newArr;
    }

    public static void Main (string[] args) {
      // Create custom callback
      Callback squareNumbers = x => x * x;
      int[] arr = {1, 2, 3, 4, 5};

      // pass the custom cb as arg
      int[] squaredArr = Map(arr, squareNumbers);

      foreach (int num in squaredArr)       {
          Console.WriteLine(num);
      }
    }
}

You can now play around with this a feel free to define your callback with a lambda function as we learned in the last chapter.

Happy Coding!