Dependency Injection Methods

Reactter provides several methods to manage dependencies in a more efficient way. These methods are used to create and manipulate dependencies in a more organized way.

`Reactter.register`

The Reactter.register method is used to register a new dependency in Reactter. It returns true if the dependency is registered successfully, otherwise return false .

Syntax

bool Reactter.register<T>(
  T Function() builder, {
  String? id,
  DependencyMode mode = DependencyMode.builder,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the dependency will be registered with the type of the dependency.
mode: The mode of the dependency. It can be DependencyMode.builder, DependencyMode.factory, or DependencyMode.singleton. The default value is DependencyMode.builder. Learn more about it in DependencyMode.

Example

See the example below to understand how to use the Reactter.register method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency
6
  Reactter.register<CounterController>(() => CounterController());
27 collapsed lines
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10

11
  // Listen to the state changes
12
  Reactter.on(
13
    counterController.count,
14
    Lifecycle.didUpdate,
15
    (_, __) {
16
      print('Count: ${counterController.count.value}');
17
    },
18
  );
19

20
  // Update the state
21
  counterController.increment();
22
  counterController.decrement();
23

24
  // Delete the dependency
25
  Reactter.delete<CounterController>();
26

27
  // Error: "Can't update when it's been disposed", because the dependency instance was deleted
28
  // counterController.increment();
29

30
  // Can't get the dependency instance, because the dependency register was deleted
31
  final counterController2 = Reactter.get<CounterController>();
32
  print("counterController2: $counterController2"); // counterController2: null
33

34
  // Register a dependency by using `id` parameter
35
  Reactter.register(() => CounterController(), id: 'count2');
8 collapsed lines
36

37
  // Get the dependency by using `id` parameter
38
  final counterControllerById = Reactter.get<CounterController>('count2')!;
39
  print("counterControllerById: $counterControllerById");
40

41
  // Delete the dependency by using `id` parameter
42
  Reactter.delete<CounterController>('count2');
43

44
  // Register a dependency by using `mode` parameter as singleton mode
45
  Reactter.register(() => CounterController(), mode: DependencyMode.singleton);
22 collapsed lines
46

47
  // Get the dependency
48
  final counterControllerBySingletonMode = Reactter.get<CounterController>()!;
49
  print("counterControllerBySingletonMode: $counterControllerBySingletonMode");
50

51
  // Delete the dependency
52
  Reactter.delete<CounterController>();
53

54
  // Can get the dependency again, because it's singleton mode
55
  final counterControllerBySingletonMode2 = Reactter.get<CounterController>()!;
56
  print("counterControllerBySingletonMode2: $counterControllerBySingletonMode2");
57

58
  // Use `onlyDependency` parameter to delete the dependency instance only
59
  Reactter.destroy<CounterController>(onlyDependency: true);
60

61
  // Can't get the dependency instance, because the dependency register was destroyed
62
  final counterControllerBySingletonMode3 = Reactter.get<CounterController>();
63
  print("counterControllerBySingletonMode3: $counterControllerBySingletonMode3"); // counterControllerBySingletonMode3: null
64

65
  // If you need to delete the dependency fully, use `Reactter.destroy` method by forcing it, because it's singleton mode
66
  Reactter.destroy<CounterController>();
67
}

`Reactter.lazyBuilder`

The Reactter.lazyBuilder method is used to register a new dependency as DependencyMode.builder in Reactter. It returns true if the dependency is registered successfully, otherwise return false .

This method is similar to the Reactter.register method.

Syntax

bool Reactter.lazyBuilder<T>(
  T Function() builder, {
  String? id,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the dependency will be registered with the type of the dependency.

Example

See the example below to understand how to use the Reactter.lazyBuilder method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency as builder mode.
6
  Reactter.lazyBuilder<CounterController>(() => CounterController());
27 collapsed lines
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10

11
  // Listen to the state changes
12
  Reactter.on(
13
    counterController.count,
14
    Lifecycle.didUpdate,
15
    (_, __) {
16
      print('Count: ${counterController.count.value}');
17
    },
18
  );
19

20
  // Update the state
21
  counterController.increment();
22
  counterController.decrement();
23

24
  // Delete the dependency
25
  Reactter.delete<CounterController>();
26

27
  // Error: "Can't update when it's been disposed", because the dependency instance was deleted
28
  // counterController.increment();
29

30
  // Can't get the dependency instance, because the dependency register was deleted
31
  final counterController2 = Reactter.get<CounterController>();
32
  print("counterController2: $counterController2"); // counterController2: null
33

34
  // Register a dependency by using `id` parameter as builder mode
35
  Reactter.lazyBuilder(() => CounterController(), id: 'count2');
8 collapsed lines
36

37
  // Get the dependency by using `id` parameter
38
  final counterControllerById = Reactter.get<CounterController>('count2')!;
39
  print("counterControllerById: $counterControllerById");
40

41
  // Delete the dependency by using `id` parameter
42
  Reactter.delete<CounterController>('count2');
43
}

`Reactter.lazyFactory`

The Reactter.lazyFactory method is used to register a new dependency as DependencyMode.factory in Reactter. It returns true if the dependency is registered successfully, otherwise return false .

This method is similar to the Reactter.register method but with the DependencyMode.factory mode.

Syntax

bool Reactter.lazyFactory<T>(
  T Function() builder, {
  String? id,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the dependency will be registered with the type of the dependency.

Example

See the example below to understand how to use the Reactter.lazyFactory method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency as factory mode.
6
  Reactter.lazyFactory<CounterController>(() => CounterController());
27 collapsed lines
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10

11
  // Listen to the state changes
12
  Reactter.on(
13
    counterController.count,
14
    Lifecycle.didUpdate,
15
    (_, __) {
16
      print('Count: ${counterController.count.value}');
17
    },
18
  );
19

20
  // Update the state
21
  counterController.increment();
22
  counterController.decrement();
23

24
  // Delete the dependency
25
  Reactter.delete<CounterController>();
26

27
  // Error: "Can't update when it's been disposed", because the dependency instance was deleted
28
  // counterController.increment();
29

30
  // Can get the dependency again, because it's factory mode
31
  final contController2 = Reactter.get<CounterController>();
32
  print("contController2: $contController2");
33

34
  // Register a dependency by using `id` parameter as factory mode
35
  Reactter.lazyFactory(() => CounterController(), id: 'count2');
8 collapsed lines
36

37
  // Get the dependency by using `id` parameter
38
  final counterControllerById = Reactter.get<CounterController>('count2')!;
39
  print("counterControllerById: $counterControllerById");
40

41
  // Delete the dependency by using `id` parameter fully
42
  Reactter.destroy<CounterController>('count2');
43
}

`Reactter.lazySingleton`

The Reactter.lazySingleton method is used to register a new dependency as DependencyMode.singleton in Reactter. It returns true if the dependency is registered successfully, otherwise return false .

This method is similar to the Reactter.register method but with the DependencyMode.singleton mode.

Syntax

bool Reactter.lazySingleton<T>(
  T Function() builder, {
  String? id,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the dependency will be registered with the type of the dependency.

Example

See the example below to understand how to use the Reactter.lazySingleton method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency as singleton mode.
6
  Reactter.lazySingleton<CounterController>(() => CounterController());
27 collapsed lines
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10

11
  // Listen to the state changes
12
  Reactter.on(
13
    counterController.count,
14
    Lifecycle.didUpdate,
15
    (_, __) {
16
      print('Count: ${counterController.count.value}');
17
    },
18
  );
19

20
  // Update the state
21
  counterController.increment();
22
  counterController.decrement();
23

24
  // Can't delete the dependency, because it's singleton mode
25
  Reactter.delete<CounterController>();
26

27
  // Can't update the state, because it's singleton mode
28
  // counterController.increment();
29

30
  // Can get the dependency again, because it's singleton mode
31
  final contController2 = Reactter.get<CounterController>();
32
  print("contController2: $contController2");
33

34
  // Register a dependency by using `id` parameter as singleton mode
35
  Reactter.lazySingleton(() => CounterController(), id: 'count2');
19 collapsed lines
36

37
  // Get the dependency by using `id` parameter
38
  final counterControllerById = Reactter.get<CounterController>('count2')!;
39
  print("counterControllerById: $counterControllerById");
40

41
  // If you need to delete the dependency fully, use `Reactter.destroy` method by forcing it, because it's singleton mode
42
  Reactter.destroy<CounterController>(id: 'count2');
43

44
  // Use `onlyDependency` parameter to delete the dependency instance only
45
  Reactter.destroy<CounterController>(onlyDependency: true);
46

47
  // Can't get the dependency instance, because the dependency register was destroyed
48
  final counterControllerById2 = Reactter.get<CounterController>('count2');
49
  print("counterControllerById2: $counterControllerById2"); // counterControllerById2: null
50

51
  // Can get the dependency again, because its register is skipped from destroying.
52
  final counterController3 = Reactter.get<CounterController>()!;
53
  print("counterController3: $counterController3");
54
}

`Reactter.create`

The Reactter.create method is used to register the dependency(if it is not already registered), create the dependency instance(if it hasn’t been created yet) and then return it.

Syntax

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

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the default instance of the dependency is used.

Example

See the example below to understand how to use the Reactter.create method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Create a dependency
6
  final counterController = Reactter.create<CounterController>(() => CounterController());
7
  print("counterController: $counterController");
24 collapsed lines
8

9
  // Listen to the state changes
10
  Reactter.on(
11
    counterController.count,
12
    Lifecycle.didUpdate,
13
    (_, __) {
14
      print('Count: ${counterController.count.value}');
15
    },
16
  );
17

18
  // Update the state
19
  counterController.increment();
20
  counterController.decrement();
21

22
  // Delete the dependency
23
  Reactter.delete<CounterController>();
24

25
  // Can't update the state, because the dependency register was deleted
26
  // counterController.increment();
27

28
  // Can't get the dependency instance, because the dependency register was deleted
29
  final counterController2 = Reactter.get<CounterController>();
30
  print("counterController2: $counterController2"); // counterController2: null
31

32
  // Create a dependency by using `id` parameter
33
  final counterControllerById = Reactter.create(
34
    () => CounterController(),
35
    id: 'count2',
36
  );
37
  print("counterControllerById: $counterControllerById");
4 collapsed lines
38

39
  // Delete the dependency by using `id` parameter
40
  Reactter.delete<CounterController>('count2');
41

42
  // Create a dependency by using `mode` parameter as singleton mode
43
  final counterControllerBySingletonMode = Reactter.create(
44
    () => CounterController(),
45
    mode: DependencyMode.singleton,
46
  );
47
  print("counterControllerBySingletonMode: $counterControllerBySingletonMode");
8 collapsed lines
48

49
  // Delete the dependency
50
  Reactter.delete<CounterController>();
51

52
  // Can get the dependency again, because it's dependency
53
  final counterControllerBySingletonMode2 = Reactter.get<CounterController>()!;
54
  print("counterControllerBySingletonMode2: $counterControllerBySingletonMode2");
55
}

`Reactter.builder`

The Reactter.create method is used to register the dependency as DependencyMode.builder(if it is not already registered), create the dependency instance(if it hasn’t been created yet) and then return it.

This method is similar to the Reactter.create method.

Syntax

T Reactter.builder<T>(T Function() builder, {
  String? id,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the default instance of the dependency is used.

Example

See the example below to understand how to use the Reactter.builder method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Create a dependency as builder mode.
6
  final counterController = Reactter.builder<CounterController>(() => CounterController());
7
  print("counterController: $counterController");
24 collapsed lines
8

9
  // Listen to the state changes
10
  Reactter.on(
11
    counterController.count,
12
    Lifecycle.didUpdate,
13
    (_, __) {
14
      print('Count: ${counterController.count.value}');
15
    },
16
  );
17

18
  // Update the state
19
  counterController.increment();
20
  counterController.decrement();
21

22
  // Delete the dependency
23
  Reactter.delete<CounterController>();
24

25
  // Can't update the state, because the dependency register was deleted
26
  // counterController.increment();
27

28
  // Can't get the dependency instance, because the dependency register was deleted
29
  final counterController2 = Reactter.get<CounterController>();
30
  print("counterController2: $counterController2"); // counterController2: null
31

32
  // Create a dependency by using `id` parameter as builder mode
33
  final counterControllerById = Reactter.builder(
34
    () => CounterController(),
35
    id: 'count2',
36
  );
37
  print("counterControllerById: $counterControllerById");
4 collapsed lines
38

39
  // Delete the dependency by using `id` parameter
40
  Reactter.delete<CounterController>('count2');
41
}

`Reactter.factory`

The Reactter.factory method is used to register the dependency as DependencyMode.factory(if it is not already registered), create the dependency instance(if it hasn’t been created yet) and then return it.

This method is similar to the Reactter.create method but with the DependencyMode.factory mode.

Syntax

T Reactter.factory<T>(T Function() builder, {
  String? id,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the default instance of the dependency is used.

Example

See the example below to understand how to use the Reactter.factory method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Create a dependency as factory mode.
6
  final counterController = Reactter.factory<CounterController>(() => CounterController());
7
  print("counterController: $counterController");
21 collapsed lines
8

9
  // Listen to the state changes
10
  Reactter.on(
11
    counterController.count,
12
    Lifecycle.didUpdate,
13
    (_, __) {
14
      print('Count: ${counterController.count.value}');
15
    },
16
  );
17

18
  // Update the state
19
  counterController.increment();
20
  counterController.decrement();
21

22
  // Delete the dependency
23
  Reactter.delete<CounterController>();
24

25
  // Can get the dependency again, because it's factory mode
26
  final contController2 = Reactter.get<CounterController>();
27
  print("contController2: $contController2");
28

29
  // Create a dependency by using `id` parameter as factory mode
30
  final counterControllerById = Reactter.factory(
31
    () => CounterController(),
32
    id: 'count2',
33
  );
34
  print("counterControllerById: $counterControllerById");
4 collapsed lines
35

36
  // Delete the dependency by using `id` parameter fully
37
  Reactter.destroy<CounterController>('count2');
38
}

`Reactter.singleton`

The Reactter.singleton method is used to register the dependency as DependencyMode.singleton(if it is not already registered), create the dependency instance(if it hasn’t been created yet) and then return it.

This method is similar to the Reactter.create method but with the DependencyMode.singleton mode.

Syntax

T Reactter.singleton<T>(T Function() builder, {
  String? id,
});

Parameters

builder : A function that returns an instance of the T dependency.
id: An optional identifier for the T dependency. If not provided, the default instance of the dependency is used.

Example

See the example below to understand how to use the Reactter.singleton method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Create a dependency as singleton mode.
6
  final counterController = Reactter.singleton<CounterController>(() => CounterController());
7
  print("counterController: $counterController");
24 collapsed lines
8

9
  // Listen to the state changes
10
  Reactter.on(
11
    counterController.count,
12
    Lifecycle.didUpdate,
13
    (_, __) {
14
      print('Count: ${counterController.count.value}');
15
    },
16
  );
17

18
  // Update the state
19
  counterController.increment();
20
  counterController.decrement();
21

22
  // Can't delete the dependency, because it's singleton mode
23
  Reactter.delete<CounterController>();
24

25
  // Can update the state, because it's singleton mode
26
  counterController.increment();
27

28
  // Can get the dependency again, because it's singleton mode
29
  final contController2 = Reactter.get<CounterController>();
30
  print("contController2: $contController2");
31

32
  // Create a dependency by using `id` parameter as singleton mode
33
  final counterControllerById = Reactter.singleton(
34
    () => CounterController(),
35
    id: 'count2',
36
  );
37
  print("counterControllerById: $counterControllerById");
21 collapsed lines
38

39
  // Delete the dependency by using `id` parameter
40
  Reactter.delete<CounterController>('count2');
41

42
  // Can get the dependency again, because it's singleton mode
43
  final counterControllerById2 = Reactter.get<CounterController>('count2')!;
44

45
  // If you need to delete the dependency fully, use `Reactter.destroy` method by forcing it, because it's singleton mode
46
  Reactter.destroy<CounterController>(id: 'count2');
47

48
  // Use `onlyDependency` parameter to delete the dependency instance only
49
  Reactter.destroy<CounterController>(onlyDependency: true);
50

51
  // Can't get the dependency instance, because the dependency register was destroyed
52
  final counterControllerById3 = Reactter.get<CounterController>('count2');
53
  print("counterControllerById3: $counterControllerById3"); // counterControllerById3: null
54

55
  // Can get the dependency again, because its register is skipped from destroying.
56
  final counterController3 = Reactter.get<CounterController>()!;
57
  print("counterController3: $counterController3");
58
}

`Reactter.get`

The Reactter.get method is used to get the dependency instance from the Reactter. If the dependency is not registered, it will return null .

Syntax

T? Reactter.get<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, If not provided, the method will attempt to retrieve the dependency instance using the default identifier.

Example

See the example below to understand how to use the Reactter.get method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency
6
  Reactter.register<CounterController>(() => CounterController());
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10
  print("counterController: $counterController");
20 collapsed lines
11

12
  // Listen to the state changes
13
  Reactter.on(
14
    counterController.count,
15
    Lifecycle.didUpdate,
16
    (_, __) {
17
      print('Count: ${counterController.count.value}');
18
    },
19
  );
20

21
  // Update the state
22
  counterController.increment();
23
  counterController.decrement();
24

25
  // Can't delete the dependency, because it's singleton mode
26
  Reactter.delete<CounterController>();
27

28
  // Can't update the state, because it's singleton mode
29
  // counterController.increment();
30

31
  // Can't get the dependency again, because the dependency register was deleted
32
  final counterController2 = Reactter.get<CounterController>();
33
  print("counterController2: $counterController2"); // counterController2: null
4 collapsed lines
34

35
  // Register a dependency by using `id` parameter as singleton mode
36
  Reactter.register(() => CounterController(), id: 'count2');
37

38
  // Get the dependency by using `id` parameter
39
  final counterControllerById = Reactter.get<CounterController>('count2')!;
40
  print("counterControllerById: $counterControllerById");
4 collapsed lines
41

42
  // Delete the dependency by using `id` parameter
43
  Reactter.delete<CounterController>('count2');
44

45
  // Get the dependency by using `id` parameter but its register doesn't exist
46
  final counterControllerById2 = Reactter.get<CounterController>('foo');
47
  print("counterControllerById2: $counterControllerById2"); // counterControllerById2: null
1 collapsed line
48
}

`Reactter.find`

The Reactter.find method is used to find the dependency instance from the Reactter. If the dependency is not created, it will return null .

Syntax

T? Reactter.find<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to find the default instance of the dependency.

Example

See the example below to understand how to use the Reactter.find method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency as factory mode
6
  Reactter.lazyFactory<CounterController>(() => CounterController());
7

8
  // Can't find the dependency instance, because the dependency is not created yet
9
  final counterController = Reactter.find<CounterController>();
10
  print("counterController: $counterController"); // counterController: null
5 collapsed lines
11

12
  // Create a dependency as factory mode
13
  final counterController2 = Reactter.factory<CounterController>()!;
14
  print("counterController2: $counterController2");
15

16
  // Find the dependency
17
  final counterController3 = Reactter.find<CounterController>()!;
18
  print("counterController3: $counterController3");
24 collapsed lines
19

20
  // Listen to the state changes
21
  Reactter.on(
22
    counterController2.count,
23
    Lifecycle.didUpdate,
24
    (_, __) {
25
      print('Count: ${counterController2.count.value}');
26
    },
27
  );
28

29
  // Update the state
30
  counterController2.increment();
31
  counterController2.decrement();
32

33
  // Delete the dependency
34
  Reactter.delete<CounterController>();
35

36
  // Can't update the state, because the dependency register was deleted
37
  // counterController2.increment();
38

39
  // Create a dependency by using `id` parameter as factory mode
40
  final counterControllerById = Reactter.factory<CounterController>('count2')!;
41
  print("counterControllerById: $counterControllerById");
42

43
  // Find the dependency by using `id` parameter
44
  final counterControllerById2 = Reactter.find<CounterController>('count2')!;
45
  print("counterControllerById2: $counterControllerById2");
4 collapsed lines
46

47
  // Delete the dependency by using `id` parameter
48
  Reactter.delete<CounterController>('count2');
49

50
  // Can't find the dependency instance by using `id` parameter, because the dependency was deleted
51
  final counterControllerById3 = Reactter.find<CounterController>('count2');
52
  print("counterControllerById3: $counterControllerById3"); // counterControllerById3: null
4 collapsed lines
53

54
  // Can't update the state, because the dependency register was deleted
55
  // counterControllerById.increment();
56
}

`Reactter.exists`

The Reactter.exists method is used to check if the dependency instance exists in Reactter. It returns true if the dependency instance exists, otherwise return false .

Syntax

bool Reactter.exists<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to check the default instance of the dependency.

Example

See the example below to understand how to use the Reactter.exists method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency as factory mode
6
  Reactter.lazyFactory<CounterController>(() => CounterController());
7

8
  // Can't find the dependency instance, because the dependency is not created yet
9
  final isExists = Reactter.exists<CounterController>();
10
  print("CounterController exists: $isExists"); // CounterController exists: false
5 collapsed lines
11

12
  // Create a dependency as factory mode
13
  final counterController = Reactter.factory<CounterController>()!;
14
  print("counterController: $counterController");
15

16
  // Find the dependency
17
  final isExists2 = Reactter.exists<CounterController>();
18
  print("CounterController exists: $isExists2"); // CountCountroller exists: true
24 collapsed lines
19

20
  // Listen to the state changes
21
  Reactter.on(
22
    counterController.count,
23
    Lifecycle.didUpdate,
24
    (_, __) {
25
      print('Count: ${counterController.count.value}');
26
    },
27
  );
28

29
  // Update the state
30
  counterController.increment();
31
  counterController.decrement();
32

33
  // Delete the dependency
34
  Reactter.delete<CounterController>();
35

36
  // Can't update the state, because the dependency register was deleted
37
  // counterController.increment();
38

39
  // Create a dependency by using `id` parameter as factory mode
40
  final counterControllerById = Reactter.factory<CounterController>('count2')!;
41
  print("counterControllerById: $counterControllerById");
42

43
  // Find the dependency by using `id` parameter
44
  final isExistsById = Reactter.exists<CounterController>('count2');
45
  print("CounterController exists: $isExistsById"); // CounterController exists: true
4 collapsed lines
46

47
  // Delete the dependency by using `id` parameter
48
  Reactter.delete<CounterController>('count2');
49

50
  // Can't find the dependency instance by using `id` parameter, because the dependency was deleted
51
  final isExistsById2 = Reactter.exists<CounterController>('count2');
52
  print("CounterController exists: $isExistsById2"); // CounterController exists: false
4 collapsed lines
53

54
  // Can't update the state, because the dependency register was deleted
55
  // counterControllerById.increment();
56
}

`Reactter.getDependencyMode`

The Reactter.getDependencyMode method is used to get the dependency mode of the dependency.

Syntax

DependencyMode? Reactter.getDependencyMode<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to get the default instance of the dependency.

Example

See the example below to understand how to use the Reactter.getDependencyMode method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency as builder mode
6
  Reactter.builder<CounterController>(() => CounterController());
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10
  print("counterController: $counterController");
11

12
  // Get the dependency mode
13
  final dependencyMode = Reactter.getDependencyMode<CounterController>();
14
  print("Dependency mode: $dependencyMode"); // Dependency mode: DependencyMode.builder
17 collapsed lines
15

16
  // Listen to the state changes
17
  Reactter.on(
18
    counterController.count,
19
    Lifecycle.didUpdate,
20
    (_, __) {
21
      print('Count: ${counterController.count.value}');
22
    },
23
  );
24

25
  // Update the state
26
  counterController.increment();
27
  counterController.decrement();
28

29
  // Delete the dependency
30
  Reactter.delete<CounterController>();
31

32
  // Can't get the dependency mode, because the dependency was deleted
33
  final dependencyMode2 = Reactter.getDependencyMode<CounterController>();
34
  print("Dependency mode: $dependencyMode2"); // Dependency mode: null
11 collapsed lines
35

36
  // Register a dependency by using `id` parameter as factory mode
37
  Reactter.lazyFactory(() => CounterController(), id: 'count2');
38

39
  // Get the dependency by using `id` parameter
40
  final counterControllerById = Reactter.get<CounterController>('count2')!;
41
  print("counterControllerById: $counterControllerById");
42

43
  // Delete the dependency by using `id` parameter
44
  Reactter.delete<CounterController>('count2');
45

46
  // Get the dependency mode by using `id` parameter
47
  final dependencyModeById2 = Reactter.getDependencyMode<CounterController>('count2');
48
  print("Dependency mode: $dependencyModeById2"); // Dependency mode: DependencyMode.factory
4 collapsed lines
49

50
  // If you need to delete the dependency fully, use `Reactter.destroy` method by forcing it, because it's factory mode
51
  Reactter.destroy<CounterController>(id: 'count2');
52

53
  // Can't get the dependency mode, because the dependency was destroyed
54
  final dependencyModeById2 = Reactter.getDependencyMode<CounterController>('count2');
55
  print("Dependency mode: $dependencyModeById2"); // Dependency mode: null
5 collapsed lines
56

57
  // Create a dependency as singleton mode
58
  final counterController2 = Reactter.singleton<CounterController>()!;
59
  print("counterController2: $counterController2");
60

61
  // Get the dependency mode by using `id` parameter
62
  final dependencyMode3 = Reactter.getDependencyMode<CounterController>();
63
  print("Dependency mode: $dependencyMode3"); // Dependency mode: DependencyMode.singleton
4 collapsed lines
64

65
  // If you need to delete the dependency fully, use `Reactter.destroy` method by forcing it, because it's singleton mode
66
  Reactter.destroy<CounterController>();
67

68
  // Can't get the dependency mode, because the dependency was destroyed
69
  final dependencyMode4 = Reactter.getDependencyMode<CounterController>();
70
  print("Dependency mode: $dependencyMode4"); // Dependency mode: null
1 collapsed line
71
}

