UseDependency

UseDependency is a hook that allows to manage a dependency.

Syntax

UseDependency : Default constructor to get the T dependency. It’s similar to using Rt.find .
```
UseDependency<T>({
  String? id,
  String? debugLabel
});
```
UseDependency.get : Get a T dependency inmediately. It’s similar to using Rt.get .
```
UseDependency<T>.get({
  String? id,
  String? debugLabel
});
```

UseDependency.register : Register a builder function to create a T dependency. It’s similar to using Rt.register .

UseDependency<T>.register(
  T builder(), {
    String? id,
    DependencyMode mode = DependencyMode.builder,
    String? debugLabel,
  },
);

UseDependency.create : Registers, creates and gets a T dependency inmediately. It’s similar to using Rt.create .

UseDependency<T>.create(
  T builder(), {
    String? id,
    DependencyMode mode = DependencyMode.builder,
    String? debugLabel,
  },
);

UseDependency.lazyBuilder : Registers a builder function, to create a instance of the T dependency as Builder mode. It’s similar to using Rt.lazyBuilder .
```
UseDependency<T>.lazyBuilder(
  T builder(), {
    String? id,
    String? debugLabel
  },
);
```
UseDependency.lazyFactory : Registers a builder function, to create a instance of the T dependency as Factory mode. It’s similar to using Rt.lazyFactory .
```
UseDependency<T>.lazyFactory(
  T builder(), {
    String? id,
    String? debugLabel
  },
);
```
UseDependency.lazySingleton : Registers a builder function, to create a instance of the T dependency as Singleton mode. It’s similar to using Rt.lazySingleton .
```
UseDependency<T>.lazySingleton(
  T builder(), {
    String? id,
    String? debugLabel
  },
);
```

UseDependency.builder : Registers, creates and gets a T dependency inmediately as Builder mode. It’s similar to using Rt.builder .

UseDependency<T>.builder(
  T builder(), {
    String? id,
    DependencyMode mode = DependencyMode.builder,
    String? debugLabel,
  },
);

UseDependency.factory : Registers, creates and gets a T dependency inmediately as Factory mode. It’s similar to using Rt.factory .

UseDependency<T>.factory(
  T builder(), {
    String? id,
    DependencyMode mode = DependencyMode.builder,
    String? debugLabel,
  },
);

UseDependency.singleton : Registers, creates and gets a T dependency inmediately as Singleton mode. It’s similar to using Rt.singleton .

UseDependency<T>.singleton(
  T builder(), {
    String? id,
    DependencyMode mode = DependencyMode.builder,
    String? debugLabel,
  },
);

Parameters

id: (optional) A String used to identify the dependency of type T .
builder: A function that returns an instance of the dependency of type T .
mode: (optional) A DependencyMode that defines the dependency mode. Defaults to DependencyMode.builder. Learn more in DependencyMode.
debugLabel: (optional) A String used to identify the hook in the DevTools extension.

Properties and methods

instance: A getter property to get the dependency instance of T type.

Properties and methods inherited from RtState

debugLabel: A string that represents the label of the state object for debugging purposes.
debugInfo: A map that contains debug information about the state object.

update : Executes a callback function and notify its observers that the state has changed. When it is invoked, it emits two lifecycle events to signal the state transition:
- Lifecycle.willUpdate is emitted first, indicating the impending update.
- Lifecycle.didUpdate is emitted once the update process is complete.
notify : Forces the state to notify its observers. Unlike update , it emits only the Lifecycle.didUpdate event, as it doesn’t involve any preparatory steps before the notification.
bind : Establishes a connection between the state and a specific instance. This connection allows the instance to reactively update based on changes to the state. By binding the state, the instance becomes aware of changes to the state and can appropriately reflect those changes in its behavior.
unbind : Releases the connection between the state and the instance. When unbinding, the instance will no longer receive updates from the state. This can be useful when an instance is no longer actively using the state or when it needs to detach from the state temporarily or permanently.
dispose : Is responsible for cleaning up the state and any associated observers or resources. Disposing of the state ensures that it is properly released and no longer consumes memory or processing resources unnecessarily.

Usage

Finding a dependency

Use the default constructor to obtain the dependency of T type, e.g.:


3 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>();
5 collapsed lines
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
8
  }
9
}

If the dependency is not registered and created, the instance property will be null .

To avoid this, you can use the UseEffect hook to get the dependency when it is created, e.g.:

1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>();
5

6
  const MyController() {
7
    UseEffect.runOnInit(() {
8
      print(
9
        uDependency.instance != null
10
        ? "MyDependency is available"
11
        : "MyDependency is not available yet."
12
      );
13
    }, [uDependency]);
14
  }
15
}

Identifying a dependency

Use the id parameter to identify the dependency. For example, to obtain a dependency by uniqueId :


3 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>("uniqueId");
5 collapsed lines
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
8
  }
9
}

The id parameter is ideal for identifying dependencies, when you need to use the same dependency type in different places, e.g.:

my_controller.dart
my_app.dart

1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.get();
5
  final uDependency2 = UseDependency<MyDependency>.get("uniqueId");
6

7
  const MyController() {
8
    print("Dependency instance: ${uDependency.instance}");
9
    print("Dependency instance with uniqueId: ${uDependency2.instance}");
10
  }
11
}

1
import 'package:flutter_reactter/flutter_reactter.dart';
2

3
class MyApp extends StatelessWidget {
4
  @override
5
  Widget build(BuildContext context) {
6
    return MaterialApp(
7
      home: RtMultiProvider(
8
        [
9
          RtProvider(() => MyDependency()),
10
          RtProvider(() => MyDependency(), id: "uniqueId"),
11
          RtProvider(() => MyController()),
12
        ],
13
        build: (_, __) => MyHomePage(),
14
      ),
15
    ),
16
  }
17
}

