using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.ComponentModel;
using System.Reflection;
using System.Windows.Forms;

namespace Mesnac.Basic
{
    /// <summary>
    /// 数据处理器
    /// </summary>
    public class DataProcessor
    {
        #region 获取浮点数值的有效小数位数

        /// <summary>
        /// 获取浮点数值的有效小数位数
        /// </summary>
        /// <param name="value">浮点数值</param>
        /// <param name="maxPrecision">允许返回的最大小数位数</param>
        /// <returns>返回有效小数位数</returns>
        public static int GetValidPrecision(object value, int maxPrecision)
        {
            if (DataProcessor.IsNullOrEmpty(value))
            {
                return 0;
            }
            else
            {
                if (value.ToString().IndexOf(".") == -1)
                {
                    return 0;
                }
                else
                {
                    string strValue = value.ToString();
                    string precision = strValue.Substring(strValue.IndexOf(".") + 1);
                    int cnt = 0;    //保存末尾0的个数
                    for (int i = precision.Length - 1; i > 0; i--)
                    {
                        if (precision.ToCharArray()[i] == '0')
                        {
                            cnt++;
                        }
                        else
                        {
                            break;
                        }
                    }
                    int result = precision.Length - cnt;    //为有效小数位数
                    if (result > maxPrecision)
                    {
                        return maxPrecision;
                    }
                    else
                    {
                        return result;
                    }
                }
            }
        }

        #endregion

        #region 对数据行字段取值方法

