Struct ServiceProvider 

pub struct ServiceProvider { /* private fields */ }

Implementations

impl ServiceProvider

pub fn register_disposable(&self, cleanup: Box<dyn FnOnce() + Send>)

Register a cleanup closure for scoped services/owned resources.

Closures run (in reverse registration order) when Self::dispose is called — either explicitly or by Scope’s Drop for scope providers.

pub fn dispose(&self)

Dispose this provider: release cached instances in reverse creation order, run registered cleanups in reverse registration order, and mark the provider unusable.

• Root provider: also marks the whole provider tree disposed (existing scopes can no longer resolve), drains the singleton cache, and clears named registrations. Singleton instances are released in reverse creation order (LIFO), so dependents drop before their dependencies.
• Scope provider: releases the scoped instances created in that scope and runs its cleanups. Singletons are untouched.

Idempotent. Instances are released by dropping the container’s strong references; a service’s Drop runs when no other owner keeps it alive. Services obtained via get_owned are caller-owned and are not tracked.

The caller must not resolve services concurrently with disposal (same contract as MEDI’s ServiceProvider.Dispose). A panicking cleanup closure does not stop the remaining cleanups; the first panic is re-raised after disposal (and swallowed when the thread is already unwinding, e.g. during Scope’s Drop).

pub fn get<T: ?Sized + Send + Sync + 'static>(&self) -> Result<Arc<T>, RdiError>

Resolve a service by type. Works uniformly for concrete types and trait objects. Returns Err(RdiError::ServiceNotFound) if not registered.

ScopeFactory is always available from a built provider (no manual registration required). An explicit singleton::<dyn ScopeFactory>(...) registration still takes precedence. Later registrations override earlier ones (MEDI semantics).

pub fn get_optional<T: ?Sized + Send + Sync + 'static>(&self) -> Option<Arc<T>>

Resolve a service by type, returning None if it is not registered or not resolvable at this point (e.g. a scoped service under root scope validation, or a disposed provider). Use Self::get when you need the concrete error.

pub fn get_async<T: ?Sized + Send + Sync + 'static>( &self, ) -> impl Future<Output = Result<Arc<T>, RdiError>> + Send + '_

Resolve an async service by type.

The returned future captures the current async resolution chain at construction time (synchronously), so nested resolution inherits the chain even when the future is moved to another task. For fully detached task closures, propagate Self::async_context (see its docs).

pub fn get_keyed_async<T: ?Sized + Send + Sync + 'static>( &self, key: impl Into<ServiceKey> + Send, ) -> impl Future<Output = Result<Arc<T>, RdiError>> + Send + '_

Resolve an async keyed service by type and key.

Accepts string keys and typed ServiceKey values. AnyKey fallback registrations are synchronous by design and are resolved through the synchronous keyed path.

pub fn get_keyed<T: ?Sized + Send + Sync + 'static>( &self, key: impl Into<ServiceKey>, ) -> Result<Arc<T>, RdiError>

Resolve a keyed service by type and key. Resolve a keyed service by type and key.

Accepts string keys ("name") as well as typed ServiceKey values. Exact-key registrations take precedence; otherwise an AnyKey fallback registration is used for the requested key. Returns Err(RdiError::KeyedServiceNotFound) if not found.

pub fn get_owned<T: Send + Sync + 'static>(&self) -> Result<T, RdiError>

Resolve owned T (bypass cache, fresh each call). Returns Err if not registered or the service is Singleton.

Owned resolution hands the instance to the caller: it is not tracked by the container and stays valid after dispose. Scoped ownership bypasses the scope cache, so a root scope-validation error is not raised for the owned instance itself; its dependencies still obey scope validation.

pub fn try_get_owned<T: Send + Sync + 'static>(&self) -> Option<T>

Resolve owned T, returning None if not registered, a Singleton, or the provider/scope is disposed.

pub fn get_keyed_owned<T: Send + Sync + 'static>( &self, key: impl Into<ServiceKey>, ) -> Result<T, RdiError>

Resolve owned keyed T. Returns Err if not found or Singleton.

pub fn try_get_keyed_owned<T: Send + Sync + 'static>( &self, key: impl Into<ServiceKey>, ) -> Option<T>

Resolve owned keyed T, returning None if not found, a Singleton, or the provider/scope is disposed.

pub fn get_all<T: ?Sized + Send + Sync + 'static>(&self) -> Vec<Arc<T>>

Return all unkeyed registered instances of the given type, in registration order (MEDI GetServices<T>() / IEnumerable<T> parity).

Keyed implementations are excluded — use Self::get_all_keyed for those. Under root scope validation, scoped services are not resolvable at the root and are omitted; other resolution failures panic with a typed RdiError payload (mirroring MEDI, where enumeration throws).

pub fn get_all_keyed<T: ?Sized + Send + Sync + 'static>(&self) -> Vec<Arc<T>>

Return all keyed registered instances of the given type, in registration order (MEDI GetKeyedServices<T>(KeyedService.AnyKey) parity).

AnyKey fallback registrations are excluded: MEDI’s AnyKey enumeration returns only registrations with an explicit key.

pub fn scope(self: &Arc<Self>) -> Scope

Create a new service scope.

Analogous to IServiceProvider.CreateScope() in MEDI. Scoped-lifetime services are cached within the returned scope.

pub fn is_registered<T: ?Sized + Send + Sync + 'static>(&self) -> bool

Whether T has a resolvable registration (or is a built-in container service). MEDI IServiceProviderIsService parity.

Reports registration state only: it is still true after Self::dispose.

pub fn is_registered_keyed<T: ?Sized + Send + Sync + 'static>( &self, key: impl Into<ServiceKey>, ) -> bool

Whether T has a registration under key (exact key, or an AnyKey fallback registration). MEDI IServiceProviderIsService.IsKeyedService parity.

pub fn get_named<T: Send + Sync + 'static>(&self, name: &str) -> Option<Arc<T>>

Cross-DLL safe named service resolution (generic).

pub fn get_named_any(&self, name: &str) -> Option<Arc<dyn Any + Send + Sync>>

Non-generic named resolution; returns Arc<dyn Any> for trait-object dispatch.

pub fn register_named<T: Send + Sync + 'static>( &self, name: &str, service: Arc<T>, )

Register a named service for cross-DLL plugin access.

No-op after the provider/scope has been disposed (the named registry is cleared by Self::dispose).

pub fn remove_named(&self, name: &str)

Remove a named service (for plugin unload).

pub fn rdi_register_named( &self, name: &str, service: Arc<dyn Any + Send + Sync>, )

Register a named service (for IProvider trait).

No-op after the provider/scope has been disposed.

pub fn rdi_remove_named(&self, name: &str)

Remove a named service (for IProvider trait).

impl ServiceProvider

pub fn async_context(&self) -> Option<AsyncFactoryContext>

Create an AsyncFactoryContext bound to the current async resolution chain.

Call this inside an async factory (before spawning) to get a handle that can be cloned into detached tasks. Outside a factory the context starts a fresh chain. Returns None only for a provider whose self-reference is not initialized (should not happen for a built provider).

Trait Implementations

impl IProvider for ServiceProvider

fn get_named_any(&self, name: &str) -> Option<Arc<dyn Any + Send + Sync>>

fn rdi_register_named(&self, name: &str, service: Arc<dyn Any + Send + Sync>)

fn rdi_remove_named(&self, name: &str)

impl IServiceResolver for ServiceProvider

fn try_get_any_result( &self, key: &str, ) -> Result<Option<Arc<dyn Any + Send + Sync>>, RdiError>

Infallible lookup: reports absence instead of panicking for scope violations / disposal (still returns Err for factory failures so callers could distinguish, but IServiceResolver::try_get maps it to None).

fn try_get_keyed_any_result( &self, key: &str, variant: &str, ) -> Result<Option<Arc<dyn Any + Send + Sync>>, RdiError>

Keyed variant of IServiceResolver::try_get_any_result.

fn get_any(&self, key: &str) -> Option<Arc<dyn Any + Send + Sync>>

fn get_keyed_any( &self, key: &str, variant: &str, ) -> Option<Arc<dyn Any + Send + Sync>>

fn get_keyed_any_key( &self, key: &str, variant: &ServiceKey, ) -> Option<Arc<dyn Any + Send + Sync>>

Typed-keyed resolution by type name (used by #[inject(key = <expr>)]).

fn try_get_keyed_any_result_key( &self, key: &str, variant: &ServiceKey, ) -> Result<Option<Arc<dyn Any + Send + Sync>>, RdiError>

Error-reporting typed-keyed lookup (used by required/optional inject fields). Defaults to Self::get_keyed_any_key.

fn get_keyed_owned_any_key( &self, key: &str, variant: &ServiceKey, ) -> Option<Arc<dyn Any + Send + Sync>>

Typed-keyed owned resolution (bypasses caches; non-singleton only).

fn try_get_keyed_owned_any_key( &self, key: &str, variant: &ServiceKey, ) -> Result<Option<Arc<dyn Any + Send + Sync>>, RdiError>

Error-reporting typed-keyed owned lookup. Defaults to Self::get_keyed_owned_any_key.

fn get_by_type_id(&self, tid: TypeId) -> Option<Arc<dyn Any + Send + Sync>>

TypeId 直查（默认 None，ServiceProvider 等覆盖为 O(1) 直查）。

fn get_keyed_by_type_id( &self, tid: TypeId, key: &str, ) -> Option<Arc<dyn Any + Send + Sync>>

TypeId 直查 keyed 版本（默认 None）。

fn get_all_any(&self, key: &str) -> Vec<Arc<dyn Any + Send + Sync>>

Type-erased polymorphic resolution: return all unkeyed registered instances of the given type, in registration order.

fn get_all_keyed_any(&self, key: &str) -> Vec<Arc<dyn Any + Send + Sync>>

Type-erased polymorphic resolution over keyed registrations only (MEDI GetKeyedServices<T>(KeyedService.AnyKey)).

fn get_all_any_result( &self, key: &str, ) -> Result<Vec<Arc<dyn Any + Send + Sync>>, RdiError>

Error-reporting variant of Self::get_all_any, used by the inject macros for Vec<Arc<T>> fields.

fn get_owned_any(&self, key: &str) -> Option<Arc<dyn Any + Send + Sync>>

Type-erased owned resolution: bypass cache, call factory fresh, return Arc<dyn Any + Send + Sync> (concrete Arc<Arc<T>>).

fn get_keyed_owned_any( &self, key: &str, variant: &str, ) -> Option<Arc<dyn Any + Send + Sync>>

fn provider_arc(&self) -> Option<Arc<ServiceProvider>>

Return an Arc<ServiceProvider> for on-demand service resolution.

fn get<T: ?Sized + Sync + Send + 'static>(&self) -> Result<Arc<T>, RdiError>

where Self: Sized,

Resolve a service by type (concrete or dyn Trait). Returns Err(RdiError::ServiceNotFound) if not registered.

fn try_get<T: ?Sized + Sync + Send + 'static>(&self) -> Option<Arc<T>>

where Self: Sized,

Resolve a service by type, returning None if it is not registered or not resolvable at this point (e.g. a scoped service under root scope validation, or a disposed provider/scope).

fn get_keyed<T: ?Sized + Sync + Send + 'static>( &self, variant: &str, ) -> Result<Arc<T>, RdiError>

where Self: Sized,

Resolve a keyed service by type and key. Returns Err if not found.

fn try_get_keyed<T: ?Sized + Sync + Send + 'static>( &self, variant: &str, ) -> Option<Arc<T>>

where Self: Sized,

Resolve a keyed service by type and key, returning None if not found or not resolvable at this point (e.g. root scope validation, disposed provider/scope). Never panics for framework-level failures.

fn get_all<T: ?Sized + Sync + Send + 'static>(&self) -> Vec<Arc<T>>

where Self: Sized,

Resolve all unkeyed registered instances of T, in registration order.

fn get_owned<T: Send + Sync + 'static>(&self) -> Result<T, RdiError>

where Self: Sized,

Resolve owned T (bypass cache, fresh each call). Returns Err if not registered or the service is Singleton.

fn try_get_owned<T: Send + Sync + 'static>(&self) -> Option<T>

where Self: Sized,

Resolve owned T, returning None if not registered or Singleton.

fn get_keyed_owned<T: Send + Sync + 'static>( &self, variant: &str, ) -> Result<T, RdiError>

where Self: Sized,

Resolve owned keyed T. Returns Err if not found or Singleton.

fn try_get_keyed_owned<T: Send + Sync + 'static>( &self, variant: &str, ) -> Option<T>

where Self: Sized,

Resolve owned keyed T, returning None if not found or Singleton.

impl ScopeFactory for ServiceProvider

fn create_scope(&self) -> Scope

创建一个独立 scope，共享 root 的 store/singleton_cache/named， 独立 scoped 缓存和 disposables。