dependency_manager 1.0.3

Package desenvolvido para prover funções para o controle e gerenciamento de instâncias de dependências em app.

Observações importantes:

• A passagem de tipo genérico[O] sempre será obrigatória para todas as funções

• As funções [Dependencies.set] & [Dependencies.add] sempre irão verificar se o objeto de dependência já existe, impossibilitando criar e adicionar uma instância que já existe sendo singleton ou não. No caso da função [add], ela irá retornar a instância do objeto que já existe nas dependências.

Como definir as dependências na inicialização da app

void main() async{

  /// Executar procedimentos antes ou depois da app iniciar
  WidgetsFlutterBinding.ensureInitialized();

  /// executar/carregar multiplos procedimento que serão executados aos mesmo tempo(assíncrono) e
  /// depois que completar as execuções a app será iniciada
  await Future.wait([
    Dependencies.set([
      Dependency<AnyObject>(() => AnyObject(), isLazy: false, isSingleton: false),
      Dependency<Controller>.lazySingleton(() => Controller()),
      Dependency<HttpClient>.singleton(() => HttpClient())
    ])
  ]).whenComplete(() {
    runApp(const MyApp());
  });

}

Formas de como obter uma instância

Controller controller = Dependencies.get();

Controller controller = Dependencies.get<Controller>();

var controller = Dependencies.get<Controller>();

Como adicionar uma instância depois que a app foi iniciada

Controller controllers = Dependencies.add<Controller>(() => Controller());
//ou
var controllers = Dependencies.add<Controller>(() => Controller());
//ou
Controller controllers = Dependencies.add(() => Controller());

Como remover e disposar uma instância de dependência

Dependencies.remove<Tata>();

Como remover e disposar todas as instância de dependência

await Dependencies.removeAll();

Como disposar uma instância. Essa função deve ser chamada quando o objeto for disposavel e singleton = false

Dependencies.dispose<Controller>();

Como verificar se existe um objeto de dependência registrado

bool dependencyContains = Dependencies.contains<Controller>();

Outras formas de acessar as mesmas funções estáticas sem acessar diretamente a classe [Dependencies]

Obter uma instância herdando ou mixando a classe [Dependencies]

class Widget extends StatelessWidget with Dependencies{
  @override
  Widget build(BuildContext context) {
    
    var controller = get<Controller>();

    return AnyWidget();
  }
}

Obter uma instância através da propriedade [dependencies] que é adicionada automaticamente dentro das classes [StatelessWidget] & [State]

class MyWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    
    final controller = dependencies.get<Controller>();

    return AnyWidget();
  }
}

Como obter e disposar uma instância automaticamente dentro de um widget [StatefulWidget]. O dispose só será executado se a dependência for singleton = false

class WidgetExample extends StatefulWidget {
  const WidgetExample({ Key? key }) : super(key: key);
  @override
  State<WidgetExample> createState() => _WidgetExampleState();
}

// Basta apenas substituir a classe [State] por [DependencyState] passando o segundo tipo de
// objeto que é a dependência
class _WidgetExampleState extends DependencyState<WidgetExample, Controller> {
//class _WidgetExampleState extends State<WidgetExample> {

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('DependencyState'),
      ),
      body: Center(
        child: Text(dependency.str),
      ),
    );
  }
}

class Controller extends Disposeble{
  
  String str = 'MyController';
  
  @override
  void dispose() {
    print('---- dispose Controller ----'); 
  }

}