        /// <summary>
        /// 获取byte数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static byte RowValue(DataRow dr, string field, byte defaultValue)
        {
            byte Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (byte.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取Short数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static short RowValue(DataRow dr, string field, short defaultValue)
        {
            short Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (short.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取整型数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static int RowValue(DataRow dr, string field, int defaultValue)
        {
            int Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (int.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取float数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static float RowValue(DataRow dr, string field, float defaultValue)
        {
            float Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (float.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取double数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static double RowValue(DataRow dr, string field, double defaultValue)
        {
            double Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (double.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取decimal数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static decimal RowValue(DataRow dr, string field, decimal defaultValue)
        {
            decimal Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (decimal.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取DateTime数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static DateTime RowValue(DataRow dr, string field, DateTime defaultValue)
        {
            DateTime Result = defaultValue;
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    if (DateTime.TryParse(dr[field].ToString(), out Result))
                    {
                        return Result;
                    }
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }
        /// <summary>
        /// 获取字符串数据列的值
        /// </summary>
        /// <param name="dr"></param>
        /// <param name="field"></param>
        /// <param name="defaultValue"></param>
        /// <returns></returns>
        public static string RowValue(DataRow dr, string field, string defaultValue)
        {
            if (dr.Table.Columns.Contains(field))
            {
                if (dr[field] != null && dr[field] != DBNull.Value)
                {
                    return dr[field].ToString().Trim();
                }
            }
            else
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("DataTable中不存在[" + field + "]列!");
            }
            return defaultValue;
        }

        #endregion

        #region 获取数组的异或校验值

        #region 获取数组的异或校验值(第1个元素与第2个元素异或，结果与第3个元素异或，直到最后一个元素)

        /// <summary>
        /// 获取数组的异或校验值(第1个元素与第2个元素异或，结果与第3个元素异或，指导最后一个元素)
        /// </summary>
        /// <param name="values">数组参数</param>
        /// <returns>返回异或校验值</returns>
        public static Int16 GetXorCheckValue(Int16[] values)
        {
            if (values == null || values.Length == 0)
            {
                return 0;
            }
            else if (values.Length == 1)
            {
                return values[0];
            }
            else
            {
                Int16 result = (Int16)(values[0] ^ values[1]);
                for (int i = 2; i < values.Length; i++)
                {
                    result = (Int16)(result ^ values[i]);
                }
                return result;
            }

        }

        /// <summary>
        /// 获取数组的异或校验值(第1个元素与第2个元素异或，结果与第3个元素异或，指导最后一个元素)
        /// </summary>
        /// <param name="values">数组参数</param>
        /// <returns>返回异或校验值</returns>
        public static object GetXorCheckValue(object[] values)
        {
            if (values == null || values.Length == 0)
            {
                return 0;
            }
            else if (values.Length == 1)
            {
                return values[0];
            }
            else
            {
                Int16 result = (Int16)(Convert.ToInt16(values[0]) ^ Convert.ToInt16(values[1]));
                for (int i = 2; i < values.Length; i++)
                {
                    result = (Int16)(Convert.ToInt16(result) ^ Convert.ToInt16(values[i]));
                }
                return result;
            }
        }

        #endregion

        #region 获取数组的异或校验值（第一个参数与数组第一个元素异或，结果与第2个元素异或，直到最后一个元素）

        /// <summary>
        /// 获取数组的异或校验值（第一个参数与数组第一个元素异或，结果与第2个元素异或，直到最后一个元素）
        /// </summary>
        /// <param name="param">起始参数</param>
        /// <param name="values">数组元素</param>
        /// <returns>返回异或校验值</returns>
        public static Int16 GetXorCheckValueByParm(Int16 param, Int16[] values)
        {
            if (values == null || values.Length == 0)
            {
                return param;
            }
            else
            {
                Int16 result = param;
                for (int i = 0; i < values.Length; i++)
                {
                    result = (Int16)(result ^ values[i]);
                }
                return result;
            }
        }

        /// <summary>
        /// 获取数组的异或校验值（第一个参数与数组第一个元素异或，结果与第2个元素异或，直到最后一个元素）
        /// </summary>
        /// <param name="param">起始参数</param>
        /// <param name="values">数组元素</param>
        /// <returns>返回异或校验值</returns>
        public static object GetXorCheckValueByParm(object param, object[] values)
        {
            if (values == null || values.Length == 0)
            {
                return param;
            }
            else
            {
                Int16 result = Convert.ToInt16(param);
                for (int i = 0; i < values.Length; i++)
                {
                    result = (Int16)(Convert.ToInt16(result) ^ Convert.ToInt16(values[i]));
                }
                return result;
            }
        }

        #endregion

        #endregion

        #region 判断2个数组元素值是否相同

        /// <summary>
        /// 判断2个数组元素值是否相同
        /// </summary>
        /// <param name="arr1">数组1</param>
        /// <param name="arr2">数组2</param>
        /// <returns>相同返回true，不同返回false</returns>
        public static bool IsSameArrayValue(object[] arr1, object[] arr2)
        {
            if (arr1.Length != arr2.Length)
            {
                return false;
            }
            bool result = true;
            for (int i = 0; i < arr1.Length; i++)
            {
                if (!arr1[i].Equals(arr2[i]))
                {
                    result = false;
                    break;
                }
            }
            return result;
        }

        #endregion

        #region 克隆DataTable及数据的方法

        /// <summary>
        /// 克隆DataTable及数据的方法
        /// </summary>
        /// <param name="dt">要克隆的数据表</param>
        /// <returns>返回克隆以后的数据表</returns>
        public static DataTable Clone(DataTable dt)
        {
            DataTable dt2 = dt.Clone();
            foreach (DataRow dr in dt.Rows)
            {
                DataRow dr2 = dt2.NewRow();
                foreach (DataColumn dc in dt.Columns)
                {
                    dr2[dc.ColumnName] = dr[dc.ColumnName];
                }
                dt2.Rows.Add(dr2);
            }
            return dt2;
        }

        #endregion

        #region 从DataGridView控件获取DataTable数据

        /// <summary>
        /// 从DataGridView控件获取DataTable数据
        /// </summary>
        /// <param name="grid"></param>
        /// <returns></returns>
        public static DataTable GetDataTableFromGridView(DataGridView grid)
        {
            DataTable dt = grid.DataSource as DataTable;
            if (dt != null)
            {
                DataTable table = dt.Clone();
                foreach(DataGridViewRow dgvRow in grid.Rows)
                {
                    DataRow row = table.NewRow();
                    foreach(DataGridViewColumn col in grid.Columns)
                    {
                        row[col.DataPropertyName] = dgvRow.Cells[col.Name].Value;
                    }
                    table.Rows.Add(row);
                }
                return table;
            }
            else
            {
                return null;
            }
        }

        #endregion

        #region 格式化小数位数

        /// <summary>
        /// 格式化小数位数
        /// </summary>
        /// <param name="floatValue">要格式化的小数对象</param>
        /// <param name="maxPrecision">保留的最大小数位数</param>
        /// <returns>返回格式化后的小数字符串值</returns>
        public static object FormatFloatValue(object floatValue, int maxPrecision)
        {
            if (IsNullOrEmpty(floatValue))
            {
                return String.Empty;
            }
            else
            {
                int intPrecision = GetValidPrecision(floatValue, maxPrecision);
                return String.Format("{0:f" + intPrecision + "}", floatValue);
            }
        }

        #endregion

        #region 格式化DataTable中小数位数

        /// <summary>
        /// 格式化DataTable
        /// </summary>
        /// <param name="dt">要格式化的DataTable对象</param>
        /// <param name="noFormatColumns">排除在格式化之外的列</param>
        /// <param name="maxPrecision">保留的最大小数位数</param>
        /// <returns>返回格式化后的DataTable对象</returns>
        public static DataTable FormatDataTable(DataTable dt, List<string> noFormatColumns, int maxPrecision)
        {
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                foreach (DataColumn dc in dt.Columns)
                {
                    if (dc.DataType == typeof(double?) ||
                        dc.DataType == typeof(double) ||
                        dc.DataType == typeof(float?) ||
                        dc.DataType == typeof(float) ||
                        dc.DataType == typeof(decimal?) ||
                        dc.DataType == typeof(decimal) ||
                        dc.DataType == typeof(int?) ||
                        dc.DataType == typeof(int))
                    {
                        if (dt.Rows[i][dc] != null && dt.Rows[i][dc] != DBNull.Value)
                        {
                            if (noFormatColumns != null && noFormatColumns.Contains(dc.ColumnName))
                            {
                                continue;
                            }
                            double d = 0.0;
                            string ss = dt.Rows[i][dc].ToString();
                            if (double.TryParse(ss, out d) && d == 0)
                            {
                                dt.Rows[i][dc] = DBNull.Value;
                            }
                            else if (dc.DataType != typeof(int))
                            {
                                int intPrecision = GetValidPrecision(dt.Rows[i][dc], maxPrecision);
                                dt.Rows[i][dc] = String.Format("{0:f" + intPrecision + "}", dt.Rows[i][dc]);
                            }
                        }
                    }
                }
            }
            return dt;
        }

        #endregion

        #region 清除DataGridView中的选中行

        /// <summary>
        /// 清除DataGridView中的选中行
        /// </summary>
        /// <param name="grid"></param>
        public static void ClearSelectedStatus(DataGridView grid)
        {
            if (grid != null && grid.Visible)
            {
                foreach (DataGridViewRow row in grid.Rows)
                {
                    if (row.Selected)
                    {
                        row.Selected = false;
                    }
                }
            }
        }

        /// <summary>
        /// 注册清除DataGridView中的选中行事件
        /// </summary>
        /// <param name="grid"></param>
        public static void RegistClearSelectedEvent(DataGridView grid)
        {
            grid.VisibleChanged -= grid_VisibleChanged;
            grid.VisibleChanged += grid_VisibleChanged;
            grid.CellDoubleClick -= grid_CellDoubleClick;
            grid.CellDoubleClick += grid_CellDoubleClick;
        }

        private static void grid_VisibleChanged(object sender, EventArgs e)
        {
            DataGridView grid = sender as DataGridView;
            if (grid != null && grid.Visible)
            {
                foreach (DataGridViewRow row in grid.Rows)
                {
                    if (row.Selected)
                    {
                        row.Selected = false;
                    }
                }
            }
        }

        private static void grid_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            DataGridView grid = sender as DataGridView;
            if (grid != null && grid.Visible)
            {
                foreach (DataGridViewRow row in grid.Rows)
                {
                    if (row.Selected)
                    {
                        row.Selected = false;
                    }
                }
            }
        }

        #endregion

        #region "按字符串位数补0"
        /// <summary>
        /// 按字符串位数补0
        /// </summary>
        /// <param name="CharTxt">字符串</param>
        /// <param name="CharLen">字符长度</param>
        /// <returns></returns>
        public static string FillZero(string CharTxt, int CharLen)
        {
            if (CharTxt.Length < CharLen)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < CharLen - CharTxt.Length; i++)
                {
                    sb.Append("0");
                }
                sb.Append(CharTxt);
                return sb.ToString();
            }
            else
            {
                return CharTxt;
            }
        }

        #endregion

        #region 判断字符串是否为纯数字
        /// <summary>
        /// 判断字符串是否为纯数字
        /// </summary>
        /// <param name="str">要判断的字符串</param>
        /// <returns>是纯数字返回true，否则返回false</returns>
        public static bool IsNumeric(string str) //接收一个string类型的参数,保存到str里
        {
            if (str == null || str.Length == 0)    //验证这个参数是否为空
                return false;                           //是，就返回False
            ASCIIEncoding ascii = new ASCIIEncoding();//new ASCIIEncoding 的实例
            byte[] bytestr = ascii.GetBytes(str);         //把string类型的参数保存到数组里

            foreach (byte c in bytestr)                   //遍历这个数组里的内容
            {
                if (c < 48 || c > 57)                          //判断是否为数字
                {
                    return false;                              //不是，就返回False
                }
            }
            return true;                                        //是，就返回True
        }

        #endregion

        #region 判断是否为空

        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <param name="value">要判断的对象</param>
        /// <returns>为空返回true，否则返回false</returns>
        public static bool IsNullOrEmpty(object value)
        {
            if (value == null || value == DBNull.Value || string.IsNullOrWhiteSpace(value.ToString()))
            {
                return true;
            }
            return false;
        }

        #endregion

        #region 合并消息列表

        /// <summary>
        /// 合并消息列表
        /// </summary>
        /// <param name="msgList">要合并的消息列表</param>
        /// <returns>返回合并的消息字符串</returns>
        public static string CombineMsgList(List<string> msgList)
        {
            if (msgList != null && msgList.Count > 0)
            {
                StringBuilder sb = new StringBuilder();
                foreach (string msg in msgList)
                {
                    sb.AppendLine(msg);
                }
                return sb.ToString();
            }
            return String.Empty;
        }

        /// <summary>
        /// 合并消息列表
        /// </summary>
        /// <param name="msgList">要合并的消息列表</param>
        /// <returns>返回合并的消息字符串</returns>
        public static string CombineMsgList(List<string> msgList, string split)
        {
            if (msgList != null && msgList.Count > 0)
            {
                StringBuilder sb = new StringBuilder();
                foreach (string msg in msgList)
                {
                    if (String.IsNullOrEmpty(sb.ToString()))
                    {
                        sb.Append(msg);
                    }
                    else
                    {
                        sb.Append(split);
                        sb.Append(msg);
                    }
                }
                return sb.ToString();
            }
            return String.Empty;
        }

        #endregion

        #region 把从PLC读取的buff数组转换为指定类型数据

        #region 把Int16[]转换为Int32类型变量

        #region 西门子PLC处理方法

        /// <summary>
        /// 把长度为2的Int16类型的数组转换为Int32类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回Int32类型值</returns>
        public static Int32 ToSiemensInt32(Int16[] buff)
        {

            if (buff == null)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为Int32:失败，原因buff为NULL!"));
                return 0;
            }
            if (buff.Length != 2)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为Int32:失败，原因buff.Length={0}应为2!", buff.Length));
                return 0;
            }

            Int16 int16Value0 = Convert.ToInt16(buff[0]);
            Int16 int16Value1 = Convert.ToInt16(buff[1]);
            byte[] byteValues0 = BitConverter.GetBytes(int16Value0);
            byte[] byteValues1 = BitConverter.GetBytes(int16Value1);
            byte[] resultValues = new byte[4];
            resultValues[0] = byteValues1[0];
            resultValues[1] = byteValues1[1];
            resultValues[2] = byteValues0[0];
            resultValues[3] = byteValues0[1];
            Int32 result = BitConverter.ToInt32(resultValues, 0);
            return result;
        }



        /// <summary>
        /// 把长度为2的Int16类型的数组转换为Int32类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回Int32类型值</returns>
        public static Int32 ToSiemensInt32(int[] buff)
        {
            Int16[] buffResult = new Int16[buff.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buffResult[i] = Convert.ToInt16(buff[i]);
            }
            return ToSiemensInt32(buffResult);
        }

        /// <summary>
        /// 把2个Int16类型的数转换为Int32类型的值
        /// </summary>
        /// <param name="buff0">第一个Int16类型的参数</param>
        /// <param name="buff1">第二个Int16类型的参数</param>
        /// <returns>返回对应Int32类型的值</returns>
        public static Int32 ToSiemensInt32(Int16 buff0, Int16 buff1)
        {
            Int16 int16Value0 = Convert.ToInt16(buff0);
            Int16 int16Value1 = Convert.ToInt16(buff1);
            byte[] byteValues0 = BitConverter.GetBytes(int16Value0);
            byte[] byteValues1 = BitConverter.GetBytes(int16Value1);
            byte[] resultValues = new byte[4];
            resultValues[0] = byteValues1[0];
            resultValues[1] = byteValues1[1];
            resultValues[2] = byteValues0[0];
            resultValues[3] = byteValues0[1];
            Int32 result = BitConverter.ToInt32(resultValues, 0);
            return result;
        }

        #endregion

        #region 其他PLC处理方法

        /// <summary>
        /// 把长度为2的Int16类型的数组转换为Int32类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回Int32类型值</returns>
        public static Int32 ToInt32(Int16[] buff)
        {

            if (buff == null)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为Int32:失败，原因buff为NULL!"));
                return 0;
            }
            if (buff.Length != 2)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为Int32:失败，原因buff.Length={0}应为2!", buff.Length));
                return 0;
            }

            Int16 int16Value0 = Convert.ToInt16(buff[0]);
            Int16 int16Value1 = Convert.ToInt16(buff[1]);
            byte[] byteValues0 = BitConverter.GetBytes(int16Value0);
            byte[] byteValues1 = BitConverter.GetBytes(int16Value1);
            byte[] resultValues = new byte[4];
            resultValues[0] = byteValues0[0];
            resultValues[1] = byteValues0[1];
            resultValues[2] = byteValues1[0];
            resultValues[3] = byteValues1[1];
            Int32 result = BitConverter.ToInt32(resultValues, 0);
            return result;
        }



        /// <summary>
        /// 把长度为2的Int16类型的数组转换为Int32类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回Int32类型值</returns>
        public static Int32 ToInt32(int[] buff)
        {
            Int16[] buffResult = new Int16[buff.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buffResult[i] = Convert.ToInt16(buff[i]);
            }
            return ToInt32(buffResult);
        }

        /// <summary>
        /// 把2个Int16类型的数转换为Int32类型的值
        /// </summary>
        /// <param name="buff0">第一个Int16类型的参数</param>
        /// <param name="buff1">第二个Int16类型的参数</param>
        /// <returns>返回对应Int32类型的值</returns>
        public static Int32 ToInt32(Int16 buff0, Int16 buff1)
        {
            Int16 int16Value0 = Convert.ToInt16(buff0);
            Int16 int16Value1 = Convert.ToInt16(buff1);
            byte[] byteValues0 = BitConverter.GetBytes(int16Value0);
            byte[] byteValues1 = BitConverter.GetBytes(int16Value1);
            byte[] resultValues = new byte[4];
            resultValues[0] = byteValues0[0];
            resultValues[1] = byteValues0[1];
            resultValues[2] = byteValues1[0];
            resultValues[3] = byteValues1[1];
            Int32 result = BitConverter.ToInt32(resultValues, 0);
            return result;
        }

        #endregion-

        #endregion

        #region 把Int16[]转换为float类型变量

        #region 西门子PLC处理方法

        /// <summary>
        /// 把长度为2的Int16类型的数组转换为float类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回float类型值</returns>
        public static float ToSiemensFloat(Int16[] buff)
        {
            if (buff == null)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为float类型失败，原因buff为NULL!"));
                return 0.0f;
            }
            if (buff.Length != 2)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为float类型失败，原因buff.Length={0}应为2!", buff.Length));
                return 0.0f;
            }

            byte[] buff0Arr = BitConverter.GetBytes(buff[0]);
            byte[] buff1Arr = BitConverter.GetBytes(buff[1]);

            List<byte> lv = new List<byte>();
            lv.Add(buff0Arr[1]);
            lv.Add(buff0Arr[0]);
            lv.Add(buff1Arr[1]);
            lv.Add(buff1Arr[0]);
            lv.Reverse();
            float f = BitConverter.ToSingle(lv.ToArray<byte>(), 0);

            return f;
        }

        /// <summary>
        /// 把长度为2的Int16类型的数组转换为float类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回float类型值</returns>
        public static float ToSiemensFloat(int[] buff)
        {
            Int16[] buffResult = new Int16[buff.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buffResult[i] = Convert.ToInt16(buff[i]);
            }
            return ToSiemensFloat(buffResult);
        }

        /// <summary>
        /// 把2个Int16类型的整数转换为float类型的值
        /// </summary>
        /// <param name="buff0">第一个Int16类型参数</param>
        /// <param name="buff1">第二个Int16类型参数</param>
        /// <returns>返回对应float类型值</returns>
        public static float ToSiemensFloat(Int16 buff0, Int16 buff1)
        {
            byte[] buff0Arr = BitConverter.GetBytes(buff0);
            byte[] buff1Arr = BitConverter.GetBytes(buff1);

            List<byte> lv = new List<byte>();
            lv.Add(buff0Arr[1]);
            lv.Add(buff0Arr[0]);
            lv.Add(buff1Arr[1]);
            lv.Add(buff1Arr[0]);
            lv.Reverse();
            float f = BitConverter.ToSingle(lv.ToArray<byte>(), 0);

            return f;
        }

        #endregion

        #region 其他PLC处理方法

        /// <summary>
        /// 把长度为2的Int16类型的数组转换为float类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回float类型值</returns>
        public static float ToFloat(Int16[] buff)
        {
            if (buff == null)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为float类型失败，原因buff为NULL!"));
                return 0.0f;
            }
            if (buff.Length != 2)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为float类型失败，原因buff.Length={0}应为2!", buff.Length));
                return 0.0f;
            }

