Il modo più veloce per rimuovere il primo carattere in una stringa

Supponiamo di avere la seguente stringa

string data= "/temp string";

Se vogliamo rimuovere il primo personaggio /possiamo farlo in molti modi come:

data.Remove(0,1);
data.TrimStart('/');
data.Substring(1);

Ma davvero non so quale abbia l'algoritmo migliore e lo faccia più velocemente.
Ce n'è uno che è il migliore o tutti sono uguali?

La seconda opzione in realtà non è la stessa delle altre: se la stringa è "/// pippo" diventerà "pippo" anziché "// pippo".

La prima opzione ha bisogno di un po 'più di lavoro per capire rispetto alla terza: vedrei l' Substringopzione come la più comune e leggibile.

(Ovviamente ciascuno di essi come singola istruzione non farà nulla di utile - dovrai assegnare il risultato a una variabile, possibilmente datastessa.)

Non prenderei in considerazione le prestazioni qui a meno che non stia effettivamente diventando un problema per te - nel qual caso l'unico modo che sapresti sarebbe avere casi di test, quindi è facile eseguire quei casi di test per ogni opzione e confrontare i risultati. Mi aspetterei Substringprobabilmente di essere il più veloce qui, semplicemente perché Substringfinisce sempre per creare una stringa da un singolo blocco dell'input originale, mentre Removedeve almeno potenzialmente incollare insieme un blocco iniziale e un blocco finale.

So che questa è terra di iper-ottimizzazione, ma mi è sembrata una buona scusa per calciare le ruote BenchmarkDotNet. Il risultato di questo test (anche su .NET Core) è Substringleggermente più veloce di Remove, in questo test di esempio: 19.37ns contro 22.52ns per Remove. Quindi circa il 16% più veloce.

using System;
using BenchmarkDotNet.Attributes;

namespace BenchmarkFun
{
    public class StringSubstringVsRemove
    {
        public readonly string SampleString = " My name is Daffy Duck.";

        [Benchmark]
        public string StringSubstring() => SampleString.Substring(1);

        [Benchmark]
        public string StringRemove() => SampleString.Remove(0, 1);

        public void AssertTestIsValid()
        {
            string subsRes = StringSubstring();
            string remvRes = StringRemove();

            if (subsRes == null
                || subsRes.Length != SampleString.Length - 1
                || subsRes != remvRes) {
                throw new Exception("INVALID TEST!");
            }
        }
    }

    class Program
    {
        static void Main()
        {
            // let's make sure test results are really equal / valid
            new StringSubstringVsRemove().AssertTestIsValid();

            var summary = BenchmarkRunner.Run<StringSubstringVsRemove>();
        }
    }
}

risultati:

BenchmarkDotNet=v0.11.4, OS=Windows 10.0.17763.253 (1809/October2018Update/Redstone5)
Intel Core i7-6700HQ CPU 2.60GHz (Skylake), 1 CPU, 8 logical and 4 physical cores
.NET Core SDK=3.0.100-preview-010184
  [Host]     : .NET Core 3.0.0-preview-27324-5 (CoreCLR 4.6.27322.0, CoreFX 4.7.19.7311), 64bit RyuJIT
  DefaultJob : .NET Core 3.0.0-preview-27324-5 (CoreCLR 4.6.27322.0, CoreFX 4.7.19.7311), 64bit RyuJIT

|          Method |     Mean |     Error |    StdDev |
|---------------- |---------:|----------:|----------:|
| StringSubstring | 19.37 ns | 0.3940 ns | 0.3493 ns |
|    StringRemove | 22.52 ns | 0.4062 ns | 0.3601 ns |

Immagino questo Removee Substringlegherei per il primo posto, dal momento che entrambi assorbono una porzione della stringa di dimensioni fisse, mentre TrimStartesegue una scansione da sinistra con un test su ciascun personaggio e quindi deve eseguire esattamente lo stesso lavoro del altri due metodi. Seriamente, però, questo sta spaccando i capelli.

Potresti profilarlo, se davvero ti interessasse. Scrivi un ciclo di molte iterazioni e guarda cosa succede. È possibile, tuttavia, che questo non sia il collo di bottiglia nell'applicazione e TrimStart sembra il più semanticamente corretto. Cerca di scrivere facilmente il codice prima di ottimizzare.