Crate di

source ·
Expand description

More Dependency Injection   CI Crates.io MIT licensed

More DI is a dependency injection (DI) library for Rust. A trait or struct can be used as the injected type.

You may be looking for:

Features

This crate provides the following features:

  • default - Abstractions for dependency injection, plus the builder and inject features
  • builder - Functions for configuring service descriptors
  • async - Use dependencies in an asynchronous context
  • inject - Code-generate common injection scenarios
  • lazy - Lazy-initialize service resolution
  • fmt - Additional output formatting
  • alias - Use alternate type aliases

Supported Lifetimes

A service can have the following lifetimes:

  • Transient - a new instance is created every time it is requested
  • Singleton - a single, new instance is created the first time it is requested
  • Scoped - a new instance is created once per provider that it is requested from

Dependency Injection in Action

Consider the following traits and structures.

Proc macro attributes are not required, but they are the fastest and simplest approach to add DI in your applications.

use di::*;
use std::rc::Rc;

trait Phrase {
    fn salutation(&self) -> &str;
}

#[injectable(Phrase)]
struct EnglishPhase;

impl Phrase for EnglishPhrase {
    fn salutation(&self) -> &str {
        "Hello world!"
    }
}

#[injectable]
struct Person {
    phase: Rc<dyn Phrase>,
}

impl Person {
    fn speak(&self) -> &str {
        self.phrase.salutation()
    }
}

This information can now be composed into a simple application:

use crate::*;
use di::*;

fn main() {
    let provider = ServiceCollection::new()
        .add(EnglishPhrase::singleton())
        .add(Person::transient())
        .build_provider()
        .unwrap();

    let person = provider.get_required::<Person>();

    println!("{}", person.speak());
}

License

This project is licensed under the MIT license.

Modules

  • Contains support for lazy service resolution.

Structs

Enums

Traits

  • Defines the behavior of an injectable type.

Functions

Type Aliases

  • Represents a holder for a keyed, mutable service.
  • Represents the type alias for a service reference.
  • Represents the type alias for a mutable service reference.
  • Represents the callback function used to create a service.

Attribute Macros

  • injectinject
    Represents the metadata used to identify an injected function.
  • Represents the metadata used to implement the Injectable trait.