            byte[] buff0Arr = BitConverter.GetBytes(buff[0]);
            byte[] buff1Arr = BitConverter.GetBytes(buff[1]);

            List<byte> lv = new List<byte>();
            lv.Add(buff0Arr[0]);
            lv.Add(buff0Arr[1]);
            lv.Add(buff1Arr[0]);
            lv.Add(buff1Arr[1]);
            float f = BitConverter.ToSingle(lv.ToArray<byte>(), 0);

            return f;
        }

        /// <summary>
        /// 把长度为2的Int16类型的数组转换为float类型的值
        /// </summary>
        /// <param name="buff">长度为2的Int16类型的数组</param>
        /// <returns>返回float类型值</returns>
        public static float ToFloat(int[] buff)
        {
            Int16[] buffResult = new Int16[buff.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buffResult[i] = Convert.ToInt16(buff[i]);
            }
            return ToFloat(buffResult);
        }

        /// <summary>
        /// 把2个Int16类型的整数转换为float类型的值
        /// </summary>
        /// <param name="buff0">第一个Int16类型参数</param>
        /// <param name="buff1">第二个Int16类型参数</param>
        /// <returns>返回对应float类型值</returns>
        public static float ToFloat(Int16 buff0, Int16 buff1)
        {
            byte[] buff0Arr = BitConverter.GetBytes(buff0);
            byte[] buff1Arr = BitConverter.GetBytes(buff1);

            List<byte> lv = new List<byte>();
            lv.Add(buff0Arr[0]);
            lv.Add(buff0Arr[1]);
            lv.Add(buff1Arr[0]);
            lv.Add(buff1Arr[1]);
            float f = BitConverter.ToSingle(lv.ToArray<byte>(), 0);

            return f;
        }

