UseDependency

UseDependency is a hook that allows to manage a dependency.

Constructors and factories

UseDependency : Default constructor to get the T dependency. It’s similar to using Reactter.find .
```
UseDependency<T>([String? id]);
```
UseDependency.get : Get a T dependency inmediately. It’s similar to using Reactter.get .
```
UseDependency<T>.get([String? id]);
```

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

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

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

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

UseDependency.lazyBuilder : Registers a builder function, to create a instance of the T dependency as Builder mode. It’s similar to using Reactter.lazyBuilder .
```
UseDependency<T>.lazyBuilder(T Function() builder, [String? id]);
```
UseDependency.lazyFactory : Registers a builder function, to create a instance of the T dependency as Factory mode. It’s similar to using Reactter.lazyFactory .
```
UseDependency<T>.lazyFactory(T Function() builder, [String? id]);
```
UseDependency.lazySingleton : Registers a builder function, to create a instance of the T dependency as Singleton mode. It’s similar to using Reactter.lazySingleton .
```
UseDependency<T>.lazySingleton(T Function() builder, [String? id]);
```
UseDependency.builder : Registers, creates and gets a T dependency inmediately as Builder mode. It’s similar to using Reactter.builder .
```
UseDependency<T>.builder(T Function() builder, {
  String? id,
  DependencyMode mode = DependencyMode.builder,
});
```
UseDependency.factory : Registers, creates and gets a T dependency inmediately as Factory mode. It’s similar to using Reactter.factory .
```
UseDependency<T>.factory(T Function() builder, {
  String? id,
  DependencyMode mode = DependencyMode.builder,
});
```
UseDependency.singleton : Registers, creates and gets a T dependency inmediately as Singleton mode. It’s similar to using Reactter.singleton .
```
UseDependency<T>.singleton(T Function() builder, {
  String? id,
  DependencyMode mode = DependencyMode.builder,
});
```

Arguments

id: An optional String value to identify the dependency of T type.
builder : A function that returns an instance of the dependency of T type.
mode: An optional DependencyMode value to define the dependency mode. Default value is DependencyMode.builder. Learn more about it in DependencyMode.

Properties and methods

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

Methods inherited from ReactterState (Learn more here):
- update : A method to notify changes after run a set of instructions.
- refresh : A method to force to notify changes.
- * bind : A method to bind an instance to it.
- * unbind : A method to unbind an instance to it.
- * dispose : A method to remove all listeners and free resources.
* These methods are unnecessary when is declared within a dependency(class registered via the dependecy injection).

Usage

Finding a dependency

You can 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
}

The UseDependency hook is ideal for checking if a dependency has been created and waiting for it to become available using UseEffect hook, 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

You can use the id argument 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 argument is ideal for identifying dependencies, when you need to use the same dependency type in different places, e.g.:

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: ReactterProviders(
8
        [
9
          ReactterProvider(() => MyDependency()),
10
          ReactterProvider(() => MyDependency(), id: "uniqueId"),
11
          ReactterProvider(() => MyController()),
12
        ],
13
        build: (_, __) => MyHomePage(),
14
      ),
15
    ),
16
  }
17
}

Using the dependency

You can 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
      if (uDependency.instance != null) {
9
        print("Dependency instance: ${uDependency.instance}");
10
      }
11
    }, [uDependency]);
12
  }
13
}

Getting a dependency

You can use 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.:

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: ReactterProviders(
8
        [
9
          ReactterProvider(() => MyDependency()),
10
          ReactterProvider(() => 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

You can 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 Reactter.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
    Reactter.get<MyDependency>();
8
    print("Dependency instance: ${uDependency.instance}");
9
  }
10
}

Also, you can create the dependency instance inmediately by 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.:

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: ReactterProvider(
8
        () => DependenciesRegisters(),
9
        build: (_, __, ___) => MyHomePage(),
10
      ),
11
    ),
12
  }
13
}

Creating a dependency

You can 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

You can use the mode argument 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 argument 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. Learn more about it in Dependency Modes, e.g.:

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: ReactterProvider(
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
}