<p>I have a String which I would like to modify in some way. For example: reverse it or upcase it. </p>

<p>I have discovered that the fastest way to do this is by using a unsafe block and pointers. </p>

<p>For example: </p>

<pre><code>        unsafe 
        {
            fixed (char* str = text)
            {
                *str = 'X';
            }
        }
</code></pre>

<p>Are there any reasons why I should never ever do this? </p>

The .Net framework requires strings to be immutable. Due to this requirement it is able to optimise all sorts of operations.
String interning
is one great example of this requirement is leveraged heavily. To speed up some string comparisons (and reduce memory consumption) the .Net framework maintains a Dictionary of pointers, all pre-defined strings will live in this dictionary or any strings where you call the
```
String.intern
```
method on. When the IL instruction ldstr is called it will check the interned dictionary and avoid memory allocation if we already have the string allocated, note:
String.Concat
will not check for interned strings.
This property of the .net framework means that if you start mucking around directly with strings you can corrupt your intern table and in turn corrupt other references to the same string.
For example:
```
```
// these strings get interned
        string hello = "hello";
        string hello2 = "hello";

        string helloworld, helloworld2;

        helloworld = hello;
        helloworld += " world";

        helloworld2 = hello;
        helloworld2 += " world"; 

        unsafe
        {
            // very bad, this changes an interned string which affects 
            // all app domains.
            fixed (char* str = hello2)
            {
                *str = 'X';
            }

            fixed (char* str = helloworld2)
            {
                *str = 'X';
            }

        }

        Console.WriteLine("hello = {0} , hello2 = {1}", hello, hello2);
        // output: hello = Xello , hello2 = Xello  

        Console.WriteLine("helloworld = {0} , helloworld2 = {1}", helloworld, helloworld2);
        // output : helloworld = hello world , helloworld2 = Xello world
```
```