`Reactter.delete`

The Reactter.delete method is used to delete the dependency instance from the Reactter. It returns true if the dependency is deleted successfully, otherwise return false .

Syntax

bool Reactter.delete<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to delete the default instance of the dependency.

Example

See the example below to understand how to use the Reactter.delete method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Register a dependency
6
  Reactter.register<CounterController>(() => CounterController());
7

8
  // Get the dependency
9
  final counterController = Reactter.get<CounterController>()!;
10
  print("counterController: $counterController");
11

12
  // Listen to the state changes
13
  Reactter.on(
14
    counterController.count,
15
    Lifecycle.didUpdate,
16
    (_, __) {
17
      print('Count: ${counterController.count.value}');
18
    },
19
  );
20

21
  // Update the state
22
  counterController.increment();
23
  counterController.decrement();
24

25
  // Delete the dependency
26
  Reactter.delete<CounterController>();
15 collapsed lines
27

28
  // Can't update the state, because the dependency register was deleted
29
  // counterController.increment();
30

31
  // Can't get the dependency instance, because the dependency register was deleted
32
  final counterController2 = Reactter.get<CounterController>();
33
  print("counterController2: $counterController2"); // counterController2: null
34

35
  // Register a dependency by using `id` parameter
36
  Reactter.register(() => CounterController(), id: 'count2');
