disposer | Easily dispose rxJava streams with Android 's Lifecycle | Reactive Programming library

By default make(Auto)Observable only supports properties that are already defined, so you need to define every property inside constructor or make it nullable like that: author = null, or add default value likes = 0:

From an Autofac perspective, you actually will have to start tracking parent and child scopes so you can choose when to dispose them. It's sort of a Spider-Man situation: With great power comes great responsibility.

Sometimes this is as easy as wrapping the set of various units of work with a using statement. In an async situation, like with ASP.NET, places like middleware and HttpContext come into play.

Disposing a parent out from under a child is a bad idea. Besides the fact that once the parent is disposed you can't really resolve things from the child (yes, I understand the parent would somehow stick around until the end of the last child, but the fact remains); we've definitely seen weird edge cases folks get themselves into by intentionally or unintentionally disposing the parent out from under the child and, depending on how it got hooked up and the order in which things happen, you can end up with really hard to troubleshoot exceptions involving ObjectDisposedException.

If you think about what you're trying to do outside of an Autofac context, it's kind of a bad design pattern to try to have the system dispose of itself, like having the child scope somehow responsible for the parent. For example, if you had some other parent/child relationship where you wanted to do this, more often you'd see some sort of external orchestrator that handles reference counts and disposal - outside the logical parent/child relationship.

I would recommend doing something like that instead - actually track the parent and child scopes with some nature of orchestrator class and have the orchestrator watch for all the child scopes to disappear.

Plus, it'll make other situations easier, like "I created the parent, I created one child, it got disposed and cleaned up the parent while I was trying to create a second child." Threading stuff. You'll be able to account for that in your orchestrator code.

You're calling .Image.FromUrl to the canvas instance not the fabric object.

Try

fabric.Image.fromUrl...

instead of

fabricCanvas.Image.fromURL

The problem is the order of initialization: Child object is initialized before makeObservable(this) is called, thus mother.name is not yet an observable when running in reaction. By moving the intialization of child object after calling makeObservable(this), I solved the problem.

Please refer to functional components migration guide and Vue 3 functional components documentation.

You should pass props and context as arguments to the functional component.

In Dart, you can use an object as if it is a method/function if the object implements the method call().

So d(); will execute the call() method defined in ReactionDisposer.

You can read about this in the Dart Langauge Tour: https://dart.dev/guides/language/language-tour#callable-classes

Indeed, the solution was to use an always-different database identifier on every test.

According to @Fabio's comment, I'd have to generate a database name every time the lambda expression services.AddDbContext(options => options.UseInMemoryDatabase(???)); is invoked, but this happens to be invoked often as the object has a prototype scope (yes, the article is about Spring for Java, but same principle applies).

In fact, in that case the guid is regenerated every time the DbContext is instantiated.

Solution? Generate a random id, but make it fixed for the whole duration of the test.

The correct place is inside the Test Factory class

What happens: you're iterating over the collection of Controls of a Form (or another class that inherits Control).

Each time you call Dispose() on one of its members, you actively remove it from the collection, so you're modifying the collection you're iterating over.

When you dispose of the first Control, this is removed from the collection and the next Control in the list takes its place.
Your loop calls Enumerator.MoveNext(), so when you call Dispose() again, you're disposing of the element at index 1, which was previously the element at index 2.
The element which was at index 1, now at index 0, is skipped.
This process goes on, the result is that you're disposing of half of the Controls in the collection.

You can test it with:

My IAsyncEnumerable function must run its cleanup code regardless of whether the enumerator it returns is disposed of correctly.

Full stop. You can't have any type run managed cleanup code regardless of whether it is disposed correctly. This is simply not possible in .NET.

You can write a finalizer, but finalizers cannot have arbitrary code. Usually they are restricted to accessing value type members and doing some p/Invoke-style calls. They cannot, say, return a buffer to an array pool. More generally, with few exceptions, they cannot call any managed code at all. They're really only intended to clean up unmanaged resources.

So this doesn't have anything to do with asynchronous enumerators. You can't guarantee cleanup code will be run if the object isn't disposed, and this is the case for any kind of object.

The best solution is to run the cleanup code when it is disposed (e.g., in a finally block in an async enumerator function). Any code that doesn't dispose that is responsible for creating the resource leak. This is the way all other .NET code works, and this is the way async enumerators work, too.