Re: Getting a byte array from a generic class

you could also I believe use sizeof and unsafe code to do this manual
conversion.. otherwise what you have is appropriate considering the few
types to check.

now.. if someone can indeed come up with something better hats off to them :
)




On Tue, May 18, 2010 at 10:54 AM, Eddie Lascu <[email protected]> wrote:

> Hi there,
>
> I need to pick your brains with regard to a more elegant solution to a
> problem I'm dealing with right now. I have a generic class that wraps any
> type of numeric values (short, int, decimal, double or float). Removing the
> parts that are not interesting, this class is something like this:
>
>    public abstract class NumericNtcipObject<T> where T : struct,
> IComparable<T>
>    {
>        protected NumericNtcipObject(T value)
>        {
>            double val;
>            Debugging.Assert(typeof(T).IsValueType &&
> typeof(T).IsPrimitive);
>            Debugging.Assert(double.TryParse(value.ToString(), out val));
>
> Value = value;
>        }
>
>        public T Value
>        {
>            set
>            {
>                _value = value;
>            }
>        }
>
>        public byte[] ValueAsByteStream
>        {
>            get
>            {
>                  // Need help here
>            }
>        }
>
>        protected T _value;
>    }
>
> The class will be derived from and will only be instantiated with numeric
> values. I want to create a property that can give me a byte array containing
> all the bytes of the underlying value. If this would not be a generic class,
> I could do:
>
> return BitConverter.GetBytes(Value);
>
> Unfortunately, BitConverter.GetBytes cannot resolve the type of Value so
> this solution goes out the window. I need the exact number of bytes, so
> casting to a type with a larger range is not good.
>
> I can do something like this:
>
>
>        public byte[] ValueAsByteStream
>        {
>            get
>            {
>                if(typeof(T) == typeof(Int16))
>                {
>                    return BitConverter.GetBytes(Value.ToInt16(new
> NumberFormatInfo()));
>                }
>
>                if (typeof(T) == typeof(Int32))
>                {
>                    return BitConverter.GetBytes(Value.ToInt32(new
> NumberFormatInfo()));
>                }
>
>                if (typeof(T) == typeof(Int64))
>                {
>                    return BitConverter.GetBytes(Value.ToInt64(new
> NumberFormatInfo()));
>                }
>
>                if (typeof(T) == typeof(UInt16))
>                {
>                    return BitConverter.GetBytes(Value.ToUInt16(new
> NumberFormatInfo()));
>                }
>
>                if (typeof(T) == typeof(UInt32))
>                {
>                    return BitConverter.GetBytes(Value.ToUInt32(new
> NumberFormatInfo()));
>                }
>
>                if (typeof(T) == typeof(UInt64))
>                {
>                    return BitConverter.GetBytes(Value.ToUInt64(new
> NumberFormatInfo()));
>                }
>                // rest of types here
>
>                return null;
>            }
>        }
>
> but this is not very nice.
>
> Can either of you smart guys give me a brilliant idea here?
>
> Thanks in advance,
> Eddie
>
> ===================================
> View archives and manage your subscription(s) at
> http://peach.ease.lsoft.com/archives
>

===================================
View archives and manage your subscription(s) at http://peach.ease.lsoft.com/archives