Using the dependency

Use the instance property to access the dependency.


6 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>();
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
2 collapsed lines
8
  }
9
}

If the dependency is not registered and created, the instance property will be null .

To avoid this, you can use the UseEffect hook to get the dependency when it is created, e.g.:

1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>();
5

6
  const MyController() {
7
    UseEffect.runOnInit(() {
8
      print(
9
        uDependency.instance != null
10
        ? "MyDependency is available"
11
        : "MyDependency is not available yet."
12
      );
13
    }, [uDependency]);
14
  }
15
}

Getting a dependency

Ue the UseDependency.get hook to get the dependency instance, e.g.:


3 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.get();
5 collapsed lines
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
8
  }
9
}

The UseDependency.get hook is ideal for accessing a dependency, when you are sure that it is already registered before, e.g.:

my_app.dart
my_controller.dart

1
import 'package:flutter_reactter/flutter_reactter.dart';
2

3
class MyApp extends StatelessWidget {
4
  @override
5
  Widget build(BuildContext context) {
6
    return MaterialApp(
7
      home: RtMultiProvider(
8
        [
9
          RtProvider(() => MyDependency()),
10
          RtProvider(() => MyController()),
11
        ],
12
        build: (_, __) => MyHomePage(),
13
      ),
14
    ),
15
  }
16
}

1
import 'package:flutter_reactter/flutter_reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.get();
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
8
  }
9
}

Registering a dependency

Use the UseDependency.register hook to register a builder function to create the dependency instance, e.g.:


3 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.register(() => MyDependency());
5 collapsed lines
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
8
  }
9
}

In above example, it will print Dependency instance: null , because UseDependency.register hook does not create the dependency instance immediately.

For creating the dependency instance, using the Rt.get method, e.g.:

1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.register(() => MyDependency());
5

6
  const MyController() {
7
    Rt.get<MyDependency>();
8
    print("Dependency instance: ${uDependency.instance}");
9
  }
10
}

Also, you can create the dependency instance inmediately using the UseDependency.create hook instead. Learn more about it in Creating a dependency.

The UseDependency.register hook is ideal for registering dependencies in a single location, e.g.:

dependencies_registers.dart
my_app.dart

1
import 'package:reactter/reactter.dart';
2

3
class DependenciesRegisters {
4
  DependenciesRegisters() {
5
    UseDependency<MyDependency>.register(() => MyDependency());
6
    UseDependency<MyOtherDependency>.register(() => MyOtherDependency(), mode: DependencyMode.singleton);
7
    UseDependency<MyController>.register(() => MyController());
8
  }
9
}

1
import 'package:flutter_reactter/flutter_reactter.dart';
2

3
class MyApp extends StatelessWidget {
4
  @override
5
  Widget build(BuildContext context) {
6
    return MaterialApp(
7
      home: RtProvider(
8
        () => DependenciesRegisters(),
9
        build: (_, __, ___) => MyHomePage(),
10
      ),
11
    ),
12
  }
13
}

Creating a dependency

Use the UseDependency.create hook to create a dependency instance inmediately, e.g.:


3 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.create(() => MyDependency());
5 collapsed lines
5

6
  const MyController() {
7
    print("Dependency instance: ${uDependency.instance}");
8
  }
9
}

Defining the dependency mode

Use the mode parameter to define the dependency mode. For example, to create a singleton dependency:


3 collapsed lines
1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  final uDependency = UseDependency<MyDependency>.create(
5
    () => MyDependency(),
6
    mode: DependencyMode.singleton,
7
  );
5 collapsed lines
8

9
  const MyController() {
10
    print("Dependency instance: ${uDependency.instance}");
11
  }
12
}

The mode parameter is available only in UseDependency.register and UseDependency.create hooks.

If you need to define the dependency mode directly, use the UseDependency.lazyBuilder , UseDependency.lazyFactory , UseDependency.lazySingleton hooks for registering a dependency in its respective mode. Likewise, use the UseDependency.builder , UseDependency.factory and UseDependency.singleton hooks instead, for creating a dependency in its respective mode, e.g.:

my_controller.dart
my_app.dart
my_controller.dart

1
import 'package:reactter/reactter.dart';
2

3
class DependenciesRegisters {
4
  DependenciesRegisters() {
5
    UseDependency<MyDependency>.lazyFactory(() => MyDependency());
6
    UseDependency<MyOtherDependency>.lazySingleton(() => MyOtherDependency());
7
    UseDependency<MyController>.builder(() => MyController());
8
  }
9
}

1
import 'package:flutter_reactter/flutter_reactter.dart';
2

3
class MyApp extends StatelessWidget {
4
  @override
5
  Widget build(BuildContext context) {
6
    return MaterialApp(
7
      home: RtProvider(
8
        () => DependenciesRegisters(),
9
        build: (_, __, ___) => MyHomePage(),
10
      ),
11
    ),
12
  }
13
}

1
import 'package:reactter/reactter.dart';
2

3
class MyController {
4
  /// Get MyDependency as Factory mode.
5
  final uDependency = UseDependency<MyDependency>.get();
6
  /// Get MyOtherDependency as Singleton mode.
7
  final uOtherDependency = UseDependency<MyOtherDependency>.get();
8

9
  const MyController() {
10
    print("Dependency instance using Factory mode: ${uDependency.instance}");
11
    print("Dependency instance using Singleton mode: ${uOtherDependency.instance}");
12
  }
13
}