        #endregion

        #endregion

        #region 把Int16[]转换为string类型变量

        /// <summary>
        /// 把Int16[]类型的数组转换为字符串(跳过标识字符串长度的前2个字节)
        /// </summary>
        /// <param name="buff">Int16类型的数组参数</param>
        /// <returns>返回转换后的字符串值</returns>
        public static string ToString(Int16[] buff)
        {
            if (buff == null || buff.Length <= 2)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为字符串失败，原因buff为NULL!"));
                return String.Empty;
            }
            List<byte> chars = new List<byte>();
            for (int i = 0; i < buff.Length; i++)           //跳过标识字符串长度的前2个字节
            {
                chars.AddRange(BitConverter.GetBytes(buff[i]));
            }

            string Result = string.Empty;
            Result = System.Text.Encoding.Default.GetString(chars.ToArray());
            Result = Result.Replace("\0", string.Empty);

            return Result.Trim();
        }

        //public static string ToString(Int16[] buff)
        //{
        //    if (buff == null || buff.Length <= 2)
        //    {
        //        ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为字符串失败，原因buff为NULL!"));
        //        return String.Empty;
        //    }
        //    List<byte> chars = new List<byte>();
        //    for (int i = 2; i < buff.Length; i++)           //跳过标识字符串长度的前2个字节
        //    {
        //        chars.AddRange(BitConverter.GetBytes(buff[i]));
        //    }

        //    string Result = string.Empty;
        //    Result = System.Text.Encoding.Default.GetString(chars.ToArray());
        //    Result = Result.Replace("\0", string.Empty);

        //    return Result.Trim();
        //}

        /// <summary>
        /// 把Int16类型的数组转换为字符串(跳过标识字符串长度的前2个字节)
        /// </summary>
        /// <param name="buff">Int16类型的数组参数</param>
        /// <returns>返回转换后的字符串值</returns>
        public static string ToString1(Int16[] buff)
        {
            if (buff == null || buff.Length <= 2)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为字符串失败，原因buff为NULL!"));
                return String.Empty;
            }
            List<byte> chars = new List<byte>();
            for (int i = 0; i < buff.Length; i++)           //跳过标识字符串长度的前2个字节
            {
                chars.AddRange(BitConverter.GetBytes(buff[i]));
            }

            string Result = string.Empty;
            Result = System.Text.Encoding.Default.GetString(chars.ToArray());
            Result = Result.Replace("\0", string.Empty);

            return Result.Trim();
        }

        #endregion

        #region 把Int32[]转换为string类型变量

        /// <summary>
        /// 把Int32类型的数组转换为字符串
        /// </summary>
        /// <param name="buff">Int32类型的数组参数</param>
        /// <returns>返回转换后的字符串值</returns>
        public static string ToString(int[] buff)
        {
            Int16[] buffResult = new Int16[buff.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buffResult[i] = (short)buff[i];
            }
            return ToString(buffResult);
        }

        /// <summary>
        /// 把Int32类型的数组转换为字符串
        /// </summary>
        /// <param name="buff">Int32类型的数组参数</param>
        /// <returns>返回转换后的字符串值</returns>
        public static string ToString1(int[] buff)
        {
            Int16[] buffResult = new Int16[buff.Length];
            for (int i = 0; i < buff.Length; i++)
            {
                buffResult[i] = (short)buff[i];
            }
            return ToString1(buffResult);
        }

        #endregion

        #region 把Int16[]转换为DateTime对象

        /// <summary>
        /// 把Int16类型的数组转换为DateTime对性爱那个
        /// </summary>
        /// <param name="buff">Int16类型的数组参数</param>
        /// <returns>返回转换后的DateTime对象</returns>
        public static DateTime ToDateTime(Int16[] buff)
        {
            if (buff == null)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为DateTime失败，原因buff为NULL!"));
                return new DateTime(1900, 1, 1, 0, 0, 0);
            }
            if (buff.Length != 6)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为DateTime失败，原因buff长度不等于6!"));
                return new DateTime(1900, 1, 1, 0, 0, 0);
            }
            DateTime dateResult = DateTime.Now;
            string strDate = String.Format("{0}-{1}-{2} {3}:{4}:{5}", buff[0], buff[1], buff[2], buff[3], buff[4], buff[5]);
            if (!DateTime.TryParse(strDate, out dateResult))
            {
                dateResult = DateTime.Now;
                //ICSharpCode.Core.LoggingService<DataProcessor>.Warn(String.Format("把PLC数据解析为DateTime失败!"));
            }
            return dateResult;
        }

        #endregion

        #endregion

        #region 把系统变量转换为要写入PLC的数据

        #region 把Int32转换为PLC数据

        #region 西门子PLC处理方法

        /// <summary>
        /// 把Int32类型的变量转换为Int16[]
        /// </summary>
        /// <param name="value">要转换的Int32类型变量</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToSiemensPLCInt16Array(Int32 value)
        {
            Int16[] buff = new Int16[2];
            for (int i = 0; i < buff.Length; i++)
            {
                buff[i] = 0;
            }
            byte[] byteValues = BitConverter.GetBytes(value);
            Int16[] intValues = new Int16[2];
            intValues[0] = System.Convert.ToInt16(System.Convert.ToString(byteValues[3], 2).PadLeft(8, '0') + System.Convert.ToString(byteValues[2], 2).PadLeft(8, '0'), 2);
            intValues[1] = System.Convert.ToInt16(System.Convert.ToString(byteValues[1], 2).PadLeft(8, '0') + System.Convert.ToString(byteValues[0], 2).PadLeft(8, '0'), 2);
            buff[0] = intValues[0];
            buff[1] = intValues[1];
            return buff;
        }

        /// <summary>
        /// 把Int32类型的变量转换为object[]
        /// </summary>
        /// <param name="value">要转换的Int32类型的变量</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToSiemensPLCDataArray(Int32 value)
        {
            Int16[] buff = ToSiemensPLCInt16Array(value);
            object[] result = new object[buff.Length];
            Array.Copy(buff, result, buff.Length);
            return result;
        }

        #endregion

        #region 其他PLC处理方法

        /// <summary>
        /// 把Int32类型的变量转换为Int16[]
        /// </summary>
        /// <param name="value">要转换的Int32类型变量</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToPLCInt16Array(Int32 value)
        {
            Int16[] buff = new Int16[2];
            for (int i = 0; i < buff.Length; i++)
            {
                buff[i] = 0;
            }
            byte[] byteValues = BitConverter.GetBytes(value);
            buff[0] = BitConverter.ToInt16(byteValues, 0);
            buff[1] = BitConverter.ToInt16(byteValues, 2);
            return buff;
        }

        /// <summary>
        /// 把Int32类型的变量转换为object[]
        /// </summary>
        /// <param name="value">要转换的Int32类型的变量</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToPLCDataArray(Int32 value)
        {
            Int16[] buff = ToPLCInt16Array(value);
            object[] result = new object[buff.Length];
            Array.Copy(buff, result, buff.Length);
            return result;
        }

        #endregion

        #endregion

        #region 把float转换为PLC数据

        #region 西门子PLC处理方法

        /// <summary>
        /// 把float类型的变量转换为Int16[]
        /// </summary>
        /// <param name="fvalue">要转换的float类型的变量</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToSiemensPLCInt16Array(float fvalue)
        {
            byte[] byteValues = BitConverter.GetBytes(fvalue);
            Int16[] intValues = new Int16[2];
            intValues[0] = System.Convert.ToInt16(System.Convert.ToString(byteValues[3], 2).PadLeft(8, '0') + System.Convert.ToString(byteValues[2], 2).PadLeft(8, '0'), 2);
            intValues[1] = System.Convert.ToInt16(System.Convert.ToString(byteValues[1], 2).PadLeft(8, '0') + System.Convert.ToString(byteValues[0], 2).PadLeft(8, '0'), 2);
            return intValues;
        }

        /// <summary>
        /// 把float类型的变量转换为object[]
        /// </summary>
        /// <param name="fvalue">要转换的float类型的变量</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToSiemensPLCDataArray(float fvalue)
        {
            Int16[] buff = ToSiemensPLCInt16Array(fvalue);
            object[] buffResult = new object[buff.Length];
            Array.Copy(buff, buffResult, buff.Length);
            return buffResult;
        }

        #endregion

        #region 其他PLC处理方法

        /// <summary>
        /// 把float类型的变量转换为Int16[]
        /// </summary>
        /// <param name="fvalue">要转换的float类型的变量</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToPLCInt16Array(float fvalue)
        {
            byte[] byteValues = BitConverter.GetBytes(fvalue);
            Int16[] intValues = new Int16[2];
            intValues[0] = BitConverter.ToInt16(byteValues, 0);
            intValues[1] = BitConverter.ToInt16(byteValues, 2);
            return intValues;
        }

        /// <summary>
        /// 把float类型的变量转换为object[]
        /// </summary>
        /// <param name="fvalue">要转换的float类型的变量</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToPLCDataArray(float fvalue)
        {
            Int16[] buff = ToPLCInt16Array(fvalue);
            object[] buffResult = new object[buff.Length];
            Array.Copy(buff, buffResult, buff.Length);
            return buffResult;
        }

        #endregion

        #endregion

        #region 把String转换为PLC数据

        /// <summary>
        /// 把字符串变量转换为Int16[]
        /// </summary>
        /// <param name="str">要转换的字符串变量</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToPLCInt16Array(string str)
        {
            byte[] temp = System.Text.Encoding.Default.GetBytes(str);
            Int32 charLen = temp.Length;
            object[] lenBuff = ToSiemensPLCDataArray(charLen);

            Int16[] buff = new Int16[temp.Length / 2 + temp.Length % 2];
            if (temp.Length % 2 == 0)
            {
                for (int i = 0; i < buff.Length; i++)
                {
                    buff[i] = BitConverter.ToInt16(temp, i * 2);
                }
            }
            else
            {
                byte[] temp1 = new byte[temp.Length + 1];
                Array.Copy(temp, temp1, temp.Length);
                for (int i = 0; i < buff.Length; i++)
                {
                    buff[i] = BitConverter.ToInt16(temp1, i * 2);
                }
            }

            //cfm20210804修改
            //Int16[] buffResult = new Int16[buff.Length + lenBuff.Length];
            //Array.Copy(lenBuff, buffResult, lenBuff.Length);                    //预留2个字节的位置保存字符串的实际长度
            //Array.Copy(buff, 0, buffResult, lenBuff.Length, buff.Length);
            //return buffResult;
            return buff;
        }

        /// <summary>
        /// 把字符串变量转换为object[]
        /// </summary>
        /// <param name="str">要转换的字符串变量</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToPLCDataArray(string str)
        {
            Int16[] buff = ToPLCInt16Array(str);
            object[] buffResult = new object[buff.Length];
            Array.Copy(buff, buffResult, buff.Length);
            return buffResult;
        }

        /// <summary>
        /// 把字符串变量转换为Int16[]
        /// </summary>
        /// <param name="str">要转换的字符串变量</param>
        /// <param name="length">要补够的长度</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static object[] ToPLCDataArray(string str, int length)
        {
            object[] buff = ToPLCDataArray(str);

            #region 补够长度

            object[] buffResult = new object[length];
            for (int i = 0; i < buffResult.Length; i++)
            {
                buffResult[i] = 0;
            }

            Array.Copy(buff, buffResult, buff.Length);

            #endregion

            return buffResult;
        }

        #endregion

        #region 把DateTime转换为PLC数据

        /// <summary>
        /// 把日期时间对象转换为Int16[]
        /// </summary>
        /// <param name="dtNow">要转换的日期时间对象</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToPLCInt16Array(DateTime dtNow)
        {
            Int16[] buff = new Int16[] { (short)dtNow.Year, (short)dtNow.Month, (short)dtNow.Day, (short)dtNow.Hour, (short)dtNow.Minute, (short)dtNow.Second };
            return buff;
        }

        /// <summary>
        /// 把日期时间对象转换为object[]
        /// </summary>
        /// <param name="dtNow">要转换的日期时间对象</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToPLCDataArray(DateTime dtNow)
        {
            Int16[] buff = ToPLCInt16Array(dtNow);

            object[] buffResult = new object[buff.Length];
            Array.Copy(buff, buffResult, buff.Length);

            return buffResult;
        }

        #endregion

        #region 把Time字符串转换为PLC数据

        /// <summary>
        /// 把Time字符串对象转换为Int16[]
        /// </summary>
        /// <param name="timeStr">要转换的日期时间对象</param>
        /// <returns>返回转换后的Int16[]</returns>
        public static Int16[] ToPLCInt16ArrayFromTimeStr(string timeStr)
        {
            Int16[] buff = new Int16[] { 0, 0, 0 };
            string[] times = timeStr.Split(new char[] { ':' });
            if (times.Length != 3)
            {
                ICSharpCode.Core.LoggingService<DataProcessor>.Error("把Time字符串转为Int[]失败，格式不正确，请确保时间是以':'分隔的时、分、秒构成!");
                return buff;
            }
            else
            {
                Int16.TryParse(times[0], out buff[0]);
                Int16.TryParse(times[1], out buff[1]);
                Int16.TryParse(times[2], out buff[2]);
                return buff;
            }
        }

        /// <summary>
        /// 把Time字符串对象转换为object[]
        /// </summary>
        /// <param name="timeStr">要转换的Time字符串对象</param>
        /// <returns>返回转换后的object[]</returns>
        public static object[] ToPLCDataArrayFromTimeStr(string timeStr)
        {
            Int16[] buff = ToPLCInt16ArrayFromTimeStr(timeStr);

            object[] buffResult = new object[buff.Length];
            Array.Copy(buff, buffResult, buff.Length);

            return buffResult;
        }

        #endregion

        #endregion

        #region 类型转换

        /// <summary>
        /// 将一个对象转换为指定类型
        /// </summary>
        /// <param name="obj">待转换的对象</param>
        /// <param name="type">目标类型</param>
        /// <returns>转换后的对象</returns>
        public static object ChangeType(object obj, Type type)
        {
            if (type == null) return obj;
            if (obj == null) return type.IsValueType ? Activator.CreateInstance(type) : null;

            Type underlyingType = Nullable.GetUnderlyingType(type);
            if (type.IsAssignableFrom(obj.GetType())) // 如果待转换对象的类型与目标类型兼容，则无需转换
            {
                return obj;
            }
            else if ((underlyingType ?? type).IsEnum) // 如果待转换的对象的基类型为枚举
            {
                if (underlyingType != null && string.IsNullOrEmpty(obj.ToString())) // 如果目标类型为可空枚举，并且待转换对象为null 则直接返回null值
                {
                    return null;
                }
                else
                {
                    return Enum.Parse(underlyingType ?? type, obj.ToString());
                }
            }
            else if (typeof(IConvertible).IsAssignableFrom(underlyingType ?? type)) // 如果目标类型的基类型实现了IConvertible，则直接转换
            {
                try
                {
                    return Convert.ChangeType(obj, underlyingType ?? type, null);
                }
                catch
                {
                    return underlyingType == null ? Activator.CreateInstance(type) : null;
                }
            }
            else
            {
                TypeConverter converter = TypeDescriptor.GetConverter(type);
                if (converter.CanConvertFrom(obj.GetType()))
                {
                    return converter.ConvertFrom(obj);
                }
                ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);
                if (constructor != null)
                {
                    object o = constructor.Invoke(null);
                    PropertyInfo[] propertys = type.GetProperties();
                    Type oldType = obj.GetType();
                    foreach (PropertyInfo property in propertys)
                    {
                        PropertyInfo p = oldType.GetProperty(property.Name);
                        if (property.CanWrite && p != null && p.CanRead)
                        {
                            property.SetValue(o, ChangeType(p.GetValue(obj, null), property.PropertyType), null);
                        }
                    }
                    return o;
                }
            }
            return obj;
        }

        #endregion

        #region 二进制操作方法

        #region 二进制位操作

        /// <summary>
        /// 对Int16数据的指定起始位指定长度的二进制位赋值
        /// </summary>
        /// <param name="x">源Int16数据</param>
        /// <param name="startIndex">二进制起始位，从0开始（低位->高位）</param>
        /// <param name="length">要操作的长度</param>
        /// <param name="value">要写入的值</param>
        /// <returns>返回二进制操作后的数据</returns>
        public static Int16 SetBitValue(Int16 x, int startIndex, int length, Int16 value)
        {
            int totalLen = 16;
            string original = FillZero(Convert.ToString(x, 2), totalLen);
            if (Convert.ToString(value, 2).Length > length)
            {
                string msg = "对数据的二进制操作失败，要写入的值超过了要操作的二进制长度!";
                ICSharpCode.Core.LoggingService<DataProcessor>.Error(msg);
                throw new Exception();
            }
            string param = FillZero(Convert.ToString(value, 2), length);
            string result = original.Substring(0, totalLen - (startIndex + length)) + param + original.Substring(totalLen - startIndex);
            return Convert.ToInt16(result, 2);
        }

        /// <summary>
        /// 对object数据的指定起始位指定长度的二进制位赋值
        /// </summary>
        /// <param name="x">源object数据</param>
        /// <param name="startIndex">二进制起始位，从0开始（低位->高位）</param>
        /// <param name="length">要操作的长度</param>
        /// <param name="value">要写入的值</param>
        /// <returns>返回二进制操作后的数据</returns>
        public static object SetBitValue(object x, int startIndex, int length, object value)
        {
            Int16 intX = Convert.ToInt16(x);
            Int16 intValue = Convert.ToInt16(value);
            return SetBitValue(intX, startIndex, length, intValue);
        }

        /// <summary>
        /// 对Int32数据的指定起始位指定长度的二进制位赋值
        /// </summary>
        /// <param name="x">源Int32数据</param>
        /// <param name="startIndex">二进制起始位，从0开始（低位->高位）</param>
        /// <param name="length">要操作的长度</param>
        /// <param name="value">要写入的值</param>
        /// <returns>返回二进制操作后的数据</returns>
        public static Int32 SetBitValue32(Int32 x, int startIndex, int length, Int32 value)
        {
            int totalLen = 32;
            string original = FillZero(Convert.ToString(x, 2), totalLen);
            if (Convert.ToString(value, 2).Length > length)
            {
                string msg = "对数据的二进制操作失败，要写入的值超过了要操作的二进制长度!";
                ICSharpCode.Core.LoggingService<DataProcessor>.Error(msg);
                throw new Exception();
            }
            string param = FillZero(Convert.ToString(value, 2), length);
            string result = original.Substring(0, totalLen - (startIndex + length)) + param + original.Substring(totalLen - startIndex);
            return Convert.ToInt32(result, 2);
        }

        /// <summary>
        /// 对object数据的指定起始位指定长度的二进制位赋值
        /// </summary>
        /// <param name="x">源object数据</param>
        /// <param name="startIndex">二进制起始位，从0开始（低位->高位)</param>
        /// <param name="length">要操作的长度</param>
        /// <param name="value">要写入的值</param>
        /// <returns>返回二进制操作后的数据</returns>
        public static object SetBitValue32(object x, int startIndex, int length, object value)
        {
            Int32 intX = Convert.ToInt32(x);
            Int32 intValue = Convert.ToInt32(value);
            return SetBitValue32(intX, startIndex, length, intValue);
        }

        #endregion

        #region 二进制位操作辅助方法

        /// <summary>
        /// 高8位低8位转换（byte[0]byte[1]->byte[1]byte[0]）
        /// </summary>
        /// <param name="a">要进行高低位转换的Int16类型变量</param>
        /// <returns>返回转换后的值</returns>
        public static Int16 Swap(Int16 a)
        {
            byte[] orignalData = BitConverter.GetBytes(a);
            List<byte> lst = new List<byte>();
            for (int i = 0; i < orignalData.Length; i++)
            {
                lst.Add(orignalData[i]);
            }
            lst.Reverse();
            Int16 newData = BitConverter.ToInt16(lst.ToArray(), 0);
            return newData;
        }

        /// <summary>
        /// 高低位转换（byte[0]byte[1]byte[2]byte[3]->byte[3]byte[2]byte[1]byte[0]）
        /// </summary>
        /// <param name="a">要进行高低位转换的Int32类型变量</param>
        /// <returns>返回转换后的值</returns>
        public static int Swap(int a)
        {
            byte[] orignalData = BitConverter.GetBytes(a);
            List<byte> lst = new List<byte>();
            for (int i = 0; i < orignalData.Length; i++)
            {
                lst.Add(orignalData[i]);
            }
            lst.Reverse();
            int newData = BitConverter.ToInt32(lst.ToArray(), 0);
            return newData;
        }

        #endregion

        #region 解析二进制位

        /// <summary>
        /// 解析二进制位
        /// </summary>
        /// <param name="x">要解析的变量</param>
        /// <param name="len">解析的长度</param>
        /// <returns>返回解析的二进制值数组</returns>
        public static int[] ParseBinaryValue(int x, int len)
        {
            int[] result = new int[len];
            int b = 1;
            for (int i = 0; i < len; i++)
            {
                result[i] = (x & b) == 0 ? 0 : 1;
                b = b << 1;
            }
            return result;
        }

        #endregion

        #endregion
    }
}