Dependency Injection with Lifetimes

In this lesson, you will learn how to inject temporary service dependencies into components while ensuring those dependencies never outlive their provided scope.

Why Inject with Lifetimes?

In many architectures, a component (like a DataProcessor) needs access to a service (like a Logger or DatabaseConnection) to perform its work. If the service is managed by a parent context—such as a request-scoped buffer or a temporary connection pool—the component must prove that it won’t store that reference longer than the service exists. By using lifetimes, we can "inject" these dependencies as shared references (&'a Service) to guarantee memory safety without needing heavy heap allocations or reference counting.

The Lifetime-Bound Injector

Consider a scenario where a ReportGenerator requires a Database connection. We don't want the generator to own the database; we want to inject it temporarily.

struct Database {
    connection_string: String,
}

struct ReportGenerator<'a> {
    db: &'a Database, // The dependency is injected via reference
}

impl<'a> ReportGenerator<'a> {
    fn run(&self) {
        println!("Running report using {}", self.db.connection_string);
    }
}

fn main() {
    let db = Database { connection_string: "postgres://localhost".to_string() };
    
    // Inject the dependency for a limited lifespan
    let generator = ReportGenerator { db: &db };
    
    generator.run();
} // 'db' is dropped here; the compiler ensures 'generator' cannot exist longer.

Why this matters

By annotating the ReportGenerator with <'a>, we force the compiler to verify that the Database instance will live at least as long as the generator. If you tried to create a generator inside a block where the db goes out of scope, the code would fail to compile. This is much more efficient than Rc<Database> or Box<Database> because it incurs zero runtime overhead—all the "dependency management" happens during the compilation check.

This approach is highly effective when you are passing context through your application, ensuring that services remain available while preventing dangling pointers or premature destruction.

Key Takeaway: Injecting dependencies as shared references with explicit lifetimes allows you to provide components with temporary access to services while ensuring absolute compile-time memory safety without performance-draining wrappers.