C # 'é' desempenho do operador

Tenho um programa que exige desempenho rápido. Em um de seus loops internos, preciso testar o tipo de um objeto para ver se ele herda de uma determinada interface.

Uma maneira de fazer isso seria com a funcionalidade de verificação de tipo integrada do CLR. O método mais elegante provavelmente sendo a palavra-chave 'é':

if (obj is ISpecialType)

Outra abordagem seria dar à classe base minha própria função virtual GetType () que retorna um valor de enum predefinido (no meu caso, na verdade, eu só preciso de um bool). Esse método seria rápido, mas menos elegante.

Ouvi dizer que existe uma instrução IL especificamente para a palavra-chave 'é', mas isso não significa que ela executa rapidamente quando traduzida para o assembly nativo. Alguém pode compartilhar alguns insights sobre o desempenho de 'é' em relação ao outro método?

ATUALIZAÇÃO: Obrigado por todas as respostas informadas! Parece que alguns pontos úteis estão espalhados entre as respostas: O ponto de Andrew sobre 'é' executar um elenco automaticamente é essencial, mas os dados de desempenho coletados por Binary Worrier e Ian também são extremamente úteis. Seria ótimo se uma das respostas fosse editada para incluir todas essas informações.

O uso ispode prejudicar o desempenho se, depois de verificar o tipo, você lançar para aquele tipo. isna verdade, converte o objeto para o tipo que você está verificando, portanto, qualquer conversão subsequente é redundante.

Se você vai lançar de qualquer maneira, aqui está uma abordagem melhor:

ISpecialType t = obj as ISpecialType;

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

Estou com Ian , você provavelmente não quer fazer isso.

No entanto, só para você saber, há muito pouca diferença entre os dois, mais de 10.000.000 de iterações

• A verificação enum chega em 700 milissegundos (aprox)
• A verificação IS chega em 1000 milissegundos (aprox)

Eu pessoalmente não resolveria esse problema dessa maneira, mas se fosse forçado a escolher um método seria a verificação de IS embutida, a diferença de desempenho não vale a pena considerar a sobrecarga de codificação.

Minhas classes base e derivadas

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: Conforme solicitado, mais informações sobre os testes.

Eu executei os dois testes de um aplicativo de console (uma compilação de depuração), cada teste se parece com o seguinte

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

Correndo na liberação, obtenho uma diferença de 60 - 70 ms, como Ian.

Atualização adicional - 25 de outubro de 2012
Depois de alguns anos longe, percebi algo sobre isso, o compilador pode escolher omitir bool b = a is MyClassBno lançamento porque b não é usado em lugar nenhum.

Este código. . .

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

. . . mostra consistentemente ois verificação chegando em aproximadamente 57 milissegundos e a comparação de enum chegando em 29 milissegundos.

NB eu ainda prefiro o ischeque, a diferença é muito pequena para me preocupar

Ok, então eu estava conversando sobre isso com alguém e decidi testar mais. Pelo que eu posso dizer, o desempenho de ase isé muito bom, em comparação com o teste de seu próprio membro ou função para armazenar informações de tipo.

Eu usei Stopwatch, que acabei de descobrir que pode não ser a abordagem mais confiável, então também tentei UtcNow. Mais tarde, também tentei a abordagem de tempo do processador, que parece semelhante a UtcNowincluir tempos de criação imprevisíveis. Eu também tentei tornar a classe base não abstrata sem virtuais, mas não pareceu ter um efeito significativo.

Eu executei isso em um Quad Q6600 com 16 GB de RAM. Mesmo com iterações de 50mil, os números ainda oscilam em torno de +/- 50 ou mais milissegundos, então eu não interpretaria muito as pequenas diferenças.

Foi interessante ver que o x64 foi criado mais rápido, mas executado como / é mais lento que o x86

x64 Modo de liberação:
Cronômetro:
As: 561ms
Is: 597ms
Propriedade básica: 539ms
Campo base: 555ms
Campo RO base: 552ms
Teste GetEnumType ()
virtual : 556ms Teste IsB virtual (): 588ms
Tempo de criação: 10416ms

UtcNow:
As: 499ms
Is: 532ms
Propriedade de base: 479ms
Campo de base: 502ms
Campo de RO base: 491ms
Virtual GetEnumType (): 502ms
Virtual bool IsB (): 522ms
Tempo de criação: 285ms (Este número parece não confiável com UtcNow. Eu também recebo 109ms e 806ms.)

x86 Modo de liberação:
Cronômetro:
As: 391ms
Is: 423ms
Propriedade básica: 369ms
Campo base: 321ms
Campo RO de base: 339ms
Teste GetEnumType ()
virtual : 361ms Teste IsB virtual (): 365ms
Tempo de criação: 14106ms

UtcNow:
As: 348ms
Is: 375ms
Propriedade de base: 329ms
Campo de base: 286ms
Campo de RO base: 309ms
Virtual GetEnumType (): 321ms
Virtual bool IsB (): 332ms
Tempo de Criação: 544ms (Este número parece não confiável com UtcNow.)

Aqui está a maior parte do código:

    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 está correto. Na verdade, com a análise de código, isso é relatado pelo Visual Studio como um elenco desnecessário.

Uma ideia (sem saber o que você está fazendo é meio que um tiro no escuro), mas sempre fui aconselhado a evitar checar assim e, em vez disso, ter outra aula. Então, ao invés de fazer algumas verificações e ter ações diferentes dependendo do tipo, faça a classe saber como se processar ...

por exemplo, Obj pode ser ISpecialType ou IType;

ambos têm um método DoStuff () definido. Para IType, ele pode apenas retornar ou fazer coisas personalizadas, enquanto ISpecialType pode fazer outras coisas.

Isso remove completamente qualquer projeção, torna o código mais limpo e mais fácil de manter, e a classe sabe como fazer suas próprias tarefas.

Eu fiz uma comparação de desempenho em duas possibilidades de comparação de tipo

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

O resultado é: Usar "é" é cerca de 10 vezes mais rápido !!!

Resultado:

Hora para comparação de tipo: 00: 00: 00.456

Hora da comparação de is: 00: 00: 00.042

Meu código:

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

O ponto que Andrew Hare fez sobre a perda de desempenho quando você executa a isverificação e, em seguida, o elenco era válido, mas no C # 7.0 podemos fazer é verificar a correspondência de padrão de bruxa para evitar elenco adicional mais tarde:

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

Além disso, se você precisar verificar entre vários tipos, as construções de correspondência de padrões C # 7.0 agora permitem que você faça switchnos tipos:

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

Você pode ler mais sobre correspondência de padrões em C # na documentação aqui .

Caso alguém esteja se perguntando, fiz testes no motor Unity 2017.1, com scripting runtime versão .NET4.6 (Experimantal) em um notebook com CPU i5-4200U. Resultados:

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

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

Sempre fui aconselhado a evitar checar assim e, em vez disso, ter outra aula. Então, ao invés de fazer algumas verificações e ter ações diferentes dependendo do tipo, faça a classe saber como se processar ...

por exemplo, Obj pode ser ISpecialType ou IType;

ambos têm um método DoStuff () definido. Para IType, ele pode apenas retornar ou fazer coisas personalizadas, enquanto ISpecialType pode fazer outras coisas.

Isso remove completamente qualquer projeção, torna o código mais limpo e mais fácil de manter, e a classe sabe como fazer suas próprias tarefas.