数据转换

private Single (byte[] b)
{
    try
    {
        Array.Reverse(b);
        Single d = BitConverter.ToSingle(b, 0);
        return (Single)Math.Round(d, 5);
    }
    catch (System.Exception ex)
    {
        return 0;
    }
}
private byte[] SingleToIEEE(Single d)
{
    try
    {
        byte[] b = new byte[]{};
        b = BitConverter.GetBytes(d);
        Array.Reverse(b);
        return b;
    }
    catch (System.Exception ex)
    {
        return new byte[] { 0x00, 0x00, 0x00, 0x00};
    }
}

int Height_LF = (int)Convert.ToDouble(XmlFO.ListObject["WBH_LF"].xValue);
Height_RR *= 4;
string s = string.Empty;
s = s + ((byte)(Height_LF >> 8)).ToString("x2")+ " ";
s = s + ((byte)(Height_LF)).ToString("x2") + " ";

uint BytesToUint(byte[] bys)
{
  uint ReVal = 0;
  foreach (byte b in bys)
  {
      ReVal <<= 8;
      ReVal += b;
  }
  return ReVal;
}

byte[] UintToBytes(uint UnVal, int Count)
{
  byte[] ReVal = new byte[Count];
  for (int i = 0; i < Count; i++)
  {
      ReVal[Count - i - 1] = (byte)(UnVal >> (i * 8));
  }
  return ReVal;
}

public xState ToByte(string sPara)
{
  try
  {
      string[] SepPara;
      if (!XmlFO.SepParams(sPara, 2, out SepPara))
          return xState.xError;

      xBytes tmpbyte = (xBytes)XmlFO.GetCheckSpecTypeObject(SepPara[0], typeof(xBytes));
      if (tmpbyte == null)
          return xState.xError;

      int Count = Convert.ToInt32(SepPara[1]);
      if (Count > 4) Count = 4;
      if (Count < 1) Count = 1;
      Byte[] TmpByte = new byte[Count];
      for (int i = 0; i < Count; i++)
      {
          TmpByte[i] = (byte)((iValue >> ((Count - i - 1) * 8)) & 0xFF);
      }
      tmpbyte.Bytes = TmpByte;
      return xState.xTrue;
  }
  catch (Exception e)
  {
      xErrorOutException(e);
      return xState.xError;
  }
}

