🍢 💃🏻 🐲 सी # ऑपरेटरों की तुलना करें ?: बनाम बनाम-अन्यथा स्विच 👨🏽‍🚒 🏴‍☠️ 🤾🏻

आज, एक और पशु कारखाने की समीक्षा में उड़ान भरी:

public static class AnimalsFactory
{
    public static Animal CreateAnimalByTernaryOperator(bool isCat)
    {
        return isCat ? (Animal)new Cat() : new Dog();
    }
}

एक बार फिर मैं परेशान था कि C # आपको एनिमल के लिए कैट ऑब्जेक्ट लेने के लिए मजबूर करता है। लेकिन जाति को बेहतर होने दो, क्योंकि अगर-और के बयान के माध्यम से कोड और भी लंबा है:

public static class AnimalsFactory
{
    public static Animal CreateAnimalByIfElseOperator(bool isCat)
    {
        if (isCat)
            return new Cat();

        return new Dog();
    }
}

समीक्षा से एक मिनट के लिए खुदाई करें और यह पता लगाने की कोशिश करें:

क्या इन उदाहरणों में IL कोड अलग होगा?
क्या एक उदाहरण से प्रदर्शन में लाभ होगा?

पहले प्रश्न का उत्तर हां, IL-code अलग है, मैं नीचे दिखाऊंगा कि क्या है।

आइए प्रदर्शन के मुद्दे पर आगे बढ़ते हैं। बेंचमार्क डॉटनेट बेंचमार्क के लिए नगेट पैकेज डाउनलोड करें और एक परीक्षण लिखें:

public class AnimalFactoryPerformanceTests
{
    [ParamsAllValues]
    public bool IsCat { get; set; }

    [Benchmark]
    public void CreateAnimalByTernaryOperator() =>
        AnimalsFactory.CreateAnimalByTernaryOperator(IsCat);

    [Benchmark]
    public void CreateAnimalByIfElseOperator() =>
        AnimalsFactory.CreateAnimalByIfElseOperator(IsCat);
}

बेंचमार्क परिणाम:

|                          | IsCat |     |
|------------------------------ |------ |---------:|
| CreateAnimalByTernaryOperator | False | 1.357 ns |
| CreateAnimalByTernaryOperator |  True | 1.655 ns |
|------------------------------ |------ |---------:|
|  CreateAnimalByIfElseOperator | False | 1.636 ns |
|  CreateAnimalByIfElseOperator |  True | 1.360 ns |

यह आश्चर्य की बात है कि "एक कुत्ते के लिए" टर्नरी तेजी से काम करता है, और "एक बिल्ली के लिए" - अगर एक और बयान।
हम टेरीरी ऑपरेटर के साथ विधि के आईएल-कोड को देखते हैं:

CreateAnimalByTernaryOperator(bool isCat)
{
    IL_0000: ldarg.0      // isCat
    IL_0001: brtrue.s     IL_0009
    IL_0003: newobj       instance void AnimalPerformance.Dog::.ctor()
    IL_0008: ret
    IL_0009: newobj       instance void AnimalPerformance.Cat::.ctor()
    IL_000e: ret
}

डॉग ऑब्जेक्ट बनाते समय, IL_0000 - IL_0008 कमांड को क्रमिक रूप से निष्पादित किया जाता है , जबकि कैट ऑब्जेक्ट बनाते समय , एक सशर्त छलांग होती है ( IL_0001: brtrue.s IL_0009 )।

जैसा कि आप अनुमान लगा सकते हैं, अगर-और स्टेटमेंट के लिए, आईएल कोड उत्पन्न होता है, जिसे कैट ऑब्जेक्ट बनाने के लिए सशर्त कूदने की आवश्यकता नहीं होती है । जबकि डॉग ऑब्जेक्ट एक सशर्त शाखा के माध्यम से बनाया गया है:

CreateAnimalByIfElseOperator(bool isCat)
{
    IL_0000: ldarg.0      // isCat
    IL_0001: brfalse.s    IL_0009
    IL_0003: newobj       instance void AnimalPerformance.Cat::.ctor()
    IL_0008: ret
    IL_0009: newobj       instance void AnimalPerformance.Dog::.ctor()
    IL_000e: ret
}

कारखाने में स्विच स्टेटमेंट के साथ तोता निर्माण और एक नई विधि जोड़ें :

public static class AnimalFactory
{
    public static Animal CreateAnimalByTernaryOperator(AnimalType animalType)
    {
        return animalType == AnimalType.Cat
            ? new Cat()
            : animalType == AnimalType.Dog
                ? (Animal)new Dog()
                : new Parrot();
    }

    public static Animal CreateAnimalByIfElseOperator(AnimalType animalType)
    {
        if (animalType == AnimalType.Cat)
            return new Cat();

        if (animalType == AnimalType.Dog)
            return new Dog();

        return new Parrot();
    }

    public static Animal CreateAnimalBySwitchOperator(AnimalType animalType)
    {
        switch (animalType)
        {
            case AnimalType.Cat:
                return new Cat();
            case AnimalType.Dog:
                return new Dog();
            case AnimalType.Parrot:
                return new Parrot();
            default:
                throw new InvalidOperationException();
        }
    }
}