37

38
  // Get the dependency by using `id` parameter
39
  final counterControllerById = Reactter.get<CounterController>('count2')!;
40
  print("counterControllerById: $counterControllerById");
41

42
  // Delete the dependency by using `id` parameter
43
  Reactter.delete<CounterController>('count2');
5 collapsed lines
44

45
  // Get the dependency by using `id` parameter but its register doesn't exist
46
  final counterControllerById2 = Reactter.get<CounterController>('foo');
47
  print("counterControllerById2: $counterControllerById2"); // counterControllerById2: null
48
}

`Reactter.destroy`

The Reactter.destroy method is used to destroy the dependency instance and its register from the Reactter. It returns true if the dependency is destroyed successfully, otherwise return false .

Syntax

bool Reactter.destroy<T>({
  String? id,
  bool onlyDependency = false,
});

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to destroy the default instance of the dependency.
onlyDependency: An optional parameter to delete the dependency instance only. The default value is false .

Example

See the example below to understand how to use the Reactter.destroy method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Create a dependency as factory mode
6
  final counterController = Reactter.singleton<CounterController>(() => CounterController());
7

8
  // Listen to the state changes
9
  Reactter.on(
10
    counterController.count,
11
    Lifecycle.didUpdate,
12
    (_, __) {
13
      print('Count: ${counterController.count.value}');
14
    },
15
  );
