InheritedModel<T> class abstract

An InheritedWidget that's intended to be used as the base class for models whose dependents may only depend on one part or "aspect" of the overall model.

An inherited widget's dependents are unconditionally rebuilt when the inherited widget changes per InheritedWidget.updateShouldNotify. This widget is similar except that dependents aren't rebuilt unconditionally.

Widgets that depend on an InheritedModel qualify their dependence with a value that indicates what "aspect" of the model they depend on. When the model is rebuilt, dependents will also be rebuilt, but only if there was a change in the model that corresponds to the aspect they provided.

The type parameter T is the type of the model aspect objects.

Widgets create a dependency on an InheritedModel with a static method: InheritedModel.inheritFrom. This method's context parameter defines the subtree that will be rebuilt when the model changes. Typically the inheritFrom method is called from a model-specific static maybeOf or of methods, a convention that is present in many Flutter framework classes which look things up. For example:

class MyModel extends InheritedModel<String> {
  const MyModel({super.key, required super.child});

  // ...
  static MyModel? maybeOf(BuildContext context, [String? aspect]) {
    return InheritedModel.inheritFrom<MyModel>(context, aspect: aspect);
  }

  // ...
  static MyModel of(BuildContext context, [String? aspect]) {
    final MyModel? result = maybeOf(context, aspect);
    assert(result != null, 'Unable to find an instance of MyModel...');
    return result!;
  }
}

Calling MyModel.of(context, 'foo') or MyModel.maybeOf(context, 'foo') means that context should only be rebuilt when the foo aspect of MyModel changes. If the aspect is null, then the model supports all aspects.

class ABModel extends InheritedModel<String> {
  const ABModel({
   super.key,
   this.a,
   this.b,
   required super.child,
  });

  final int? a;
  final int? b;

  @override
  bool updateShouldNotify(ABModel oldWidget) {
    return a != oldWidget.a || b != oldWidget.b;
  }

  @override
  bool updateShouldNotifyDependent(ABModel oldWidget, Set<String> dependencies) {
    return (a != oldWidget.a && dependencies.contains('a'))
      || (b != oldWidget.b && dependencies.contains('b'));
  }

  // ...
}

In the previous example the dependencies checked by updateShouldNotifyDependent are just the aspect strings passed to dependOnInheritedWidgetOfExactType. They're represented as a Set because one Widget can depend on more than one aspect of the model. If a widget depends on the model but doesn't specify an aspect, then changes in the model will cause the widget to be rebuilt unconditionally.

See also:

• InheritedWidget, an inherited widget that only notifies dependents when its value is different.
• InheritedNotifier, an inherited widget whose value can be a Listenable, and which will notify dependents whenever the value sends notifications.