c# - Convert.ChangeType() signed type

Question

How to convert unsigned integer using the method Convert.ChangeType() if I want to get the number is less than zero ?

Example

 uint l = 0xFFF0;    
 short ret = (short)Convert.ChangeType(l, typeof(short)); // here error instead of -16 

Answer 1

I am decided that the problem create own implementation class whith interface IConvertible.

Like this

    /// Class that implements IConvertible
    class ConvertData : IConvertible
    {
        public ConvertData(ulong Value)
        {
            _Field.UlongValue = Value;        
        }

        public ConvertData():this(0)
        {
        }

        public ulong Field
        {
            set { _Field.UlongValue = value; }
            get { return _Field.UlongValue; }
        } 


        ULongStruct _Field;

        [StructLayout(LayoutKind.Explicit)]
        struct ULongStruct
        {
            [FieldOffset(0)]
            public ulong UlongValue;

            [FieldOffset(0)]
            public float FloatValue;

            [FieldOffset(0)]
            public double DoubleValue;

            [FieldOffset(0)]
            public uint UIntValue;

            [FieldOffset(0)]
            public int IntValue;

            [FieldOffset(0)]
            public ushort UShortValue;

            [FieldOffset(0)]
            public short ShortValue;

            [FieldOffset(0)]
            public byte ByteValue;

            [FieldOffset(0)]
            public sbyte SByteValue;
        }

        public TypeCode GetTypeCode()
        {
            return TypeCode.Object;
        }

        bool IConvertible.ToBoolean(IFormatProvider provider)
        {
            return _Field.ByteValue!=0;
        }

        byte IConvertible.ToByte(IFormatProvider provider)
        {
            return _Field.ByteValue;
        }

        char IConvertible.ToChar(IFormatProvider provider)
        {
            return (char)_Field.SByteValue;
        }

        DateTime IConvertible.ToDateTime(IFormatProvider provider)
        {
            return Convert.ToDateTime(_Field.UlongValue);
        }

        decimal IConvertible.ToDecimal(IFormatProvider provider)
        {
            return Convert.ToDecimal(_Field.DoubleValue);
        }

        double IConvertible.ToDouble(IFormatProvider provider)
        {
            return _Field.DoubleValue;
        }

        short IConvertible.ToInt16(IFormatProvider provider)
        {
            return _Field.ShortValue;
        }

        int IConvertible.ToInt32(IFormatProvider provider)
        {
            return _Field.IntValue; 
        }

        long IConvertible.ToInt64(IFormatProvider provider)
        {
            return (long)_Field.UlongValue;
        }

        sbyte IConvertible.ToSByte(IFormatProvider provider)
        {
            return _Field.SByteValue;
        }

        float IConvertible.ToSingle(IFormatProvider provider)
        {
            return _Field.FloatValue;
        }

        string IConvertible.ToString(IFormatProvider provider)
        {
            return String.Format("({0})", _Field.UlongValue);
        }

        object IConvertible.ToType(Type conversionType, IFormatProvider provider)
        {
            return Convert.ChangeType(_Field.UlongValue, conversionType);
        }

        ushort IConvertible.ToUInt16(IFormatProvider provider)
        {
            return _Field.UShortValue; 
        }

        uint IConvertible.ToUInt32(IFormatProvider provider)
        {
            return _Field.UIntValue; 
        }

        ulong IConvertible.ToUInt64(IFormatProvider provider)
        {
            return _Field.UlongValue;
        }
    }

Call

        ConvertData data = new ConvertData(l);
        return (T)Convert.ChangeType(data, typeof(T));