C # स्विच का भाव अलग परिणाम देता है

Question

मैंने अपने एक प्रोजेक्ट पर C # 8 में स्विच किया है। और मैं अपने सभी switchबयानों को भावों तक ले जा रहा हूं । हालाँकि मुझे पता चला कि मेरे प्रोजेक्ट ने अलग तरीके से काम करना शुरू कर दिया है और मुझे पता चला है कि यह switchअभिव्यक्ति के कारण था । उदाहरण के लिए यह कोड प्राप्त करें

class Program
{
    public enum DataType
    {
        Single,
        Double,
        UInt16,
        UInt32,
        UInt64,
        Int16,
        Int32,
        Int64,
        Byte
    }

    static void Main(string[] args)
    {
        dynamic value1 = 5;
        dynamic value2 = 6;

        var casted = CastToType(value1, DataType.Int16);
        var casted1 = CastToTypeExpression(value2, DataType.Int16);


        var type = casted.GetType(); // Int16
        var type1 = casted1.GetType(); // Double
        var bytes = BitConverter.GetBytes(casted); // byte arr with 2 el => [5, 0] <- expected behavior 
        var bytes1 = BitConverter.GetBytes(casted1); // byte arr with 8 el => [0, 0, 0, 0, 0, 0, 24, 64]
    }

    public static dynamic CastToType(dynamic value, DataType type)
    {
        switch (type)
        {
            case DataType.Byte:
                return (byte)value;
            case DataType.Double:
                return (double)value;
            case DataType.Int16:
                return (short)value;
            case DataType.Int32:
                return (int)value;
            case DataType.Int64:
                return (long)value;
            case DataType.Single:
                return (float)value;
            case DataType.UInt16:
                return (ushort)value;
            case DataType.UInt32:
                return (uint)value;
            case DataType.UInt64:
                return (ulong)value;
            default: throw new InvalidCastException();
        }
    }

    public static dynamic CastToTypeExpression(dynamic value, DataType type)
    {
        return type switch
        {
            DataType.Byte => (byte)value,
            DataType.Double => (double)value,
            DataType.Int16 => (short)value,
            DataType.Int32 => (int)value,
            DataType.Int64 => (long)value,
            DataType.Single => (float)value,
            DataType.UInt16 => (ushort)value,
            DataType.UInt32 => (uint)value,
            DataType.UInt64 => (ulong)value,
            _ => throw new InvalidCastException(),
        };
    }
}

मैंने परिणाम को एक टिप्पणी के रूप में लिखा है, लेकिन tl; ड्र जब क्लासिक स्विच का उपयोग किया जाता है, तो मूल्य अपेक्षित प्रकार में मूल्य लौटाता है, लेकिन जब स्विच अभिव्यक्ति का उपयोग किया जाता है तो यह "डबल" का प्रकार लौटाता है, जिसके परिणामस्वरूप भिन्न byte[]होता है। मूल्य के बाइट्स।

दोनों में क्या अंतर है? मुझे क्या याद आती है?

Comments

मैं वास्तव में यह नहीं बता सकता कि ऐसा क्यों और कैसे होता है, लेकिन अगर आपके पास यहाँ पर अपने कोड के एक विघटित संस्करण पर एक नज़र है ( gist.github.com/MaDOS/4904683d461d022e4b24f408ae5e ) आप देख सकते हैं कि संकलक को लगता है कि सभी संभावित प्रकार लौट रहे हैं। अभिव्यक्ति एक डबल में फिट होगी और स्वचालित रूप से एक डबल की घोषणा करती है जहां यह स्टोर करेगा जो भी परिणाम वापस आ जाएगा। ( gist.github.com/MaDOS/… )

— रॉबिन बी

Answer 1

आपके स्विच स्टेटमेंट फॉर्म में, प्रत्येक हाथ सीधे मान लौटा रहा है। यह संख्यात्मक प्रकार से सीधे objectरूप में परिवर्तित हो रहा है , क्योंकि यह प्रभावी रूप से विधि का प्रकार है।

आपका स्विच एक्सप्रेशन फॉर्म थोड़ा अलग है। यह पहले स्विच अभिव्यक्ति से एक परिणाम निकालता है, फिर उस परिणाम को घोषित रिटर्न प्रकार में परिवर्तित करता है। तो स्विच अभिव्यक्ति का प्रकार क्या है? यह स्विच अभिव्यक्ति की बाहों में व्यक्तिगत अभिव्यक्तियों के सभी प्रकारों में से "सर्वश्रेष्ठ" प्रकार है।

उन सभी प्रकारों को अंतर्निहित रूप से परिवर्तित किया जा सकता है double(जो स्वयं प्रकारों में से एक है), इसलिए यह सबसे अच्छा प्रकार है। तो आपकी स्विच अभिव्यक्ति विधि इसके बराबर है:

public static dynamic CastToTypeExpression(dynamic value, DataType type)
{
    double result = type switch
    {
        DataType.Byte => (byte)value,
        DataType.Double => (double)value,
        DataType.Int16 => (short)value,
        DataType.Int32 => (int)value,
        DataType.Int64 => (long)value,
        DataType.Single => (float)value,
        DataType.UInt16 => (ushort)value,
        DataType.UInt32 => (uint)value,
        DataType.UInt64 => (ulong)value,
        _ => throw new InvalidCastException(),
    };
    return result;
}

आप इस "सबसे अच्छे प्रकार" को बिना स्विच अभिव्यक्ति का उपयोग किए, बिना देखे टाइप किए गए सरणियों का उपयोग करके देख सकते हैं:

var array = new[]
{
    (byte) 0, 0.0, (short) 0, 0,
    0L, 0f, (ushort) 0, 0U, 0UL
};

यहाँ प्रकार के होने arrayका अनुमान हैdouble[] ।