InstanceExtension<T> extension

Extension on GetInterface providing a convenient method to find instances of type T.

on

• GetInterface

Methods

call() → T

Calls find<T>() to retrieve an instance of type T.

delete<S>({String? tag, String? key, bool force = false}) → bool

Delete registered Class Instance S (or tag) and, closes any open controllers DisposableInterface, cleans up the memory

deleteAll({bool force = false}) → void

Deletes all registered class instances and closes any open controllers that implement DisposableInterface.

find<S>({String? tag}) → S

Finds the registered type <S> (or tag) In case of using Get.create to register a type <S> or tag, it will create an instance each time you call find. If the registered type <S> (or tag) is a Controller, it will initialize it's lifecycle.

findOrNull<S>({String? tag}) → S?

The findOrNull method will return the instance if it is registered; otherwise, it will return null.

getInstanceInfo<S>({String? tag}) → InstanceInfo

Get instance info

isPrepared<S>({String? tag}) → bool

Checks if a lazy factory callback Get.lazyPut() that returns an Instance<S> is registered in memory.

isRegistered<S>({String? tag}) → bool

Check if a Class Instance<S> (or tag) is registered in memory.

lazyPut<S>(InstanceBuilderCallback<S> builder, {String? tag, bool? fenix, bool permanent = false}) → void

Creates a new Instance lazily from the <S>builder() callback.

lazyReplace<P>(InstanceBuilderCallback<P> builder, {String? tag, bool? fenix}) → void

Replaces a parent instance with a new Instance

markAsDirty<S>({String? tag, String? key}) → void

Mark instance as a dirty

put<S>(S dependency, {String? tag, bool permanent = false}) → S

Injects an instance <S> in memory to be globally accessible.

putAsync<S>(AsyncInstanceBuilderCallback<S> builder, {String? tag, bool permanent = false}) → Future<S>

async version of Get.put(). Awaits for the resolution of the Future from builder() parameter and stores the Instance returned.

putOrFind<S>(InstanceBuilderCallback<S> dep, {String? tag}) → S

Registerd instance and if already exists then it will return

reload<S>({String? tag, String? key, bool force = false}) → void

Reloads the instance of type S.

reloadAll({bool force = false}) → void

Reloads all registered class instances.

replace<P>(P child, {String? tag}) → void

Replace a parent instance of a class in dependency management with a child instance

spawn<S>(InstanceBuilderCallback<S> builder, {String? tag, bool permanent = true}) → void

Creates a new Class Instance S from the builder callbackS. Every time find<S>() is used, it calls the builder method to generate a new Instance S. It also registers each instance.onClose() with the current Route Get.reference to keep the lifecycle active. Is important to know that the instances created are only stored per Route. So, if you call Get.delete<T>() the "instance factory" used in this method (Get.spawn<T>()) will be removed, but NOT the instances already created by it.