The memory model is specific to the runtime, so your question is in fact “are there any differences in the memory models of CLR, CoreCLR and MonoRuntime”.
After researching a bit, I found that the question is really, really difficult to answer. There is the ECMA specification that you have mentioned, which gives you the bare minimum guarantees that all implementations must provide. There’s a very nice, concise description on Joe Duffy’s blog for CLR 2.0. Then, for .NET Framework there is this two part article that speaks about the CLR model in probably more details than it’s healthy to know about. There’s even a paper written on that.
For MonoRuntime, I’ve found this doc that talks about atomics and actually describes the way Mono implements this, though the level of detail is rather low.
Finding details of CoreCLR is even trickier. There are some keypoints highlighted in this dotnet/coreclr GitHub thread and a discussion about volatile read/writes in this one.
The simplest way to answer is – yes, it has changed, based on the above resources.
However, there is a second way of answering your question and that is to simply deny its premise – it seems to assume that the memory model changed in the sense that some smart people sat down, rewrote the ECMA CLI spec, made that into the CoreCLR memory-model spec and that’s the new memory-model. That is not the case. The mentioned smart people sat down and, over the course of many months, refined the design to be reliable, fast, sensibly easy to implement and not in violation of the minimum guarantees of the spec. Citing from the linked Joe Duffy’s blog:
We have constructed our model over years of informal work and design-by-example (…) this is apt to change from one implementation to the next.
The informal ECMA specification is, unfortunatelly, as formal as we get for now. There is no formal description of changes between the ECMA spec and the CLR implementation, nor is there a formal description of changes between CLR and CoreCLR. And, more importantly, the implementation specific differences between the ECMA CLI and CLR/CoreCLR are just that – implementation specific – and must not be relied upon. The only 100% reliable source of how the .NET Core memory model is implemented is the source code. And that obviously changes with every commit, every release, and there is no guarantee that the team won’t throw the entire jitter out the window and rewrite it for .NET 5 to be exact same as the ECMA spec (however wildly unlikely that is).