C # ist die Leistung des Bedieners

Ich habe ein Programm, das eine schnelle Leistung erfordert. Innerhalb einer seiner inneren Schleifen muss ich den Typ eines Objekts testen, um festzustellen, ob es von einer bestimmten Schnittstelle erbt.

Eine Möglichkeit hierfür wäre die integrierte Typprüfungsfunktion der CLR. Die eleganteste Methode ist wahrscheinlich das Schlüsselwort 'is':

if (obj is ISpecialType)

Ein anderer Ansatz wäre, der Basisklasse meine eigene virtuelle GetType () -Funktion zu geben, die einen vordefinierten Aufzählungswert zurückgibt (in meinem Fall brauche ich eigentlich nur einen Bool). Diese Methode wäre schnell, aber weniger elegant.

Ich habe gehört, dass es eine IL-Anweisung speziell für das Schlüsselwort 'is' gibt, aber das bedeutet nicht, dass sie schnell ausgeführt wird, wenn sie in eine native Assembly übersetzt wird. Kann jemand einen Einblick in die Leistung von 'is' im Vergleich zur anderen Methode geben?

UPDATE: Danke für all die informierten Antworten! Es scheint, dass einige hilfreiche Punkte in den Antworten verteilt sind: Andrews Punkt über das automatische Durchführen einer Besetzung ist wichtig, aber die von Binary Worrier und Ian gesammelten Leistungsdaten sind auch äußerst nützlich. Es wäre großartig, wenn eine der Antworten so bearbeitet würde, dass sie alle diese Informationen enthält.

Die Verwendung iskann die Leistung beeinträchtigen, wenn Sie nach Überprüfung des Typs auf diesen Typ umwandeln. isWirkt das Objekt tatsächlich in den Typ, den Sie überprüfen, sodass jede nachfolgende Umwandlung redundant ist.

Wenn Sie trotzdem besetzen wollen, ist hier ein besserer Ansatz:

ISpecialType t = obj as ISpecialType;

if (t != null)
{
    // use t here
}

Ich bin bei Ian , du willst das wahrscheinlich nicht.

Nur damit Sie wissen, gibt es kaum einen Unterschied zwischen den beiden, über 10.000.000 Iterationen

• Die Aufzählung erfolgt nach ca. 700 Millisekunden.
• Der IS-Check erfolgt nach ca. 1000 Millisekunden.

Ich persönlich würde dieses Problem nicht auf diese Weise beheben, aber wenn ich gezwungen wäre, eine Methode auszuwählen, wäre dies die integrierte IS-Prüfung. Der Leistungsunterschied ist es nicht wert, den Codierungsaufwand zu berücksichtigen.

Meine Basis- und abgeleiteten Klassen

class MyBaseClass
{
    public enum ClassTypeEnum { A, B }
    public ClassTypeEnum ClassType { get; protected set; }
}

class MyClassA : MyBaseClass
{
    public MyClassA()
    {
        ClassType = MyBaseClass.ClassTypeEnum.A;
    }
}
class MyClassB : MyBaseClass
{
    public MyClassB()
    {
        ClassType = MyBaseClass.ClassTypeEnum.B;
    }
}

JubJub: Wie gewünscht mehr Infos zu den Tests.

Ich habe beide Tests über eine Konsolen-App (ein Debug-Build) ausgeführt. Jeder Test sieht wie folgt aus

static void IsTest()
{
    DateTime start = DateTime.Now;
    for (int i = 0; i < 10000000; i++)
    {
        MyBaseClass a;
        if (i % 2 == 0)
            a = new MyClassA();
        else
            a = new MyClassB();
        bool b = a is MyClassB;
    }
    DateTime end = DateTime.Now;
    Console.WriteLine("Is test {0} miliseconds", (end - start).TotalMilliseconds);
}

Wenn ich im Release laufe, bekomme ich wie Ian einen Unterschied von 60 - 70 ms.

Weiteres Update - 25. Oktober 2012
Nach ein paar Jahren ist mir etwas daran aufgefallen. Der Compiler kann dies bool b = a is MyClassBin der Version weglassen , da b nirgendwo verwendet wird.

Dieser Code. . .

public static void IsTest()
{
    long total = 0;
    var a = new MyClassA();
    var b = new MyClassB();
    var sw = new Stopwatch();
    sw.Start();
    for (int i = 0; i < 10000000; i++)
    {
        MyBaseClass baseRef;
        if (i % 2 == 0)
            baseRef = a;//new MyClassA();
        else
            baseRef = b;// new MyClassB();
        //bool bo = baseRef is MyClassB;
        bool bo = baseRef.ClassType == MyBaseClass.ClassTypeEnum.B;
        if (bo) total += 1;
    }
    sw.Stop();
    Console.WriteLine("Is test {0} miliseconds {1}", sw.ElapsedMilliseconds, total);
}

. . . Zeigt konsistent an, dass der isCheck bei ca. 57 Millisekunden und der Enum-Vergleich bei 29 Millisekunden eingeht.

NB Ich würde den isScheck immer noch vorziehen , der Unterschied ist zu gering, um sich darum zu kümmern

Ok, also habe ich mich mit jemandem darüber unterhalten und beschlossen, dies mehr zu testen. Soweit ich das beurteilen kann, sind die Leistung von asund isbeide sehr gut, verglichen mit dem Testen Ihres eigenen Mitglieds oder Ihrer Funktion zum Speichern von Typinformationen.

Ich habe verwendet Stopwatch, was ich gerade gelernt habe, ist möglicherweise nicht der zuverlässigste Ansatz, also habe ich es auch versucht UtcNow. Später habe ich auch den Prozessorzeitansatz ausprobiert, der dem UtcNowEinschließen unvorhersehbarer Erstellungszeiten ähnelt . Ich habe auch versucht, die Basisklasse ohne Virtuals nicht abstrakt zu machen, aber es schien keinen signifikanten Effekt zu haben.

Ich habe dies auf einem Quad Q6600 mit 16 GB RAM ausgeführt. Selbst bei 50-mil-Iterationen schwanken die Zahlen immer noch um +/- 50 Millisekunden, sodass ich nicht zu viel in die kleinen Unterschiede hineinlesen würde.

Es war interessant zu sehen, dass x64 schneller erstellt, aber langsamer ausgeführt wird als x86

x64-Freigabemodus:
Stoppuhr:
As: 561 ms
Is: 597
ms Basiseigenschaft : 539 ms Basisfeld : 555
ms
Basis-RO-Feld: 552 ms
Virtual GetEnumType () -Test: 556 ms
Virtual IsB () -Test: 588 ms
Erstellungszeit: 10416 ms

UtcNow:
As: 499 ms
Is: 532 ms
Base-Eigenschaft: 479 ms
Base-Feld: 502 ms
Base-RO-Feld: 491 ms
Virtual GetEnumType (): 502 ms
Virtual bool IsB (): 522 ms
Erstellungszeit: 285 ms (Diese Zahl scheint mit UtcNow unzuverlässig zu sein. Ich erhalte auch 109 ms und 806 ms.)

x86-Freigabemodus:
Stoppuhr:
As: 391 ms
Is: 423
ms Basiseigenschaft : 369 ms Basisfeld : 321
ms
Basis-RO-Feld: 339 ms
Virtual GetEnumType () -Test: 361 ms
Virtual IsB () -Test: 365 ms
Erstellungszeit: 14106 ms

UtcNow:
As: 348ms
Is: 375ms
Base-Eigenschaft: 329ms
Base-Feld: 286 ms
Base-RO-Feld: 309 ms
Virtual GetEnumType (): 321 ms
Virtual bool IsB (): 332 ms
Erstellungszeit: 544 ms (Diese Zahl scheint mit UtcNow unzuverlässig zu sein.)

Hier ist der größte Teil des Codes:

    static readonly int iterations = 50000000;
    void IsTest()
    {
        Process.GetCurrentProcess().ProcessorAffinity = (IntPtr)1;
        MyBaseClass[] bases = new MyBaseClass[iterations];
        bool[] results1 = new bool[iterations];

        Stopwatch createTime = new Stopwatch();
        createTime.Start();
        DateTime createStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            if (i % 2 == 0) bases[i] = new MyClassA();
            else bases[i] = new MyClassB();
        }
        DateTime createStop = DateTime.UtcNow;
        createTime.Stop();


        Stopwatch isTimer = new Stopwatch();
        isTimer.Start();
        DateTime isStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] =  bases[i] is MyClassB;
        }
        DateTime isStop = DateTime.UtcNow; 
        isTimer.Stop();
        CheckResults(ref  results1);

        Stopwatch asTimer = new Stopwatch();
        asTimer.Start();
        DateTime asStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] = bases[i] as MyClassB != null;
        }
        DateTime asStop = DateTime.UtcNow; 
        asTimer.Stop();
        CheckResults(ref  results1);

        Stopwatch baseMemberTime = new Stopwatch();
        baseMemberTime.Start();
        DateTime baseStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] = bases[i].ClassType == MyBaseClass.ClassTypeEnum.B;
        }
        DateTime baseStop = DateTime.UtcNow;
        baseMemberTime.Stop();
        CheckResults(ref  results1);

        Stopwatch baseFieldTime = new Stopwatch();
        baseFieldTime.Start();
        DateTime baseFieldStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] = bases[i].ClassTypeField == MyBaseClass.ClassTypeEnum.B;
        }
        DateTime baseFieldStop = DateTime.UtcNow;
        baseFieldTime.Stop();
        CheckResults(ref  results1);


        Stopwatch baseROFieldTime = new Stopwatch();
        baseROFieldTime.Start();
        DateTime baseROFieldStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] = bases[i].ClassTypeField == MyBaseClass.ClassTypeEnum.B;
        }
        DateTime baseROFieldStop = DateTime.UtcNow;
        baseROFieldTime.Stop();
        CheckResults(ref  results1);

        Stopwatch virtMethTime = new Stopwatch();
        virtMethTime.Start();
        DateTime virtStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] = bases[i].GetClassType() == MyBaseClass.ClassTypeEnum.B;
        }
        DateTime virtStop = DateTime.UtcNow;
        virtMethTime.Stop();
        CheckResults(ref  results1);

        Stopwatch virtMethBoolTime = new Stopwatch();
        virtMethBoolTime.Start();
        DateTime virtBoolStart = DateTime.UtcNow;
        for (int i = 0; i < iterations; i++)
        {
            results1[i] = bases[i].IsB();
        }
        DateTime virtBoolStop = DateTime.UtcNow;
        virtMethBoolTime.Stop();
        CheckResults(ref  results1);


        asdf.Text +=
        "Stopwatch: " + Environment.NewLine 
          +   "As:  " + asTimer.ElapsedMilliseconds + "ms" + Environment.NewLine
           +"Is:  " + isTimer.ElapsedMilliseconds + "ms" + Environment.NewLine
           + "Base property:  " + baseMemberTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Base field:  " + baseFieldTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Base RO field:  " + baseROFieldTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Virtual GetEnumType() test:  " + virtMethTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Virtual IsB() test:  " + virtMethBoolTime.ElapsedMilliseconds + "ms" + Environment.NewLine + "Create Time :  " + createTime.ElapsedMilliseconds + "ms" + Environment.NewLine + Environment.NewLine+"UtcNow: " + Environment.NewLine + "As:  " + (asStop - asStart).Milliseconds + "ms" + Environment.NewLine + "Is:  " + (isStop - isStart).Milliseconds + "ms" + Environment.NewLine + "Base property:  " + (baseStop - baseStart).Milliseconds + "ms" + Environment.NewLine + "Base field:  " + (baseFieldStop - baseFieldStart).Milliseconds + "ms" + Environment.NewLine + "Base RO field:  " + (baseROFieldStop - baseROFieldStart).Milliseconds + "ms" + Environment.NewLine + "Virtual GetEnumType():  " + (virtStop - virtStart).Milliseconds + "ms" + Environment.NewLine + "Virtual bool IsB():  " + (virtBoolStop - virtBoolStart).Milliseconds + "ms" + Environment.NewLine + "Create Time :  " + (createStop-createStart).Milliseconds + "ms" + Environment.NewLine;
    }
}

abstract class MyBaseClass
{
    public enum ClassTypeEnum { A, B }
    public ClassTypeEnum ClassType { get; protected set; }
    public ClassTypeEnum ClassTypeField;
    public readonly ClassTypeEnum ClassTypeReadonlyField;
    public abstract ClassTypeEnum GetClassType();
    public abstract bool IsB();
    protected MyBaseClass(ClassTypeEnum kind)
    {
        ClassTypeReadonlyField = kind;
    }
}

class MyClassA : MyBaseClass
{
    public override bool IsB() { return false; }
    public override ClassTypeEnum GetClassType() { return ClassTypeEnum.A; }
    public MyClassA() : base(MyBaseClass.ClassTypeEnum.A)
    {
        ClassType = MyBaseClass.ClassTypeEnum.A;
        ClassTypeField = MyBaseClass.ClassTypeEnum.A;            
    }
}
class MyClassB : MyBaseClass
{
    public override bool IsB() { return true; }
    public override ClassTypeEnum GetClassType() { return ClassTypeEnum.B; }
    public MyClassB() : base(MyBaseClass.ClassTypeEnum.B)
    {
        ClassType = MyBaseClass.ClassTypeEnum.B;
        ClassTypeField = MyBaseClass.ClassTypeEnum.B;
    }
}

Andrew ist richtig. Bei der Codeanalyse wird dies von Visual Studio als unnötige Besetzung gemeldet.

Eine Idee (ohne zu wissen, was Sie tun, ist ein Schuss in die Dunkelheit), aber mir wurde immer geraten, solche Überprüfungen zu vermeiden und stattdessen eine andere Klasse zu haben. Lassen Sie die Klasse also wissen, wie sie sich selbst verarbeitet, anstatt einige Überprüfungen durchzuführen und je nach Typ unterschiedliche Aktionen auszuführen ...

zB Obj kann ISpecialType oder IType sein;

Für beide ist eine DoStuff () -Methode definiert. Für IType kann es einfach zurückgeben oder benutzerdefinierte Aufgaben ausführen, während ISpecialType andere Aufgaben ausführen kann.

Dadurch wird jegliches Casting vollständig entfernt, der Code wird sauberer und einfacher zu warten, und die Klasse weiß, wie sie ihre eigenen Aufgaben erledigt.

Ich habe einen Leistungsvergleich über zwei Möglichkeiten des Typvergleichs durchgeführt

1. myobject.GetType () == typeof (MyClass)
2. Mein Objekt ist MyClass

Das Ergebnis ist: Die Verwendung von "is" ist ungefähr 10x schneller !!!

Ausgabe:

Zeit für den Typvergleich: 00: 00: 00.456

Zeit für den Is-Vergleich: 00: 00: 00.042

Mein Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

namespace ConsoleApplication3
{
    class MyClass
    {
        double foo = 1.23;
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyClass myobj = new MyClass();
            int n = 10000000;

            Stopwatch sw = Stopwatch.StartNew();

            for (int i = 0; i < n; i++)
            {
                bool b = myobj.GetType() == typeof(MyClass);
            }

            sw.Stop();
            Console.WriteLine("Time for Type-Comparison: " + GetElapsedString(sw));

            sw = Stopwatch.StartNew();

            for (int i = 0; i < n; i++)
            {
                bool b = myobj is MyClass;
            }

            sw.Stop();
            Console.WriteLine("Time for Is-Comparison: " + GetElapsedString(sw));
        }

        public static string GetElapsedString(Stopwatch sw)
        {
            TimeSpan ts = sw.Elapsed;
            return String.Format("{0:00}:{1:00}:{2:00}.{3:000}", ts.Hours, ts.Minutes, ts.Seconds, ts.Milliseconds);
        }
    }
}

Punkt Andrew Hare machte über Leistungsverluste, wenn Sie eine isPrüfung durchführen und dann die Besetzung gültig war, aber in C # 7.0 können wir die Übereinstimmung der Hexenmuster überprüfen, um später eine zusätzliche Besetzung zu vermeiden:

if (obj is ISpecialType st)
{
   //st is in scope here and can be used
}

Wenn Sie zwischen mehreren Typen prüfen müssen, können Sie mit C # 7.0-Mustervergleichskonstrukten jetzt folgende switchTypen ausführen:

public static double ComputeAreaModernSwitch(object shape)
{
    switch (shape)
    {
        case Square s:
            return s.Side * s.Side;
        case Circle c:
            return c.Radius * c.Radius * Math.PI;
        case Rectangle r:
            return r.Height * r.Length;
        default:
            throw new ArgumentException(
                message: "shape is not a recognized shape",
                paramName: nameof(shape));
    }
}

Weitere Informationen zum Mustervergleich in C # finden Sie in der Dokumentation hier .

Für den Fall, dass sich jemand wundert, habe ich Tests in Unity Engine 2017.1 mit der Skript-Laufzeitversion .NET4.6 (Experimantal) auf einem Notebook mit i5-4200U-CPU durchgeführt. Ergebnisse:

Average Relative To Local Call LocalCall 117.33 1.00 is 241.67 2.06 Enum 139.33 1.19 VCall 294.33 2.51 GetType 276.00 2.35

Vollständiger Artikel: http://www.ennoble-studios.com/tuts/unity-c-performance-comparison-is-vs-enum-vs-virtual-call.html

Mir wurde immer geraten, solche Überprüfungen zu vermeiden und stattdessen eine andere Klasse zu haben. Lassen Sie die Klasse also wissen, wie sie sich selbst verarbeitet, anstatt einige Überprüfungen durchzuführen und je nach Typ unterschiedliche Aktionen auszuführen ...

zB Obj kann ISpecialType oder IType sein;

Für beide ist eine DoStuff () -Methode definiert. Für IType kann es einfach zurückgeben oder benutzerdefinierte Aufgaben ausführen, während ISpecialType andere Aufgaben ausführen kann.

Dadurch wird jegliches Casting vollständig entfernt, der Code wird sauberer und einfacher zu warten, und die Klasse weiß, wie sie ihre eigenen Aufgaben erledigt.