Der schnellste Weg, um das erste Zeichen in einem String zu entfernen

Angenommen, wir haben die folgende Zeichenfolge

string data= "/temp string";

Wenn wir das erste Zeichen entfernen möchten, /können wir dies auf viele Arten tun:

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

Aber wirklich, ich weiß nicht, welcher den besten Algorithmus hat und das schneller macht.
Gibt es einen, der der beste ist oder alle gleich sind?

Die zweite Option ist wirklich nicht die gleiche wie die anderen - wenn die Zeichenfolge "/// foo" ist, wird sie zu "foo" anstelle von "// foo".

Die erste Option erfordert etwas mehr Arbeit als die dritte - ich würde die SubstringOption als die häufigste und lesbarste betrachten.

(Offensichtlich wird jede von ihnen als einzelne Anweisung nichts Nützliches bewirken - Sie müssen das Ergebnis einer Variablen zuweisen, möglicherweise dataselbst.)

Ich würde die Leistung hier nicht berücksichtigen, es sei denn, dies würde tatsächlich zu einem Problem für Sie werden. In diesem Fall würden Sie nur Testfälle haben, und dann ist es einfach, diese Testfälle für jede Option und auszuführen Vergleichen Sie die Ergebnisse. Ich würde erwarten Substring, hier wahrscheinlich der Schnellste zu sein, einfach weil Substringimmer eine Zeichenfolge aus einem einzelnen Block der ursprünglichen Eingabe erstellt wird, während Removezumindest potenziell ein Startblock und ein Endblock zusammengeklebt werden müssen.

Ich weiß, dass dies ein Land der Hyperoptimierung ist, aber es schien eine gute Ausrede zu sein, die Räder zu treten BenchmarkDotNet. Das Ergebnis dieses Tests (sogar unter .NET Core) ist, Substringdass er etwas schneller ist als Removein diesem Beispieltest: 19,37 ns gegenüber 22,52 ns für Remove. Also ca. 16% schneller.

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>();
        }
    }
}

Ergebnisse:

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 |

Ich würde das erraten Removeund Substringwürde den ersten Platz belegen, da beide einen Teil der Zeichenfolge mit fester Größe schlürfen, während TrimStartein Scan von links mit einem Test für jedes Zeichen durchgeführt wird und dann genau die gleiche Arbeit wie die ausführen muss andere zwei Methoden. Im Ernst, das spaltet die Haare.

Sie könnten es profilieren, wenn Sie sich wirklich darum kümmern. Schreiben Sie eine Schleife mit vielen Iterationen und sehen Sie, was passiert. Es besteht jedoch die Möglichkeit, dass dies nicht der Engpass in Ihrer Anwendung ist und TrimStart semantisch korrekt erscheint. Versuchen Sie, den Code vor der Optimierung lesbar zu schreiben.