Also ich freue mich aufdiese Frag und der allgemeine Konsens ist, dass die Uint-Cast-Version effizienter ist als die Bereichsüberprüfung mit 0. Da der Code auch in der MS-Implementierung von List enthalten ist, gehe ich davon aus, dass es sich um eine echte Optimierung handelt. Es ist mir jedoch nicht gelungen, ein Codebeispiel zu erstellen, das zu einer besseren Leistung für die uint-Version führt. Ich habe verschiedene Tests ausprobiert und es fehlt etwas oder ein anderer Teil meines Codes lässt die Zeit für die Überprüfungen in den Schatten stellen. Mein letzter Versuch sieht so aus:

class TestType
{
    public TestType(int size)
    {
        MaxSize = size;
        Random rand = new Random(100);
        for (int i = 0; i < MaxIterations; i++)
        {
            indexes[i] = rand.Next(0, MaxSize);
        }
    }

    public const int MaxIterations = 10000000;
    private int MaxSize;
    private int[] indexes = new int[MaxIterations];

    public void Test()
    {
        var timer = new Stopwatch();

        int inRange = 0;
        int outOfRange = 0;

        timer.Start();
        for (int i = 0; i < MaxIterations; i++)
        {
            int x = indexes[i];
            if (x < 0 || x > MaxSize)
            {
                throw new Exception();

            }

            inRange += indexes[x];
        }
        timer.Stop();

        Console.WriteLine("Comparision 1: " + inRange + "/" + outOfRange + ", elapsed: " + timer.ElapsedMilliseconds + "ms");

        inRange = 0;
        outOfRange = 0;

        timer.Reset();
        timer.Start();

        for (int i = 0; i < MaxIterations; i++)
        {
            int x = indexes[i];
            if ((uint)x > (uint)MaxSize)
            {
                throw new Exception();
            }

            inRange += indexes[x];
        }

        timer.Stop();

        Console.WriteLine("Comparision 2: " + inRange + "/" + outOfRange + ", elapsed: " + timer.ElapsedMilliseconds + "ms");

    }
}

class Program
{
    static void Main()
    {
        TestType t = new TestType(TestType.MaxIterations);
        t.Test();
        TestType t2 = new TestType(TestType.MaxIterations);
        t2.Test();
        TestType t3 = new TestType(TestType.MaxIterations);
        t3.Test();
    }
}

Der Code ist ein bisschen chaotisch, weil ich viele Dinge versucht habe, um uint check schneller zu machen, wie das Verschieben der verglichenen Variablen in ein Feld einer Klasse, das Erzeugen eines zufälligen Indexzugriffs usw., aber in jedem Fall scheint das Ergebnis das gleiche zu sein für beide Versionen. Ist diese Änderung auf moderne x86-Prozessoren anwendbar und kann jemand sie irgendwie demonstrieren?

Bitte beachten Sie, dass ich nicht nach jemandem frage, der meine Probe repariert oder erklärt, was daran falsch ist. Ich möchte nur den Fall sehen, in dem die Optimierung funktioniert.