autofac/Autofac

Features

• Dependency Injection - Decouples application components by automatically supplying required services through constructors or properties.
• Reflection-Based Dependency Resolution - Uses runtime type inspection to automatically identify and inject required services into constructor parameters.
• Type-Level Service Maps - Implements a type-safe mapping from service interfaces to their concrete implementations for on-demand retrieval.
• Assembly Scanning and Discovery - Provides a system to discover and register classes based on specific criteria within compiled assemblies.
• Assembly Scanning Libraries - Includes a library to automatically discover and register components within compiled .NET assemblies.
• Assembly Scanning Registrations - Automatically discovers and maps types for injection by searching compiled binaries for specific attributes or interfaces.
• Automated Component Discovery - Automatically discovers and registers classes within compiled assemblies by scanning for specific attributes or interfaces.
• Automatic Dependency Resolution - Automatically instantiates requested services and injects all nested dependencies into constructors.
• Container Module Registrations - Organizes sets of registrations into reusable modules to simplify configuration and implement dynamic logic.
• Component Registration - Provides a configuration system to map interfaces to concrete implementations using reflection and lambda expressions.
• Concrete Type Mappings - Provides a method to map concrete classes to services to automatically handle dependency injection.
• Constructor Injection - Supplies required services to classes via constructors or properties to decouple implementation from consumption.
• Lambda-Based Instantiation - Allows custom object creation logic through lambda expressions that can access the current resolution context.
• Dependency Injection Frameworks - Implements a comprehensive framework for inversion of control to manage component dependencies.
• Factory-Based Instantiation - Defines custom instantiation logic through delegates to resolve dependencies using the component context.
• .NET IoC Containers - Functions as a centralized .NET container for managing object instantiation and dependency lifetimes.
• Dependency Tree Traversers - Resolves nested dependencies by repeatedly requesting required types until the entire object graph is instantiated.
• Container Module Registrations - Encapsulates sets of service mappings into reusable modules to organize configuration and share dependency definitions.
• Service Lifetime Scopes - Isolates object instances within logical boundaries to control when components are created and automatically disposed.
• Isolated Resolution Scopes - Provides isolated scopes for resolving services to ensure that scoped instances are properly disposed.
• Conditional Service Resolution - Allows retrieving services only if they exist, providing a safe way to handle optional registrations.
• Serverless Job Activators - Implements a system for injecting dependencies into serverless function executions using a dedicated job activator.
• External Instance Registrations - Allows adding pre-created objects to the container and marking them as externally owned to prevent automatic disposal.
• Application Bootstrapping - Provides mechanisms to initialize the root module and primary service providers during application startup.
• Application Hosting Bootstrappers - Provides mechanisms to initialize service providers within application hosting pipelines to manage root and child dependency scopes.
• Conditional Registrations - Triggers component registration based on whether specific services already exist within the container builder.
• Generic Type Resolution - Dynamically creates concrete implementations of generic services by mapping open type definitions at runtime.
• Open Generic Registrations - Provides the ability to map open generic implementations to services, allowing the dynamic creation of closed generic types at runtime.
• Serverless Injection - Supports injecting dependencies into serverless function executions through a dedicated job activator.
• Scoped Object Disposals - Ensures instances are properly disposed of when their associated isolated resolution scope ends.
• Request-Scoped Configurations - Implements memory control by defining object scopes as singletons or per-request instances.
• Dependency-Mocked Unit Testers - Enables testing classes in isolation by allowing the container to generate mock implementations for dependencies.
• Web Framework Integrations - Connects dependency injection to web frameworks to manage the lifetimes of controllers and middleware.
• Dependency Injection - Extensible and popular dependency injection container.

Star history