Exemple #1
0
        /// <summary>
        /// Convierte a obj los bytes al tipo especificado
        /// </summary>
        /// <param name="tipo"></param>
        /// <param name="bytesTipo"></param>
        /// <returns>si no se puede devuelve null</returns>
        public static Object ToTipoAceptado(TiposAceptados tipo, byte[] bytesTipo)
        {
            Object obj = null;
            Stream str = new MemoryStream(bytesTipo);

            obj = ToObjetoAceptado(tipo, str);
            str.Close();
            return(obj);
        }
Exemple #2
0
 public static T ToObjetoAceptadoTipado <T>(TiposAceptados objHaLeer, Stream ms)
 {
     return((T)ToObjetoAceptado(objHaLeer, ms));
 }
Exemple #3
0
 public static T ToTipoAceptadoTipado <T>(TiposAceptados tipo, byte[] bytesTipo)
 {
     return((T)ToTipoAceptado(tipo, bytesTipo));
 }
Exemple #4
0
        public static object ToObjetoAceptado(TiposAceptados objHaLeer, Stream ms)
        {
            object obj = null;

            switch (objHaLeer)
            {
            case TiposAceptados.Null:
                break;

            case TiposAceptados.Byte:
                obj = ms.ReadByte();
                break;

            case TiposAceptados.Bool:
                obj = ToBoolean(ms.Read(sizeof(bool)));
                break;

            case TiposAceptados.Short:
                obj = ToShort(ms.Read(sizeof(short)));
                break;

            case TiposAceptados.UShort:
                obj = ToUShort(ms.Read(sizeof(ushort)));
                break;

            case TiposAceptados.Int:
                obj = ToInt(ms.Read(sizeof(int)));
                break;

            case TiposAceptados.UInt:
                obj = ToUInt(ms.Read(sizeof(uint)));
                break;

            case TiposAceptados.Long:
                obj = ToLong(ms.Read(sizeof(long)));
                break;

            case TiposAceptados.ULong:
                obj = ToULong(ms.Read(sizeof(ulong)));
                break;

            case TiposAceptados.Double:
                obj = ToDouble(ms.Read(sizeof(double)));
                break;

            case TiposAceptados.Float:
                obj = ToFloat(ms.Read(sizeof(float)));
                break;

            case TiposAceptados.Char:
                obj = ToChar(ms.Read(sizeof(char)));
                break;

            case TiposAceptados.DateTime:
                obj = ToDateTime(ms.Read(sizeof(long)));
                break;

            case TiposAceptados.Point:
                obj = ToPoint(ms.Read(sizeof(int) * 2));
                break;

            case TiposAceptados.PointZ:
                obj = ToPointZ(ms.Read(sizeof(int) * 3));
                break;

            case TiposAceptados.String:
                obj = ToString(ms.Read(ToLong(ms.Read(sizeof(long)))));
                break;

            case TiposAceptados.Bitmap:
                obj = ToBitmap(ms.Read(ToLong(ms.Read(sizeof(long)))));
                break;

            case TiposAceptados.Color:
                obj = ToColor(ms.Read(sizeof(int)));
                break;

            case TiposAceptados.TimeSpan:
                obj = ToTimeSpan(ms.Read(sizeof(long)));
                break;

            case TiposAceptados.Size:
                obj = ToSize(ms.Read(sizeof(int) * 2));
                break;

            case TiposAceptados.SizeF:
                obj = ToSizeF(ms.Read(sizeof(float) * 2));
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            return(obj);
        }
Exemple #5
0
        public static byte[] GetBytes(Object objTipoAceptado)
        {
            TiposAceptados tipo = GetType(objTipoAceptado);

            byte[] bytes = new byte[] { };
            try {
                switch (tipo)
                {
                case TiposAceptados.Point:
                    bytes = GetBytes((Point)objTipoAceptado);
                    break;

                case TiposAceptados.PointZ:
                    bytes = GetBytes((PointZ)objTipoAceptado);
                    break;

                case TiposAceptados.Bool:
                    bytes = GetBytes((bool)objTipoAceptado);
                    break;

                case TiposAceptados.Short:
                    bytes = GetBytes((short)objTipoAceptado);
                    break;

                case TiposAceptados.UShort:
                    bytes = GetBytes((ushort)objTipoAceptado);
                    break;

                case TiposAceptados.Int:
                    bytes = GetBytes((int)objTipoAceptado);
                    break;

                case TiposAceptados.UInt:
                    bytes = GetBytes((uint)objTipoAceptado);
                    break;

                case TiposAceptados.Long:
                    bytes = GetBytes((long)objTipoAceptado);
                    break;

                case TiposAceptados.ULong:
                    bytes = GetBytes((ulong)objTipoAceptado);
                    break;

                case TiposAceptados.Double:
                    bytes = GetBytes((double)objTipoAceptado);
                    break;

                case TiposAceptados.Float:
                    bytes = GetBytes((float)objTipoAceptado);
                    break;

                case TiposAceptados.Char:
                    bytes = GetBytes((char)objTipoAceptado);
                    break;

                case TiposAceptados.String:
                    bytes = GetBytes((string)objTipoAceptado);
                    break;

                case TiposAceptados.Bitmap:
                    bytes = GetBytes((Bitmap)objTipoAceptado);
                    break;

                case TiposAceptados.DateTime:
                    bytes = GetBytes((DateTime)objTipoAceptado);
                    break;

                case TiposAceptados.Byte:
                    bytes = GetBytes((byte)objTipoAceptado);
                    break;

                case TiposAceptados.Null:
                    bytes = new byte[] { 0x00 };
                    break;

                case TiposAceptados.Color:
                    bytes = GetBytes((Color)objTipoAceptado);
                    break;

                case TiposAceptados.TimeSpan:
                    bytes = GetBytes((TimeSpan)objTipoAceptado);
                    break;

                case TiposAceptados.Size:
                    bytes = GetBytes((Size)objTipoAceptado);
                    break;

                case TiposAceptados.SizeF:
                    bytes = GetBytes((SizeF)objTipoAceptado);
                    break;
                }
            } catch {
                throw new Exception("El objeto no es del tipo indicado como parametro");
            }
            return(bytes);
        }