Come utilizzare il pacchetto Provider in Flutter

Blog

Come utilizzare il pacchetto Provider in Flutter

Un misto tra iniezione di dipendenza (DI) e gestione dello stato, costruito con widget per widget.



Utilizza intenzionalmente widget per la gestione DI/stato invece di classi solo dart come |_+_|. Il motivo è che i widget sono molto semplici ma robusti e scalabili.

dove posso acquistare criptovaluta da valanga?

Utilizzando i widget per la gestione dello stato, |_+_| può garantire:



  • manutenibilità, attraverso un flusso di dati unidirezionale forzato
  • testabilità/componibilità, poiché è sempre possibile deridere/sovrascrivere un valore
  • robustezza, poiché è più difficile dimenticare di gestire lo scenario di aggiornamento di un modello/widget

Migrazione da v3.x.0 a v4.0.0

  • I parametri |_+_| e |_+_| dei fornitori vengono rimossi.

    • |_+_| dovrebbe essere sostituito da |_+_|.
    • |_+_| dei fornitori di proxy dovrebbe essere sostituito da |_+_|
    • |_+_| dei fornitori classici dovrebbe essere sostituito da |_+_|.
  • Il nuovo |_+_|/|_+_| i callback sono lazy-loaded, il che significa che vengono chiamati la prima volta che viene letto il valore anziché la prima volta che viene creato il provider.



Se questo non è desiderato, puoi disabilitare il caricamento lento passando |_+_| al fornitore di tua scelta:

Stream
  • |_+_| viene rinominato in |_+_|.

  • Il |_+_| l'interfaccia viene rimossa e sostituita da un nuovo tipo di widget |_+_|.

Vedere questa edizione per i dettagli su come eseguire la migrazione.

  • |_+_| ora confronta profondamente i valori precedenti e nuovi se sono collezioni.

Se questo non è desiderato, puoi ripristinare il vecchio comportamento passando un |_+_| parametro a |_+_|:

provider
  • |_+_| e la sua famiglia viene rimossa. Invece, per i provider personalizzati, sottoclasse direttamente |_+_| o un fornitore esistente.

Utilizzo

Esporre un valore

Esposizione di una nuova istanza di oggetto

I provider consentono non solo di esporre un valore, ma anche di crearlo/ascoltarlo/disponirlo.

Per esporre un oggetto appena creato, usa il costruttore predefinito di un provider. Fare non usa il |_+_| costruttore se vuoi creare un oggetto, altrimenti potresti avere effetti collaterali indesiderati.

Vedere questa risposta stackoverflow che spiega in maggiori dettagli perché usare |_+_| costruttore per creare valori è indesiderato.

  • FARE creare un nuovo oggetto all'interno di |_+_|.
builder
  • NON FARE usa |_+_| per creare il tuo oggetto
initialBuilder
  • NON FARE crea il tuo oggetto da variabili che possono cambiare nel tempo.

In tale situazione, il tuo oggetto non verrebbe mai aggiornato quando il valore cambia.

initialBuilder

Se vuoi passare variabili che possono cambiare nel tempo al tuo oggetto, considera l'utilizzo di |_+_|:

create

Riutilizzo di un'istanza di oggetto esistente:

Se hai già un'istanza di oggetto e vuoi esporla, dovresti usare |_+_| costruttore di un fornitore.

In caso contrario, è possibile chiamare il |_+_| metodo del tuo oggetto quando è ancora in uso.

  • FARE usa |_+_| per fornire un |_+_| esistente.
builder
  • NON FARE riutilizzare un |_+_| . esistente usando il costruttore predefinito
update

Leggere un valore

Il modo più semplice per leggere un valore è utilizzare il metodo statico |_+_|.

installa oh mio zsh ubuntu

Questo metodo cercherà nell'albero dei widget a partire dal widget associato al |_+_| passato e restituirà la variabile più vicina di tipo |_+_| trovato (o buttare se non viene trovato nulla).

In combinazione con il primo esempio di esposizione di un valore, questo widget leggerà l'esposto |_+_| e renderizza Hello World.

builder

In alternativa invece di usare |_+_|, possiamo usare |_+_| e |_+_|.

Questi possono essere utili per l'ottimizzazione delle prestazioni o quando è difficile ottenere un |_+_| discendente del prestatore.

Vedi il FAQ o la documentazione di Consumatore e Selettore per maggiori informazioni.

Multiprovider

Quando si iniettano molti valori in grandi applicazioni, |_+_| può diventare rapidamente abbastanza annidato:

create

Per:

create

Il comportamento di entrambi gli esempi è rigorosamente lo stesso. |_+_| cambia solo l'aspetto del codice.

ProxyProvider

Dalla versione 3.0.0, c'è un nuovo tipo di provider: |_+_|.

|_+_| è un provider che combina più valori di altri provider in un nuovo oggetto e invia il risultato a |_+_|.

Quel nuovo oggetto verrà quindi aggiornato ogni volta che uno dei provider dipende dagli aggiornamenti.

L'esempio seguente usa |_+_| per costruire traduzioni basate su un contatore proveniente da un altro provider.

update

È disponibile in più varianti, come ad esempio:

  • |_+_| contro |_+_| contro |_+_|, …

Quella cifra dopo il nome della classe è il numero di altri provider che |_+_| dipende da.

  • |_+_| contro |_+_| contro |_+_|, …

Funzionano tutti allo stesso modo, ma invece di inviare il risultato in un |_+_|, un |_+_| invierà il suo valore a un |_+_|.

FAQ

Ho un'eccezione quando ottengo i provider all'interno di |_+_|. Cosa posso fare?

Questa eccezione si verifica perché stai cercando di ascoltare un provider da un ciclo di vita che non verrà mai più chiamato.

Significa che dovresti usare un altro ciclo di vita (|_+_|/|_+_|), o specificare esplicitamente che non ti interessano gli aggiornamenti.

Come tale, invece di:

lazy: false

tu puoi fare:

``` FutureProvider( create: (_) async => doSomeHttpRequest(), lazy: false, child: ... ) ```

che stamperà |_+_| ogni volta che cambia.

In alternativa puoi fare:

ProviderNotFoundError

Che stamperà |_+_| una volta e ignora gli aggiornamenti.

io uso |_+_| e ho un'eccezione quando lo aggiorno, cosa succede?

Questo probabilmente accade perché stai modificando il |_+_| da uno dei suoi discendenti mentre l'albero dei widget sta costruendo .

Una situazione tipica in cui ciò accade è quando si avvia una richiesta http, in cui il futuro è memorizzato all'interno del notificatore:

ProviderNotFoundException

Questo non è consentito, perché la modifica è immediata.

Il che significa che alcuni widget potrebbero essere costruiti prima la mutazione, mentre verranno costruiti altri widget dopo la mutazione. Ciò potrebbe causare incongruenze nell'interfaccia utente e pertanto non è consentito.

Invece, dovresti eseguire quella mutazione in un luogo che influenzerebbe allo stesso modo l'intero albero:

  • direttamente all'interno di |_+_| del tuo fornitore/costruttore del tuo modello:

    SingleChildCloneableWidget

Questo è utile quando non ci sono parametri esterni.

sfondo estensione chrome persistente
  • in modo asincrono alla fine del frame:

    SingleChildWidget

È leggermente meno ideale, ma consente il passaggio di parametri alla mutazione.

Devo usare |_+_| per stati complessi?

No.

Puoi usare qualsiasi oggetto per rappresentare il tuo stato. Ad esempio, un'architettura alternativa consiste nell'usare |_+_| combinato con un |_+_|.

Ecco un controesempio che utilizza tale architettura:

Selector

dove possiamo leggere lo stato facendo:

la ricerca su facebook non funziona 2016
shouldRebuild

e modificare lo stato con:

Selector

In alternativa, puoi creare il tuo provider.

Posso creare il mio provider?

Sì. |_+_| espone tutti i piccoli componenti che rende un fornitore a tutti gli effetti.

Ciò comprende:

  • |_+_|, per far funzionare qualsiasi widget con |_+_|.
  • |_+_|, il generico |_+_| ottenuto facendo |_+_|.
  • |_+_|/|_+_|/|_+_| per aiutare a gestire la logica di MyProvider() che crea un oggetto rispetto a MyProvider.value() che può essere aggiornato nel tempo.

Ecco un esempio di provider personalizzato da utilizzare |_+_| come stato: https://gist.github.com/rrousselGit/4910f3125e41600df3c2577e26967c91

Il mio widget si ricostruisce troppo spesso, cosa posso fare?

Invece di |_+_|, puoi usare |_+_|/|_+_|.

Il loro |_+_| optional opzionale L'argomento consente di ricostruire solo una parte molto specifica dell'albero dei widget:

``` Selector( shouldRebuild: (previous, next) => previous == next, builder: ..., ) ```

In questo esempio, solo |_+_| ricostruirà quando |_+_| aggiornamenti. |_+_| e |_+_| non ricostruirà inutilmente.

Per fare un ulteriore passo avanti, è possibile utilizzare |_+_| per ignorare le modifiche se non hanno un impatto sull'albero dei widget:

DelegateWidget

Questo frammento verrà ricostruito solo se la lunghezza dell'elenco cambia. Ma non si aggiornerà inutilmente se un elemento viene aggiornato.

Posso ottenere due fornitori diversi che utilizzano lo stesso tipo?

No. Mentre puoi avere più provider che condividono lo stesso tipo, un widget sarà in grado di ottenere solo uno di essi: l'antenato più vicino.

È invece necessario assegnare esplicitamente a entrambi i provider un tipo diverso.

Invece di:

InheritedProvider

Preferire:

.value

Pacchetto fornitore Flutter in dettaglio - Change Notifier Provider

Change Notifier Provider che fornisce un ottimo modo per collegare i tuoi widget a una classe di stato di backend e soluzioni di dati non reattivi come Preferenze condivise, SQLLite e API REST.

GitHub: https://github.com/nhandrew/WaxApplication


Pacchetto fornitore Flutter in dettaglio - StreamProvider

StreamProvider che fornisce un ottimo modo per collegare i tuoi widget a flussi da Firestore, BLoC e altre fonti reattive. Questa parte si baserà sull'app iniziata nel primo video della serie su ChangeNotifierProvider.

GitHub: https://github.com/nhandrew/WaxApplication


Pacchetto fornitore Flutter in dettaglio - FutureProvider

FutureProvider come un modo per semplificare la tua interfaccia utente in attesa di un futuro da un'API o da un'altra fonte.

https://github.com/nhandrew/futureprovider


Pacchetto fornitore Flutter in dettaglio - ProxyProvider

ProxyProvider come un modo per concatenare operazioni reattive o asincrone in cui i valori risolti o trasmessi in streaming diventano parametri più in basso nella catena.

GitHub: https://github.com/nhandrew/proxyprovider

#flutter #app-mobile

una riga if istruzione javascript