16

17
  // Update the state
18
  counterController.increment();
19
  counterController.decrement();
20

21
  // Destroy the dependency instance only
22
  Reactter.destroy<CounterController>(onlyDependency: true);
4 collapsed lines
23

24
  // Can get the dependency again, because its register is skipped from destroying.
25
  final counterController2 = Reactter.get<CounterController>()!;
26

27
  // Destroy the dependency instance and its register
28
  Reactter.destroy<CounterController>();
12 collapsed lines
29

30
  // Can't update the state, because the dependency register was destroyed
31
  // counterController.increment();
32

33
  // Can't get the dependency instance, because the dependency register was destroyed
34
  final counterController2 = Reactter.get<CounterController>();
35
  print("counterController2: $counterController2"); // counterController2: null
36

37
  // Create a dependency by using `id` parameter as singleton mode
38
  final counterControllerById = Reactter.singleton(() => CounterController(), id: 'count2');
39
  print("counterControllerById: $counterControllerById");
40

41
  // Destroy the dependency by using `id` parameter
42
  Reactter.destroy<CounterController>(id: 'count2');
5 collapsed lines
43

44
  // Can't get the dependency instance, because the dependency register was destroyed
45
  final counterControllerById2 = Reactter.get<CounterController>('count2');
46
  print("counterControllerById2: $counterControllerById2"); // counterControllerById2: null
