C # Cambia espressioni che restituiscono risultati diversi

Sono passato a C # 8 in uno dei miei progetti. E ho trasferito tutte le mie switchdichiarazioni in espressioni. Tuttavia ho scoperto che il mio progetto ha iniziato a funzionare in modo diverso e ho scoperto che era a causa switchdell'espressione. Consente di ottenere questo codice, ad esempio

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

Ho scritto il risultato come un commento, ma tl; dr quando si usa lo switch classico lanciando il valore restituisce il valore nel Tipo previsto, ma quando si usa l'espressione switch restituisce il tipo di "Double", risultando diverso byte[]quando si ottiene il byte del valore.

Qual è la differenza tra i due? Cosa mi manca

— Expressingx
fonte

Non riesco a spiegare esattamente perché e come ciò accada, ma se dai un'occhiata a una versione decompilata del tuo codice qui ( gist.github.com/MaDOS/4904683d461d022e4b24f4080009ae5e ) noterai che il compilatore sembra notare che tutti i possibili tipi di ritorno dell'espressione si inserirà in un doppio e dichiara automaticamente un doppio in cui memorizzerà qualsiasi risultato verrà restituito. ( gist.github.com/MaDOS/… )

— Robin B

Nel modulo dell'istruzione switch , ogni braccio restituisce direttamente un valore. Si sta convertendo direttamente dal tipo numerico a object, in quanto è effettivamente il tipo restituito del metodo.

Il modulo di espressione del cambio è leggermente diverso. Prima estrae un risultato dall'espressione switch, quindi converte quel risultato nel tipo restituito dichiarato. Quindi qual è il tipo dell'espressione switch? È il tipo "migliore" di tutti i tipi delle singole espressioni tra le braccia dell'espressione switch.

Tutti questi tipi possono essere convertiti implicitamente in double(che è uno dei tipi stessi), quindi è il tipo migliore. Quindi il tuo metodo di espressione switch è equivalente a:

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

Puoi vedere questo "miglior tipo" senza usare un'espressione switch, usando array tipicamente impliciti:

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

Qui arraysi suppone che il tipo di sia double[].

— Jon Skeet
fonte