Struct InstanceGenericFirstDependencyResolver 

pub struct InstanceGenericFirstDependencyResolver { /* private fields */ }

A resolver whose registrations belong to the instance, kept per service type and contract (InstanceGenericFirstDependencyResolver). It is the resolver AppLocator starts with.

A registration runs the callbacks of its service type and contract; disposing the resolver drops its registrations, disposes the constants and the created lazy singletons that were registered as disposable, and runs every callback once more.

Implementations

impl InstanceGenericFirstDependencyResolver

pub fn new() -> Self

An empty resolver.

pub fn with_configuration( configure: impl FnOnce(&dyn IMutableDependencyResolver), ) -> Self

A resolver that configure registers services with first (InstanceGenericFirstDependencyResolver(Action<IMutableDependencyResolver>?)).

Trait Implementations

impl Default for InstanceGenericFirstDependencyResolver

fn default() -> Self

Returns the “default value” for a type.

impl IDisposable for InstanceGenericFirstDependencyResolver

fn dispose(&self)

impl IMutableDependencyResolver for InstanceGenericFirstDependencyResolver

fn has_registration_erased( &self, service_type: ServiceType, contract: Option<&str>, ) -> bool

Whether a service is registered for service_type and contract (HasRegistration<T>).

fn register_erased( &self, factory: ServiceFactory, service_type: ServiceType, contract: Option<&str>, )

Registers a factory, called for each resolution (Register<T>(Func<T?>, string?)).

fn register_constant_erased( &self, value: Option<ErasedService>, disposal: Option<Rc<dyn Fn()>>, service_type: ServiceType, contract: Option<&str>, )

Registers a constant (RegisterConstant<T>(T?, string?)). disposal is what disposing the resolver does with it: upstream disposes a constant that is IDisposable.

fn register_lazy_singleton_erased( &self, factory: ServiceFactory, disposal: Option<LazyDisposal>, service_type: ServiceType, contract: Option<&str>, )

Registers a singleton created by factory on its first resolution (RegisterLazySingleton<T>(Func<T?>, string?)). disposal is what disposing the resolver does with the value once it was created.

fn unregister_current_erased( &self, service_type: ServiceType, contract: Option<&str>, )

Removes the last registration (UnregisterCurrent<T>(string?)).

fn unregister_all_erased( &self, service_type: ServiceType, contract: Option<&str>, )

Removes every registration (UnregisterAll<T>(string?)).

fn service_registration_callback_erased( &self, service_type: ServiceType, contract: Option<&str>, callback: RegistrationCallback, ) -> Rc<dyn IDisposable>

Calls callback for every registration, those that exist and those to come, until the returned disposable is disposed (ServiceRegistrationCallback<T>(string?, Action<IDisposable>)).

impl IReadonlyDependencyResolver for InstanceGenericFirstDependencyResolver

fn get_service_erased( &self, service_type: ServiceType, contract: Option<&str>, ) -> Option<ErasedService>

The last service registered for service_type and contract, or None (GetService<T>(string? contract)).

fn get_services_erased( &self, service_type: ServiceType, contract: Option<&str>, ) -> Vec<ErasedService>

Every service registered for service_type and contract, in the order of registration (GetServices<T>(string? contract)).