47
}

`Reactter.unregister`

The Reactter.unregister method is used to unregister the dependency from the Reactter. It returns true if the dependency is unregistered successfully, otherwise return false .

Syntax

bool Reactter.unregister<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to unregister the default instance of the dependency.

Example

See the example below to understand how to use the Reactter.unregister method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // Create a dependency as factory mode
6
  final counterController = Reactter.factory<CounterController>(() => CounterController());
7

8
  // Listen to the state changes
9
  Reactter.on(
10
    counterController.count,
11
    Lifecycle.didUpdate,
12
    (_, __) {
13
      print('Count: ${counterController.count.value}');
14
    },
15
  );
16

17
  // Update the state
18
  counterController.increment();
19
  counterController.decrement();
20

21
  // Can't unregister the dependency, because the dependency is active
22
  Reactter.unregister<CounterController>();
8 collapsed lines
23

24
  // Delete the dependency
25
  Reactter.delete<CounterController>();
26

27
  // Can get the dependency again, because it's factory mode
28
  final contController2 = Reactter.get<CounterController>();
29
  print("contController2: $contController2");
30

31
  // Can unregister the dependency, because the dependency is deleted
32
  Reactter.unregister<CounterController>();
15 collapsed lines
33

34
  // Can't update the state, because the dependency register was unregistered
