How can it possibly go wrong to mutate a string

[Xyncgas]

I have a string, I have a memory marshal, MemoryMarshal.CreateSpan(&MemoryMarshal.GetReference<'T>(readonlysp), readonlysp.Length), I can now mutate string.AsSpan

[Xyncgas]

The scenario would be useful because I am encrypting the string, I don't care about length for now just for the sake of protecting the planet we need to reuse as much memory as possible so lets mutate the string and write our encrypted text inside without allocating a new memory region for it.

I can do the encryption again and again and again, without seeing allocation in gen0

Maybe we should let FastAllocateString be public

I am hearing

That's what string.Create exists for

Seems uninclusive to people from c
There's an saying for meta programming in C/C++
"if you don't use it, it should cost nothing, if you do use it pay for what you use", alternatives like string.Create is just not as free as FastAllocateString

[huoyaoyuan]

I am encrypting the string, I don't care about length for now just for the sake of protecting the planet we need to reuse as much memory as possible

Don't do that for anything on normal GC heap, including an ordinal array. GC can move it around at any time, and potentially leave the old content at old address.

[DaZombieKiller]

Mutating a string instance invokes undefined behavior, the runtime offers you no guarantees if you do this. Your process could crash, you could corrupt the GC heap, you could get an access violation (for strings stored in read-only memory).

Maybe we should let FastAllocateString be public

That's what string.Create<TState> exists for. You can see another recent discussion about this here.

[Xyncgas]

It should be alright if I simply mutate the string without going outside of the memory of the string right

[stephentoub]

No. For example, the runtime could choose to create the string in memory that's then marked readonly. It could choose to intern the string such that other strings initially created with the same value all point to the same memory and mutating one is mutating them all. It could choose to dedup strings on the heap and rewrite references to them accordingly. Etc.

[Xyncgas]

Thanks for teaching new things everyday to help people @stephentoub
Meanwhile if I create a stack allocated span in F# to mutate it however I like, later converting the Span'byte to ReadOnlySpan'char via dark magic, now calling ToString() should give me back a string created from ReadOnlySpan'char, still it was stack allocated memory and I was able to mutate it, so how is the string going to stick around in the long run and can I now mutating this string in the future by casting it to Span again knowing I am mutating the memory I allocated instead of some 'unknown' dotnet internal memory that's sacred

[stephentoub]

The stackalloc'd data isn't a System.String. You can mutate it however you like. The result of calling ToString is a new immutable System.String, which you should not attempt to mutate; any attempts to get a mutable span from that String are unsafe.

[ufcpp]

https://sharplab.io/#v2:C4LgTgrgdgPgAgJgIwFgBQcAMACOSB0AStMAJYC2ApvgMID25ADqQDaVgDK7AbqQMaUAzgG506AGZ0w2ABTcAhtNLYAvNkzDsygDzYkG7AGpDpAJToA3umw3cSAJwyzotAF8xGBNgCCl67YBtAFk6ABMINgBJKFIyeRZSAC92AF1/GzgAZjsANlwAFmxo2JlzNFtsK3KK20lpOUUtVXVNHT0DYzN0mqqavuxoQXlxSm7+yrHx2tIAD0pQ2T4AC0UAKmxGZtJ8ABU6DmAwUigAc1Kyqf7ey6nVzbUAcgB1h5cbmvdqy8/xn9tPz7oIA==