कौन सी विधि तेज होगी?

बेंचमार्क परिणाम

|                          | AnimalType |     |
|------------------------------ |----------- |---------:|
| CreateAnimalByTernaryOperator |        Cat | 2.490 ns |
| CreateAnimalByTernaryOperator |        Dog | 2.515 ns |
| CreateAnimalByTernaryOperator |     Parrot | 2.333 ns |
|------------------------------ |----------- |---------:|
|  CreateAnimalByIfElseOperator |        Cat | 2.368 ns |
|  CreateAnimalByIfElseOperator |        Dog | 2.545 ns |
|  CreateAnimalByIfElseOperator |     Parrot | 2.735 ns |
|------------------------------ |----------- |---------:|
|  CreateAnimalBySwitchOperator |        Cat | 2.747 ns |
|  CreateAnimalBySwitchOperator |        Dog | 2.730 ns |
|  CreateAnimalBySwitchOperator |     Parrot | 2.722 ns |

आईएल कोड

CreateAnimalByTernaryOperator(AnimalsFactory.AnimalType animalType)
{
    IL_0000: ldarg.0      // animalType
    IL_0001: brfalse.s    IL_0013
    IL_0003: ldarg.0      // animalType
    IL_0004: ldc.i4.1
    IL_0005: beq.s        IL_000d
    IL_0007: newobj       instance void AnimalsFactory.Parrot::.ctor()
    IL_000c: ret
    IL_000d: newobj       instance void AnimalsFactory.Dog::.ctor()
    IL_0012: ret
    IL_0013: newobj       instance void AnimalsFactory.Cat::.ctor()
    IL_0018: ret
}

CreateAnimalByIfElseOperator(AnimalsFactory.AnimalType animalType)
{
    IL_0000: ldarg.0      // animalType
    IL_0001: brtrue.s     IL_0009
    IL_0003: newobj       instance void AnimalsFactory.Cat::.ctor()
    IL_0008: ret
    IL_0009: ldarg.0      // animalType
    IL_000a: ldc.i4.1
    IL_000b: bne.un.s     IL_0013
    IL_000d: newobj       instance void AnimalsFactory.Dog::.ctor()
    IL_0012: ret
    IL_0013: newobj       instance void AnimalsFactory.Parrot::.ctor()
    IL_0018: ret

}

CreateOtherAnimalBySwitchOperator(AnimalsFactory.AnimalType animalType)
{
    IL_0000: ldarg.0      // animalType
    IL_0001: switch       (IL_0014, IL_001a, IL_0020)
    IL_0012: br.s         IL_0026
    IL_0014: newobj       instance void AnimalsFactory.Cat::.ctor()
    IL_0019: ret
    IL_001a: newobj       instance void AnimalsFactory.Dog::.ctor()
    IL_001f: ret
    IL_0020: newobj       instance void AnimalsFactory.Parrot::.ctor()
    IL_0025: ret
    IL_0026: newobj       instance void System.InvalidOperationException::.ctor()
    IL_002b: throw
}

निष्कर्ष 1: टर्नरी और यदि-अन्य कथनों के लिए, रनटाइम सीधे सशर्त जंप की संख्या पर निर्भर करता है जो निष्पादन थ्रेड में पारित हो गए हैं।

निष्कर्ष 2: C # स्विच स्टेटमेंट IL कोड में एक स्विच स्टेटमेंट में परिवर्तित हो जाता है और, औसतन, नियमित ब्रांचिंग स्टेटमेंट्स की तुलना में थोड़ी अधिक देर तक काम करता है।

निष्कर्ष 3: उपरोक्त सब कुछ केवल .NET फ्रेमवर्क v.4.8 के लिए प्रासंगिक है। .NetCore पर एक ही परीक्षण चलाने के बाद, हमें पूरी तरह से अलग परिणाम मिले हैं जिनकी व्याख्या अभी तक किसी भी तरह से की जानी है।

बेंचमार्क .NetCore 3.0

|                          | AnimalType |     |
|------------------------------ |----------- |---------:|
| CreateAnimalByTernaryOperator |        Cat | 3.046 ns |
| CreateAnimalByTernaryOperator |        Dog | 2.984 ns |
| CreateAnimalByTernaryOperator |     Parrot | 3.019 ns |
|------------------------------ |----------- |---------:|
|  CreateAnimalByIfElseOperator |        Cat | 2.980 ns |
|  CreateAnimalByIfElseOperator |        Dog | 2.977 ns |
|  CreateAnimalByIfElseOperator |     Parrot | 3.103 ns |
|------------------------------ |----------- |---------:|
|  CreateAnimalBySwitchOperator |        Cat | 3.519 ns |
|  CreateAnimalBySwitchOperator |        Dog | 3.533 ns |
|  CreateAnimalBySwitchOperator |     Parrot | 3.312 ns |

प्रोसेसर: Intel® Core (TM) i7-7700K

स्रोत

सी # ऑपरेटरों की तुलना करें ?: बनाम बनाम-अन्यथा स्विच

More articles: