C # 'adalah' kinerja operator

Saya memiliki program yang membutuhkan kinerja cepat. Dalam salah satu loop dalamnya, saya perlu menguji jenis objek untuk melihat apakah itu mewarisi dari antarmuka tertentu.

Salah satu cara untuk melakukannya adalah dengan fungsionalitas pemeriksaan tipe built-in CLR. Metode paling elegan yang mungkin ada adalah kata kunci 'is':

if (obj is ISpecialType)

Pendekatan lain adalah memberikan kelas dasar fungsi GetType () virtual saya sendiri yang mengembalikan nilai enum yang telah ditentukan sebelumnya (dalam kasus saya, sebenarnya, saya hanya perlu bool). Metode itu akan cepat, tetapi kurang elegan.

Saya telah mendengar bahwa ada instruksi IL khusus untuk kata kunci 'is', tetapi itu tidak berarti itu dijalankan dengan cepat ketika diterjemahkan ke dalam perakitan asli. Adakah yang bisa berbagi beberapa wawasan tentang kinerja 'adalah' versus metode lainnya?

UPDATE: Terima kasih atas semua jawaban yang diinformasikan! Tampaknya beberapa poin berguna tersebar di antara jawaban: Poin Andrew tentang 'adalah' secara otomatis melakukan pemeran itu penting, tetapi data kinerja yang dikumpulkan oleh Binary Worrier dan Ian juga sangat berguna. Alangkah baiknya jika salah satu jawaban diedit untuk menyertakan semua informasi ini.

Penggunaan isdapat mengganggu kinerja jika, setelah Anda memeriksa jenisnya, Anda mentransmisikan ke jenis itu. issebenarnya mentransmisikan objek ke jenis yang Anda periksa sehingga setiap pengecoran berikutnya berlebihan.

Jika Anda tetap akan melakukan cast, berikut ini pendekatan yang lebih baik:

ISpecialType t = obj as ISpecialType;

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

Saya dengan Ian , Anda mungkin tidak ingin melakukan ini.

Namun, asal tahu saja, ada sangat sedikit perbedaan antara keduanya, lebih dari 10.000.000 iterasi

• Pemeriksaan enum masuk pada 700 milidetik (perkiraan)
• Pemeriksaan IS masuk pada 1000 milidetik (perkiraan)

Saya pribadi tidak akan memperbaiki masalah ini dengan cara ini, tetapi jika saya terpaksa memilih satu metode, itu akan menjadi pemeriksaan IS bawaan, perbedaan kinerja tidak layak mempertimbangkan overhead pengkodean.

Kelas dasar dan turunan saya

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: Seperti yang diminta info lebih lanjut tentang tes.

Saya menjalankan kedua pengujian dari aplikasi konsol (build debug) setiap pengujian terlihat seperti berikut

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

Berjalan dalam rilis, saya mendapatkan perbedaan 60 - 70 ms, seperti Ian.

Pembaruan Lebih Lanjut - 25 Oktober 2012
Setelah beberapa tahun saya melihat sesuatu tentang ini, kompilator dapat memilih untuk menghilangkan bool b = a is MyClassBdalam rilis karena b tidak digunakan dimanapun.

Kode ini. . .

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

. . . secara konsisten menunjukkanis cek masuk pada kira-kira 57 milidetik, dan perbandingan enum masuk pada 29 milidetik.

NB Saya masih lebih suka iscek, perbedaannya terlalu kecil untuk diperhatikan

Oke, jadi saya mengobrol tentang ini dengan seseorang dan memutuskan untuk menguji ini lebih lanjut. Sejauh yang saya tahu, kinerja asdan iskeduanya sangat baik, dibandingkan dengan menguji anggota Anda sendiri atau fungsi untuk menyimpan informasi tipe.

Saya menggunakan Stopwatch, yang baru saja saya pelajari mungkin bukan pendekatan yang paling dapat diandalkan, jadi saya juga mencoba UtcNow. Kemudian, saya juga mencoba pendekatan waktu Prosesor yang tampaknya mirip dengan UtcNowmenyertakan waktu pembuatan yang tidak dapat diprediksi. Saya juga mencoba membuat kelas dasar non-abstrak tanpa virtual tetapi tampaknya tidak memiliki efek yang signifikan.

Saya menjalankan ini pada Quad Q6600 dengan RAM 16GB. Bahkan dengan iterasi 50mil, angkanya masih memantul sekitar +/- 50 atau lebih milidetik jadi saya tidak akan terlalu banyak membaca perbedaan kecil.

Menarik untuk melihat bahwa x64 dibuat lebih cepat tetapi dieksekusi karena / lebih lambat dari x86

Mode Rilis x64:
Stopwatch:
As: 561ms
Is: 597ms
Properti dasar: 539ms
Bidang dasar: 555ms
Bidang RO Basis: 552ms Tes
Virtual GetEnumType (): 556ms Tes
Virtual IsB (): 588ms
Buat Waktu: 10416ms

UtcNow:
As: 499ms
Is: 532ms
Properti dasar: 479ms
Bidang dasar: 502ms
Bidang RO dasar: 491ms
Virtual GetEnumType (): 502ms
Virtual bool IsB (): 522ms
Buat Waktu: 285ms (Angka ini tampaknya tidak dapat diandalkan dengan UtcNow. Saya juga mendapatkan 109ms dan 806ms.)

Mode Rilis x86:
Stopwatch:
As: 391ms
Is: 423ms
Properti dasar: 369ms
Bidang dasar: 321ms
Bidang RO Basis: 339ms Tes
Virtual GetEnumType (): 361ms Tes
Virtual IsB (): 365ms
Buat Waktu: 14106ms

UtcNow:
As: 348ms
Is: 375ms
Properti dasar: 329ms
Bidang dasar: 286ms
Bidang RO dasar: 309ms
Virtual GetEnumType (): 321ms
Virtual bool IsB (): 332ms
Buat Waktu: 544ms (Angka ini tampaknya tidak dapat diandalkan dengan UtcNow.)

Inilah sebagian besar kodenya:

    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 benar. Faktanya dengan analisis kode ini dilaporkan oleh Visual Studio sebagai pemeran yang tidak perlu.

Satu gagasan (tanpa mengetahui apa yang Anda lakukan adalah sedikit bidikan dalam kegelapan), tetapi saya selalu disarankan untuk menghindari pemeriksaan seperti ini, dan sebaliknya memiliki kelas lain. Jadi, daripada melakukan beberapa pemeriksaan dan melakukan tindakan yang berbeda tergantung pada jenisnya, buat kelas tahu cara memprosesnya sendiri ...

misalnya Obj bisa ISpecialType atau IType;

keduanya memiliki metode DoStuff () yang ditentukan. Untuk IType bisa saja mengembalikan atau mengerjakan custom, sedangkan ISpecialType bisa melakukan hal lain.

Tindakan ini kemudian akan sepenuhnya menghapus transmisi apa pun, membuat kode lebih bersih dan lebih mudah dikelola, dan kelas tahu cara melakukan tugasnya sendiri.

Saya melakukan perbandingan kinerja pada dua kemungkinan perbandingan tipe

1. myobject.GetType () == typeof (MyClass)
2. myobject adalah MyClass

Hasilnya adalah: Menggunakan "is" 10x lebih cepat !!!

Keluaran:

Waktu untuk Jenis-Perbandingan: 00: 00: 00.456

Waktu untuk Perbandingan-Is: 00: 00: 00.042

Kode Saya:

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

Poin yang dibuat Andrew Hare tentang kinerja yang hilang ketika Anda melakukan ispemeriksaan dan kemudian pemeran valid tetapi di C # 7.0 yang dapat kita lakukan adalah memeriksa kecocokan pola penyihir untuk menghindari pemeran tambahan nanti:

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

Lebih jauh lagi jika Anda perlu memeriksa antara beberapa tipe konstruksi pencocokan pola C # 7.0 sekarang memungkinkan Anda untuk melakukan switchpada tipe:

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

Anda dapat membaca lebih lanjut tentang pencocokan pola di C # dalam dokumentasi di sini .

Jika ada yang bertanya-tanya, saya telah melakukan pengujian di Unity engine 2017.1, dengan skrip versi runtime .NET4.6 (Experimantal) pada notebook dengan CPU i5-4200U. Hasil:

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

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

Saya selalu disarankan untuk menghindari pemeriksaan seperti ini, dan sebaliknya memiliki kelas lain. Jadi, daripada melakukan beberapa pemeriksaan dan melakukan tindakan yang berbeda tergantung pada jenisnya, buat kelas tahu cara memprosesnya sendiri ...

misalnya Obj bisa ISpecialType atau IType;

keduanya memiliki metode DoStuff () yang ditentukan. Untuk IType bisa saja mengembalikan atau mengerjakan custom, sedangkan ISpecialType bisa melakukan hal lain.

Tindakan ini kemudian akan sepenuhnya menghapus transmisi apa pun, membuat kode lebih bersih dan lebih mudah dikelola, dan kelas tahu cara melakukan tugasnya sendiri.