referencesource | NET Reference Source that represent a subset of the .NET | Database library

Look in the dotnet/runtime repo on GitHub:

You'll find the implementation of the String class there: https://github.com/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/String.cs

Probably that is a performance issue. Access to local variables is slightly faster than access to instance variables. And - as List is probably one of the most used classes in the CLR - having good performance matters.

Local variables can directly be read from stack or maybe a register, while instance variables read the address of the object, and then get the value relative to that.

You're mixing up two things that are working together:

On one site, there is the Serializable attribute and its methods. This contains also the two methods GetSerializableMembers() to describe the structure and GetObjectData() to get the concrete values of a living instance that should be serialized. Regardless of the used writer (aka formatter) you'll always need a tree of key value pairs holding the property name as key and its content as value (which could be another object of key value pairs).

The next one comes into play is (in your case) the binary formatter. It consumes this structure and picks whatever it likes to, to write the information into some kind of stream. This special implementation of a fomatter is tried for being optimized for needed size within stream. This will be achieved by omitting the keys and only writing the value and assuming the reader knows the exact structure and writes the values onto the correct properties.

That's the reason, why this formatter shouldn't be used. Instead use some kind of serialization that also contains the structure like XML or JSON. These add also the keys to the stream and making it easier to deserialize the data even if the destination structure doesn't fully match.

For the first question I don't have any answer, maybe it just an relic from some previous implementation, maybe it somehow improves performance (though I would wonder how and why, so my bet is on the first guess). Also in the Core implementation list field is marked as readonly.

As for the second one - it has nothing to do with Reset, but with System.Collections.IEnumerator.Current implementation:

The Invoke will block current thread and main thread.

And BeginInvoke only block main thread.

you can try in wpf

MainWindow.xaml

You can see that List uses explicit interface method implementation (explicitly specify the interface's name) to implement the non-generic Contains

Indeed.

But that's because the IList interface (not IList) is decades-old - from the primitive, dark, times before .NET had support for generics (.NET 1.0 came out in 2001 - generics weren't added until the .NET Framework 2.0 in 2005). It was a truly godforsaken time.

List (but not IList) implements the IList interface so that the new generic List could be consumed by older code that accepted an IList (in a way that allows preserving object identity and without requiring allocating a separate IList instance).

Supposing it's 2005 and you're writing some wonderous C# 2.0 code that uses the fancy new reified generics and List - but you need to interact with a library that was last updated in 2004:

It looks like Json.NET got a new VersionConverter in .NET Core 2.2, which knows how to properly serialize and deserialize Version instances. This automatically gets picked up and used when you're using .NET Core 2.2+.

Using VersionConverter, Json.NET wants to serialize your Version objects to strings like "1.0", rather than to JSON objects. If you create the json string in your post by serializing a new instance of Versioned on .NET Core 2.2+:

As you have found yourself, null sender breaks WeakEventManager into thinking that this is a static event, which basically makes it incompatible with LayoutUpdated. Since WeakEventManager.DeliverEvent is non-virtual, you cannot really "fix" it.

So I think your option would be to use a third-party weak event manager, or write one yourself, which shouldn't be that difficult (unless you need a generic solution).

The idea is to break a hard reference between the event source (UIElement) and the event subscriber (Delegate.Target), which may be achieved by using a mediator class with weak references to the event handler and its target.

Here is a quick-and-dirty example that would work with events of type EventHandler:

Alright, thanks to Darius I was able to figure out a work around! I cut down the Fragment to its basics and instead of the FrameLayout, used an MvxFrameControl and it worked. So this is what my Fragment looks like: