ExceptionHandler Widget

[escamoteur]

@eseidelGoogle As discussed here is the issue:

Currently we don't have a possibility to handle Exceptions that happens inside a Widget somewhere down the widget tree. I would propose a Widget that allows that. Something like

typedef ExceptionHandler = void Function( ex)
typedef AlternativeBuilder = void Function(BuildingContext context, ex)


ExceptionHandledBuilder(
   List<Object>  exceptionsToCatch,           // Exceptions that should behandled  (It's really a pity that Dart doesen't have a common Exception base class)
   HandlerFunction: onException,               // get's called to allow logging or what else
   AlternativeBuilder: alternativeBuilder,     // Builder that get's invoked while executing the normal builder method
   AsyncWidgetBuilder<T>: builder);          // the default builder that tryies to bild the child widget tree.

I'm not sure if something like this is possible.

What are your thoughts?

[eseidelGoogle]

@Hixie and @leafpetersen are the right folks for thoughts probably.

[leafpetersen]

I don't have a lot of thoughts from the language perspective (as opposed to the API perspective), other than to wonder whether support for implicitly lazy parameters would clean this up a bit? cc @munificent

[Hixie]

@escamoteur What's the use case here?

[zoechi]

I guess the first bullet of #19996

[escamoteur]

@Hixie if I call a function to assign a value inside the widget tree that could throw an exception I have no chance to handle this. Sure I could do such calls at the beginning of the build method with a try-catch and set some bool flags to display different contents but I think there should be a better way to achieve that

[munificent]

Ah, so the issue is that in the middle of building a tree of widgets, an exception might occur. You want to be able to catch it and provide an alternate subtree instead of the failed one?

Something like:

Widget hopefullyMakeText() {
  if (sometimes) throw "Oh no!";

  return Text('Hello, world!');
}

Widget build() {
  return Center(child: hopefullyMakeText());
}

And you want to be able to handle that exception and swap out the widget without having to do:

Widget build() {
  // Hoist everything out of expression.
  Widget child;
  try {
    child = hopefullyMakeText();
  } catch (error) {
    child = Text('Fallback');
  }

  return Center(child: child);
}

Do I have that right? You can always solve this at the application level by writing a utility function:

Widget definitelyMakeText() {
  try {
    return hopefullyMakeText();
  } catch (error) {
    return Text('Fallback');
  }
}

Widget build() {
  return Center(child: definitelyMakeText());
}

If Dart were an expression-oriented language, I could imagine that it would allow something like:

Widget build() {
  return Center(
    child: try {
      hopefullyMakeText();
    } catch (error) {
      Text('Fallback');
    }
  );
}

I'm definitely not proposing that, but that is a way it could be solved in the language.

As far as your original question, yes, it's possible. Here's one way:

T handleException<T>(T Function() original, T Function() fallback) {
  try {
    return original();
  } catch (error) {
    return fallback();
  }
}

Then you'd use it like:

Widget build() {
  return Center(
    child: handleException(hopefullyMakeText, () => Text('Fallback'))
  );
}

It would be easy to extend handleException() to let you control which exceptions it catches.

[zoechi]

@escamoteur what do you think about @munificent's suggestion?

[escamoteur]

Yeah, that is a completely feasible solution. My suggestion from the beginning was if something like that shouldn't be part of the framework. @eseidelGoogle

[Hixie]

I would recommend making your build methods not ever throw. Don't read data from a database within your build methods, for example; read the data in your model objects, asynchronously, and have the build methods read from your model in a way guaranteed not to throw.

But if that's not a thing you want to do, consider making a variant of Builder that catches exceptions, something like (untested):

class SafeBuilder extends StatelessWidget {
  SafeBuilder({
    Key key,
    this.builder,
  }) : super(key: key);
  final WidgetBuilder builder;
  @override
  Widget build(BuildContext context) {
    try {
      return builder(context);
    } catch (error) {
      return ErrorWidget(error);
    }
  }
}

If you want custom handling for the error, you can call a different builder instead of ErrorWidget.

Also you may wish to look at ErrorWidget.builder, which is a more global way to catch errors.

[escamoteur]

@Hixie that looks like an interesting idea. I agree with you that normally this should not happen. Anyway I still think such a widget should be part of the framework in case you need it e.g. if a Widget from a package throws exception under certain conditions.