35
  // counterController.increment();
36

37
  // Can't get the dependency instance, because the dependency register was unregistered
38
  final counterController3 = Reactter.get<CounterController>();
39
  print("counterController3: $counterController3"); // counterController2: null
40

41
  // Create a dependency by using `id` parameter as factory mode
42
  final counterControllerById = Reactter.factory(() => CounterController(), id: 'count2');
43
  print("counterControllerById: $counterControllerById");
44

45
  // Delete the dependency by using `id` parameter
46
  Reactter.delete<CounterController>('count2');
47

48
  // Unregister the dependency by using `id` parameter
49
  Reactter.unregister<CounterController>('count2');
5 collapsed lines
50

51
  // Can't get the dependency instance, because the dependency register was unregistered
52
  final counterControllerById2 = Reactter.get<CounterController>('count2');
53
  print("counterControllerById2: $counterControllerById2"); // counterControllerById2: null
54
}

`Reactter.isRegistered`

The Reactter.isRegistered method is used to check if the dependency is registered in Reactter. It returns true if the dependency is registered, otherwise return false .

Syntax

bool Reactter.isRegistered<T>([String? id]);

Parameters

id: An optional identifier for the T dependency. If not provided, the method will attempt to check the default instance of the dependency.

Example

See the example below to understand how to use the Reactter.isRegistered method in different scenarios.


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

