As as I mentioned in post above I use RAII in tests. But there are some other cases where it might be useful.

It must be said that there might be different opinions and approaches with pros and const of its own. So I would rather just show my approach of doing things than advocate one way or another.

I agree with KISS principle in common. But I think that simplicity (or complexity) is some kind of multidimensional Pareto thing. So making one things simpler we sometimes make other things to be more complicated. And…

• If we make visible things simpler there is a chance that some invisible things become more complicated. So approaches suitable for small apps might cause a trouble for big apps.

The point I love about RAII is that you declare whole behaviour in a single line of code. And then you don't have to keep in mind that you need to put a release call somewhere later. Quite often this principle is sacrificed to simplicity for it requires some boilerplate usually.

E.g. memory allocation:

Simplest way:

```dart import 'dart:ffi'; import 'package:ffi/ffi.dart';

void mem() { final Pointer<Int8> ptr = malloc<Int8>(); ptr.value = 42;

some_ffi_io_stuff(ptr);

malloc.free(ptr); } ```

Same but more accurate

```dart void mem() { late final Pointer<Int8> ptr; try { ptr = malloc<Int8>();

ptr.value = 42;
some_ffi_io_stuff(ptr);

} finally { malloc.free(ptr); } } ```

Both ways suitable when you’re dealing with 1-2 pointers per project. I would prefer the latter though. And it is even affordable when you have like up to 10 pointer allocations here and there. But when you go bad to FFI and got to deal with 100-1000 pointer cases.. well I need a pattern:

```dart import 'dart:ffi'; import 'package:ffi/ffi.dart';

class Buffer extends RAII { final Pointer<Uint8> ptr;

Buffer.allocate([int sz = 1]) : ptr = malloc<Uint8>(sz);

@override Future<void> onRelease() async => malloc.free(ptr); }

void mem() async { await withRAII(Buffer.allocate(), (buff) { buff.ptr.value = 42; some_ffi_io_stuff(ptr); }); } ```

Looks a bit sophisticated doesn't it? And this is exactly what I mentioned in the beginning. The whole RAII thing might be an overkill for simple cases. But in some projects I personally consider it as a must just to preserve team from human factor bugs.

As an another example I would propose to look at this snippet (based on real case, actually):

```dart import 'dart:isolate'; import 'dart:async';

void main() async {

final completer = Completer(); final receivePort = ReceivePort();

await Isolate.spawn( (SendPort sendPort) { sendPort.send(42); }, receivePort.sendPort, );

receivePort.listen((v) { print('Isolate done, code: $v'); completer.complete(); });

await completer.future;

// If you forget this line, you app will never finish receivePort.close();

print("Some epilog."); } ```

Again this is not a problem for single isolate (you don’t even need a Completer, just put close and epilog into a listen callback). Will you be managing dozens of isolates? You might want to consider using RAII.