public byte[] xHexToBytes(string InStr)
{
    if (!InStr.StartsWith("0x"))
        return System.Text.Encoding.GetEncoding(cPage).GetBytes(InStr);
    InStr = InStr.Substring(2);
    string NSpaceStr = InStr.Replace(" ", string.Empty);

    List<byte> ReByte = new List<byte>();
    for (int i = 0; i < NSpaceStr.Length / 2; i++)
    {
        ReByte.Add(Convert.ToByte(NSpaceStr.Substring(i * 2, 2), 16));
    }
    return ReByte.ToArray();
}
public byte[] StringAnaToBytes(string StrAna)
{
    List<byte> ReByte = new List<byte>();
    try
    {
        string[] strs = StrAna.Split('{', '}');
        for (int i = 0; i < strs.Length; i++)
        {
            if (i % 2 == 0)
                ReByte.AddRange(System.Text.Encoding.GetEncoding(cPage).GetBytes(strs[i]));
            else ReByte.AddRange(xHexToBytes(strs[i]));
        }
    }
    catch (Exception e)
    {
        string xError = string.Format("字符串转换到BYTE失败Error:{0} 字串：{1}", e.Message, StrAna);
        xErrorOut(MethodInfo.GetCurrentMethod().Name, xError);
    }
    return ReByte.ToArray();
}
public string PackBytes(byte[] ArrByte)
{
    string ReStr = "{0x";
    foreach (byte b in ArrByte)
    {
        ReStr += b.ToString("X2");
    }
    ReStr += "}";
    return ReStr;
}
public int cPage = Encoding.Default.CodePage;
public byte[] StringToBytes(string InValue)
{
    string str = XmlFO.StringAnalysis(InValue);
    return StringAnaToBytes(str);
}
public string BytesToString(byte[] InBytes)
{
    return System.Text.Encoding.GetEncoding(cPage).GetString(Bytes);
}
public xState ToString(string sPara)
{
    try
    {
        XmlFO.ListObject[sPara].xValue = BytesToString(Bytes);
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState ToInt(string sPara)
{
    try
    {
        xInt TmpInt = (xInt)XmlFO.GetCheckSpecTypeObject(sPara, typeof(xInt));
        if (TmpInt == null)
            return xState.xError;

        int Count = Bytes.Length;
        int NumTmp = 0;
        if (Count > 0)
        {
            NumTmp = (sbyte)Bytes[0];
            if (Count > 4) Count = 4;
            for (int i = 1; i < Count; i++)
            {
                NumTmp <<= 8;
                NumTmp += Bytes[i];
            }
        }
        TmpInt.iValue = NumTmp;
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState ToInt_MinusSign(string sPara)
{
    try
    {
        xInt TmpInt = (xInt)XmlFO.GetCheckSpecTypeObject(sPara, typeof(xInt));
        if (TmpInt == null)
            return xState.xError;

        int Count = Bytes.Length;
        int NumTmp = 0;
        if (Count > 0)
        {
            NumTmp = (Bytes[0] & 0x7F);
            if (Count > 4) Count = 4;
            for (int i = 1; i < Count; i++)
            {
                NumTmp <<= 8;
                NumTmp += Bytes[i];
            }
            if (Bytes[0] > 0x7F)
                NumTmp = -NumTmp;
        }
        TmpInt.iValue = NumTmp;
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState ToInt_Uint(string sPara)
{
    try
    {
        xInt TmpInt = (xInt)XmlFO.GetCheckSpecTypeObject(sPara, typeof(xInt));
        if (TmpInt == null)
            return xState.xError;

        int Count = Bytes.Length;
        int NumTmp = 0;
        if (Count > 0)
        {
            NumTmp = Bytes[0];
            if (Count > 4) Count = 4;
            for (int i = 1; i < Count; i++)
            {
                NumTmp <<= 8;
                NumTmp += Bytes[i];
            }
        }
        TmpInt.iValue = NumTmp;
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState CopyFrom(string sPara)
{
    try
    {
        xBytes TmpByte = (xBytes)XmlFO.GetCheckSpecTypeObject(sPara, typeof(xBytes));
        if (TmpByte == null)
            return xState.xError;

        if (TmpByte.cPage != cPage)
            Bytes = Encoding.Convert(Encoding.GetEncoding(TmpByte.cPage), Encoding.GetEncoding(cPage), TmpByte.Bytes);
        else Bytes = TmpByte.Bytes.ToArray();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState SubByteFrom(string sPara)
{
    try
    {
        string[] SepPara;
        if (!XmlFO.SepParams(sPara, 3, out SepPara))
            return xState.xError;

        List<Byte> tmpByte = new List<byte>();
        tmpByte.AddRange(StringToBytes(SepPara[0]));
        if (tmpByte.Count > 0)
        {
            int start = Convert.ToInt32(SepPara[1]);
            int leng = Convert.ToInt32(SepPara[2]);
            if (start >= tmpByte.Count)
                start = tmpByte.Count - 1;
            if ((start + leng) > tmpByte.Count)
                leng = tmpByte.Count - start;
            Bytes = tmpByte.GetRange(start, leng).ToArray();
        }
        else Bytes = tmpByte.ToArray();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState IsEqual(string sPara)
{
    try
    {
        string[] SepPara;
        if (!XmlFO.SepParams(sPara, 2, out SepPara))
            return xState.xError;

        byte[] tmpByte = StringToBytes(SepPara[0]);
        int start = Convert.ToInt32(SepPara[1]);
        if ((start + tmpByte.Length) > Bytes.Length)
            return xState.xFalse;
        for (int i = 0; i < tmpByte.Length; i++)
        {
            if (tmpByte[i] != Bytes[start + i])
                return xState.xFalse;
        }
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState CheckBit(string sPara)
{
    try
    {
        string[] SepPara;
        if (!XmlFO.SepParams(sPara, 2, out SepPara))
            return xState.xError;

        int byteNo = Convert.ToInt32(SepPara[0]);
        int bitNo = Convert.ToInt32(SepPara[1]);//start 7---0
        if (bitNo > 7) bitNo = 7;
        if (bitNo < 0) bitNo = 0;
        int Num = (Bytes[byteNo] << (7 - bitNo)) & 0xFF;
        Num = (Num >> 7) & 0xFF;
        if (Num == 1)
            return xState.xTrue;
        else return xState.xFalse;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xError;
    }
}
public xState UseDefaultCodePage(string sPara)
{
    cPage = Encoding.Default.CodePage;
    return xState.xTrue;
}
public xState UseUTF8CodePage(string sPara)
{
    cPage = Encoding.UTF8.CodePage;
    return xState.xTrue;
}
public xState UseUnicodeCodePage(string sPara)
{
    cPage = Encoding.Unicode.CodePage;
    return xState.xTrue;
}

//转换
public xState Convert_String_ASCII(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, Bytes.Length);

        XmlFO.ListObject[Sep.sName].xValue = Encoding.ASCII.GetString(Bytes, Sep.iStart, Sep.iCount);
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}
public xState Convert_String_BCD(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, Bytes.Length);

        string strTmp = string.Empty;
        for (int i = Sep.iStart; (i < Bytes.Length) && (i < (Sep.iStart + Sep.iCount)); i++)
            strTmp += Bytes[i].ToString("X2");
        XmlFO.ListObject[Sep.sName].xValue = strTmp;
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}
public xState Convert_Double(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, 1);
        int NumTmp = 0;
        for (int i = Sep.iStart; (i < Bytes.Length) && (i < (Sep.iStart + Sep.iCount)); i++)
        {
            NumTmp <<= 8;
            NumTmp += Bytes[i];
        }
        double DoubTmp = (NumTmp * Sep.dRadio + Sep.dOffset);

        XmlFO.ListObject[Sep.sName].xValue = DoubTmp.ToString();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}
public xState Convert_Double_Bit(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, 1);
        double NumTmp = 0;
        if (Sep.iCount > 4)
            NumTmp = BitConverter.ToDouble(Bytes, Sep.iStart);
        else NumTmp = BitConverter.ToSingle(Bytes, Sep.iStart);

        double DoubTmp = (NumTmp * Sep.dRadio + Sep.dOffset);

        XmlFO.ListObject[Sep.sName].xValue = DoubTmp.ToString();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}
public xState Convert_Double_Minus(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, 1);
        int NumTmp = (Bytes[0] & 0x7F);
        for (int i = (Sep.iStart + 1); (i < Bytes.Length) && (i < (Sep.iStart + Sep.iCount)); i++)
        {
            NumTmp <<= 8;
            NumTmp += Bytes[i];
        }
        if (Bytes[0] > 0x7F)
            NumTmp = -NumTmp;
        double DoubTmp = (NumTmp * Sep.dRadio + Sep.dOffset);

        XmlFO.ListObject[Sep.sName].xValue = DoubTmp.ToString();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}

public xState Convert_Int(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, 1);
        int NumTmp = 0;
        for (int i = Sep.iStart; (i < Bytes.Length) && (i < (Sep.iStart + Sep.iCount)); i++)
        {
            NumTmp <<= 8;
            NumTmp += Bytes[i];
        }
        NumTmp = (int)(NumTmp * Sep.dRadio + Sep.dOffset);

        XmlFO.ListObject[Sep.sName].xValue = NumTmp.ToString();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}
public xState Convert_Int_Bit(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, 1);
        int NumTmp = 0;
        if (Sep.iCount > 4)
            NumTmp = (int)BitConverter.ToInt64(Bytes, Sep.iStart);
        else if (Sep.iCount > 2)
            NumTmp = (int)BitConverter.ToInt32(Bytes, Sep.iStart);
        else if (Sep.iCount > 1)
            NumTmp = (int)BitConverter.ToInt16(Bytes, Sep.iStart);
        else NumTmp = Bytes[Sep.iStart];

        NumTmp = (int)(NumTmp * Sep.dRadio + Sep.dOffset);

        XmlFO.ListObject[Sep.sName].xValue = NumTmp.ToString();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}

public xState Append_Double(string sPara)
{
    try
    {
        cSepParams Sep = new cSepParams(sPara, 4);
        int iTmp = (int)(Convert.ToDouble(XmlFO.ListObject[Sep.sName].xValue) * Sep.dRadio + Sep.dOffset);

        List<Byte> ListTmp = new List<byte>();
        ListTmp.AddRange(Bytes);
        for (int i = 0; i < Sep.iCount; i++)
        {
            ListTmp.Add((byte)((iTmp >> ((Sep.iCount - i - 1) * 8)) & 0xFF));
        }

        Bytes = ListTmp.ToArray();
        return xState.xTrue;
    }
    catch (Exception e)
    {
        xErrorOutException(e);
        return xState.xFalse;
    }
}