3
class CounterController {
4
  // Create a reactive state using the `Signal` class
5
  final count = Signal(0);
6

7
  void increment() {
8
    count.value++;
9
  }
10

11
  void decrement() {
12
    count.value--;
13
  }
14
}


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

4
void main() {
5
  // The dependency is not registered yet
6
  final isRegistered = Reactter.isRegistered<CounterController>();
7
  print("CounterController is registered: $isRegistered"); // CounterController is registered: false
4 collapsed lines
8

9
  // Register a dependency as factory mode
10
  Reactter.lazyFactory<CounterController>(() => CounterController());
11

12
  // The dependency is registered
13
  final isRegistered2 = Reactter.isRegistered<CounterController>();
14
  print("CounterController is registered: $isRegistered2"); // CounterController is registered: true
21 collapsed lines
15

16
  // Create a dependency as factory mode
17
  final counterController = Reactter.factory<CounterController>()!;
18
  print("counterController: $counterController");
19

20
  // Listen to the state changes
21
  Reactter.on(
22
    counterController.count,
23
    Lifecycle.didUpdate,
24
    (_, __) {
25
      print('Count: ${counterController.count.value}');
26
    },
27
  );
28

29
  // Update the state
30
  counterController.increment();
31
  counterController.decrement();
32

33
  // Delete the dependency
34
  Reactter.delete<CounterController>();
35

36
  // The dependency is registered, because it's factory mode
37
  final isRegistered3 = Reactter.isRegistered<CounterController>();
38
  print("CounterController is registered: $isRegistered3"); // CounterController is registered: true
18 collapsed lines
39

40
  // Can't update the state, because the dependency register was deleted
41
  // counterController.increment();
42

43
  // Create a dependency by using `id` parameter as factory mode
44
  final counterControllerById = Reactter.factory<CounterController>('count2')!;
45
  print("counterControllerById: $counterControllerById");
46

47
  // Delete the dependency by using `id` parameter
48
  Reactter.delete<CounterController>('count2');
49

50
  // The dependency is registered
51
  final isRegisteredById = Reactter.isRegistered<CounterController>('count2');
52
  print("CounterController is registered: $isRegisteredById"); // CounterController is registered: true
53

54
  // Unregister the dependency by using `id` parameter
55
  Reactter.unregister<CounterController>('count2');
56

57
  // The dependency is not registered
58
  final isRegisteredById2 = Reactter.isRegistered<CounterController>('count2');
59
  print("CounterController is registered: $isRegisteredById2"); // CounterController is registered: false
4 collapsed lines
60

61
  // Can't update the state, because the dependency register was deleted
62
  // counterControllerById.increment();
63
}