https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

In the C Language, dependency injection (DI) is a design pattern that promotes loose coupling between components by injecting dependencies (such as services, objects, or resources) into a function or module, rather than hardwiring these dependencies directly within the code. This approach contrasts with hardwiring, where resources and dependencies are created or managed directly inside a function or module, leading to tightly coupled code that is harder to test, extend, and maintain. By preferring dependency injection over hardwiring resources, you can achieve more modular, testable, and maintainable code.

Preferring dependency injection over hardwiring resources offers several key advantages: 1. **Improved Testability**: DI allows you to easily replace real implementations with mocks or stubs during testing, making unit tests more isolated and reliable. 2. **Loose Coupling**: DI decouples functions and modules from their dependencies, allowing them to evolve independently. This results in a more flexible and maintainable codebase. 3. **Simplified Configuration Management**: DI patterns allow centralized management of dependencies, reducing complexity and making configuration changes easier. 4. **Better Separation of Concerns**: By separating the creation of dependencies from their usage, you adhere to the single responsibility principle, leading to more focused and maintainable code.

1. Hardwiring Example

```c

1. include <stdio.h>
2. include <stdlib.h>

typedef struct {

   // Database connection details
   const char* connection_string;

void save_user(DatabaseConnection* db, const char* user) {

   printf("Saving user %s to database %s\n", user, db->connection_string);

void add_user(const char* user) {

   // Hardwiring the dependency
   DatabaseConnection db = { "localhost:5432/mydb" };
   save_user(&db, user);

int main() {

   add_user("John Doe");
   return 0;

In this example, the `add_user` function is responsible for creating its `DatabaseConnection` dependency. This tight coupling makes the function harder to test, extend, and maintain.

1. Dependency Injection Example

```c

1. include <stdio.h>
2. include <stdlib.h>

typedef struct {

   // Database connection details
   const char* connection_string;

void save_user(DatabaseConnection* db, const char* user) {

   printf("Saving user %s to database %s\n", user, db->connection_string);

// Injecting the dependency via parameter void add_user(DatabaseConnection* db, const char* user) {

   save_user(db, user);

int main() {

   DatabaseConnection db = { "localhost:5432/mydb" };
   add_user(&db, "John Doe");
   return 0;

Here, the `add_user` function receives its `DatabaseConnection` dependency as a parameter. This loose coupling allows for greater flexibility and makes the function easier to test and modify.

In C Language, function pointers can be used to inject different behaviors or implementations depending on the context.

1. Dependency Injection with Function Pointers

```c

1. include <stdio.h>
2. include <stdlib.h>

typedef struct {

   const char* connection_string;
   void (*save)(const char* user);

void mysql_save(const char* user) {

   printf("Saving user %s to MySQL database\n", user);

void postgres_save(const char* user) {

   printf("Saving user %s to PostgreSQL database\n", user);

void add_user(DatabaseConnection* db, const char* user) {

   db->save(user);

int main() {

   DatabaseConnection mysql_db = { "localhost:3306/mydb", mysql_save };
   DatabaseConnection postgres_db = { "localhost:5432/mydb", postgres_save };

   add_user(&mysql_db, "John Doe");
   add_user(&postgres_db, "Jane Smith");

   return 0;

In this example, the `DatabaseConnection` struct includes a function pointer that allows different save implementations to be injected. This makes the `add_user` function more flexible and easier to adapt to different contexts.

Dependency injection in C Language can be implemented in different ways, with constructor injection and setter injection being common methods.

1. Constructor Injection (Preferred)

```c

1. include <stdio.h>
2. include <stdlib.h>

typedef struct {

   const char* connection_string;
   void (*save)(const char* user);

typedef struct {

   DatabaseConnection* db;

UserService* user_service_new(DatabaseConnection* db) {

   UserService* service = malloc(sizeof(UserService));
   service->db = db;
   return service;

void user_service_add_user(UserService* service, const char* user) {

   service->db->save(user);

int main() {

   DatabaseConnection mysql_db = { "localhost:3306/mydb", mysql_save };
   UserService* service = user_service_new(&mysql_db);
   user_service_add_user(service, "John Doe");
   free(service);
   return 0;

1. Setter Injection

```c

1. include <stdio.h>
2. include <stdlib.h>

typedef struct {

   const char* connection_string;
   void (*save)(const char* user);

typedef struct {

   DatabaseConnection* db;

void user_service_set_db(UserService* service, DatabaseConnection* db) {

   service->db = db;

void user_service_add_user(UserService* service, const char* user) {

   service->db->save(user);

int main() {

   DatabaseConnection postgres_db = { "localhost:5432/mydb", postgres_save };
   UserService service;
   user_service_set_db(&service, &postgres_db);
   user_service_add_user(&service, "Jane Smith");
   return 0;

Constructor injection is generally preferred over setter injection because it makes dependencies explicit and ensures that the module is never in an invalid state. Constructor injection also promotes immutability, as the dependencies are typically set only once.

One of the main benefits of dependency injection is the ability to test functions and modules more effectively by injecting mock or stub dependencies.

1. Testing a Function with Mock Dependencies

```c

1. include <stdio.h>
2. include <stdlib.h>
3. include <string.h>
4. include <assert.h>

typedef struct {

   const char* connection_string;
   void (*save)(const char* user);

typedef struct {

   const char* saved_user;

void mock_save(const char* user) {

   static MockDatabaseConnection mock_db;
   mock_db.saved_user = user;
   printf("Mock save: %s\n", user);

void test_add_user() {

   DatabaseConnection mock_db = { "mock", mock_save };
   MockDatabaseConnection mock;
   add_user(&mock_db, "Test User");

   assert(strcmp(mock.saved_user, "Test User") == 0);

int main() {

   test_add_user();
   printf("All tests passed.\n");
   return 0;

In this example, a mock `DatabaseConnection` is injected into the `add_user` function for testing purposes. This allows you to test the function without relying on a real database connection, making your tests faster and more reliable.

Dependency injection is particularly useful in the following scenarios: - **Complex Applications**: In large or complex applications, DI helps manage the interdependencies between functions and modules more effectively. - **Test-Driven Development (TDD)**: If you follow TDD practices, DI makes it easier to create testable functions and modules by allowing dependencies to be injected as mocks or stubs. - **Systems Programming**: When building systems-level applications, DI helps manage configuration and external resources like databases or external services. - **Embedded Systems**: In embedded systems, where resource management is critical, DI allows for more flexible and maintainable code.

In C Language, preferring dependency injection over hardwiring resources is a best practice that leads to more maintainable, testable, and flexible code. By injecting dependencies, you decouple your functions and modules from their dependencies, making it easier to manage and extend your application. This approach aligns well with modern C development practices, especially when using function pointers or structs to define dependencies and create flexible, testable components.

For more information on dependency injection in C Language, consider exploring the following resources:

• https://embeddedartistry.com/blog/2018/04/17/strategies-for-managing-dependencies-in-c/
• https://isocpp.org/wiki/faq/dependency-injection
• https://github.com/rust-unofficial/patterns/blob/main/patterns/di.md

These resources provide additional insights and best practices for using dependency injection effectively in C Language.