mes-client/UAS-MES/PublicMethod/BaseUtil.cs

using LabelManager2;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.DataVisualization.Charting;
using System.Xml;
using UAS_MES.CustomControl.DataGrid_View;
using UAS_MES.CustomControl.GroupBoxWithBorder;
using UAS_MES.CustomControl.TextBoxWithIcon;
using UAS_MES.CustomControl.ValueLabel;
using UAS_MES.Entity;
using static System.Windows.Forms.Control;

namespace UAS_MES.PublicMethod
{
    class BaseUtil
    {
        /// <summary>
        /// 通过DataTable的ColumnName和Caption来拼接一条语句
        /// </summary>
        /// <param name=""></param>
        /// <returns></returns>
        public static string GetGridViewSelectContent(DataGridView d)
        {
            StringBuilder selectConetnt = new StringBuilder();
            DataTable dt = (DataTable)d.DataSource;
            if (dt == null)
            {
                foreach (DataGridViewColumn dc in d.Columns)
                {
                    if (dc.DataPropertyName != "" && dc.DataPropertyName != null)
                    {
                        selectConetnt.Append(dc.Name + " as " + dc.Name + ",");
                    }
                }
            }
            else
            {
                foreach (DataColumn dc in dt.Columns)
                {
                    selectConetnt.Append(dc.Caption + " as " + dc.ColumnName + ",");
                }
            }
            return selectConetnt.Remove(selectConetnt.Length - 1, 1).ToString();
        }

        /// <summary>
        /// 禁止DataGirdView排序
        /// </summary>
        /// <param name="Dgv"></param>
        public static void DataGridViewNotSort(DataGridView Dgv)
        {
            foreach (DataGridViewColumn item in Dgv.Columns)
                item.SortMode = DataGridViewColumnSortMode.NotSortable;
        }

        public static string GetLocalIP()
        {
            try
            {
                string HostName = Dns.GetHostName(); //得到主机名  
                IPHostEntry IpEntry = Dns.GetHostEntry(HostName);
                for (int i = 0; i < IpEntry.AddressList.Length; i++)
                {
                    //从IP地址列表中筛选出IPv4类型的IP地址  
                    //AddressFamily.InterNetwork表示此IP为IPv4,  
                    //AddressFamily.InterNetworkV6表示此地址为IPv6类型  
                    if (IpEntry.AddressList[i].AddressFamily == AddressFamily.InterNetwork)
                    {
                        return IpEntry.AddressList[i].ToString();
                    }
                }
                return "";
            }
            catch (Exception ex)
            {
                MessageBox.Show("获取本机IP出错:" + ex.Message);
                return "";
            }
        }

        /// <summary>
        /// 通过字段和其展示的中文值获取查询的内容
        /// </summary>
        /// <param name="field"></param>
        /// <param name="cnfield"></param>
        /// <returns></returns>
        public static string GetSelectContentByStringArray(string[] field, string[] cnfield)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < field.Length; i++)
            {
                sb.Append(field[i] + " as " + cnfield[i] + ",");
            }
            //去掉多余的逗号
            sb.Remove(sb.Length - 1, 1);
            return sb.ToString();
        }

        /// <summary>
        ///  传入控件的集合和DataTable，通过判断控件的名称和数据源的列的描述来匹配，支持单层的GroupBox和Panel
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="dt"></param>
        public static void SetFormValue(ControlCollection collection, DataTable dt)
        {
            //DataTable存在数据才进行赋值操作
            if (dt.Rows.Count > 0)
            {
                for (int i = 0; i < collection.Count; i++)
                {
                    //如果含有子控件则进行递归调用
                    if (collection[i].Controls.Count > 0)
                        SetFormValue(collection[i].Controls, dt);
                    string controlName = collection[i].Name;
                    string controlsTag = collection[i].Tag == null ? "" : collection[i].Tag.ToString();
                    //默认给TextBox和Label赋值
                    if (collection[i] is TextBox || collection[i] is Label || collection[i] is SearchTextBox || collection[i] is MaCodeSearchTextBox || collection[i] is EnterTextBox || collection[i] is TextBoxGeneratePaCode || collection[i] is NumericUpDown)
                    {
                        for (int j = 0; j < dt.Columns.Count; j++)
                        {
                            if (controlName.ToUpper() == dt.Columns[j].Caption.ToUpper() || controlsTag.ToUpper() == dt.Columns[j].Caption.ToUpper())
                            {
                                //字段含有Status内容的才进行转换
                                if (controlName.ToUpper().Contains("STATUS") || controlsTag.ToUpper().Contains("STATUS"))
                                {
                                    //对审批状态进行判断
                                    switch (dt.Rows[0][j].ToString().ToUpper())
                                    {
                                        case "ENTERING":
                                            collection[i].Text = "在录入";
                                            break;
                                        case "UNAPPROVED":
                                            collection[i].Text = "未批准";
                                            break;
                                        case "COMMITED":
                                            collection[i].Text = "已提交";
                                            break;
                                        case "APPROVE":
                                            collection[i].Text = "已批准";
                                            break;
                                        case "AUDITED":
                                            collection[i].Text = "已审核";
                                            break;
                                        case "STARTED":
                                            collection[i].Text = "已下放";
                                            break;
                                        case "UNCHECK":
                                            collection[i].Text = "待检验";
                                            break;
                                        case "CHECKING":
                                            collection[i].Text = "检验中";
                                            break;
                                        default:
                                            collection[i].Text = dt.Rows[0][j].ToString();
                                            break;
                                    }
                                }
                                else
                                    collection[i].Text = dt.Rows[0][j].ToString();
                            }
                        }
                    }
                    //对封装在GroupBox的和Panel的控件进行批量赋值
                    if (collection[i] is GroupBox || collection[i] is Panel || collection[i] is GroupBoxWithBorder)
                    {
                        for (int j = 0; j < collection[i].Controls.Count; j++)
                        {
                            controlName = collection[i].Controls[j].Name;
                            if (collection[i].Controls[j] is TextBox || collection[i].Controls[j] is Label || collection[i].Controls[j] is SearchTextBox || collection[i].Controls[j] is MaCodeSearchTextBox)
                            {
                                for (int k = 0; k < dt.Columns.Count; k++)
                                {
                                    if (controlName.ToUpper() == dt.Columns[k].Caption.ToUpper())
                                    {
                                        collection[i].Controls[j].Text = dt.Rows[0][k].ToString();
                                    }
                                }
                            }
                        }
                    }
                }
            }
            //如果没有记录的话，将dt中含有的列的对应值设置为空
            else
            {
                for (int i = 0; i < collection.Count; i++)
                {
                    if (collection[i] is TextBox || collection[i] is Label || collection[i] is SearchTextBox)
                    {
                        for (int j = 0; j < dt.Columns.Count; j++)
                        {
                            if (collection[i].Name.ToUpper() == dt.Columns[j].Caption.ToUpper())
                            {
                                collection[i].Text = "";
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 获取打印标签
        /// </summary>
        /// <param name="labelName"></param>
        /// <param name="labelUrl"></param>
        /// <param name="indate"></param>
        public static void GetPrintLabel(string labelName, string labelUrl, string indate)
        {
            string LabelUrl = labelUrl;
            string LabelName = labelName;
            System.DateTime time = Convert.ToDateTime(indate);
            FileInfo file = new FileInfo(ftpOperater.DownLoadTo + LabelName);
            if (time.ToString() != file.LastWriteTime.ToString())
                BaseUtil.GetLabelUrl(LabelUrl, LabelName, time);
        }

        /// <summary>
        /// 获取标签的路径
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="LabelName"></param>
        /// <param name="time"></param>
        /// <returns></returns>
        public static string GetLabelUrl(string URL, string LabelName, System.DateTime time)
        {
             ftpOperater ftp = new ftpOperater();
             return ftp.DownLoadFromSharePath(URL, LabelName);        
        }


        /// <summary>
        /// 移除重复行
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="field"></param>
        /// <returns></returns>
        public static DataTable DeleteSameRow(DataTable dt, string field)
        {
            ArrayList indexList = new ArrayList();
            // 找出待删除的行索引   
            for (int i = 0; i < dt.Rows.Count - 1; i++)
            {
                if (!IsContain(indexList, i))
                {
                    for (int j = i + 1; j < dt.Rows.Count; j++)
                    {
                        if (dt.Rows[i][field].ToString() == dt.Rows[j][field].ToString())
                        {
                            indexList.Add(j);
                        }
                    }
                }
            }
            indexList.Sort();
            // 排序
            for (int i = indexList.Count - 1; i >= 0; i--)// 根据待删除索引列表删除行  
            {
                int index = Convert.ToInt32(indexList[i]);
                dt.Rows.RemoveAt(index);
            }
            return dt;
        }

        /// <summary>   
        /// 判断数组中是否存在   
        /// </summary>   
        /// <param name="indexList">数组</param>   
        /// <param name="index">索引</param>   
        /// <returns></returns>   
        public static bool IsContain(ArrayList indexList, int index)
        {
            for (int i = 0; i < indexList.Count; i++)
            {
                int tempIndex = Convert.ToInt32(indexList[i]);
                if (tempIndex == index)
                {
                    return true;
                }
            }
            return false;
        }

        //播放音频文件
        public static void PlaySound(string FileName)
        {
            //要加载COM组件:Microsoft speech object Library    
            if (!System.IO.File.Exists(FileName))
            {
                return;
            }
            SpeechLib.SpVoiceClass pp = new SpeechLib.SpVoiceClass();
            SpeechLib.SpFileStreamClass spFs = new SpeechLib.SpFileStreamClass();
            spFs.Open(FileName, SpeechLib.SpeechStreamFileMode.SSFMOpenForRead, true);
            SpeechLib.ISpeechBaseStream Istream = spFs as SpeechLib.ISpeechBaseStream;
            pp.SpeakStream(Istream, SpeechLib.SpeechVoiceSpeakFlags.SVSFIsFilename);
            spFs.Close();
        }

        /// <summary>
        /// 从DGV获取指定的列的数据形式是数组的形式
        /// </summary>
        public static ArrayList[] GetColumnDataFromDGV(DataGridView dgv, string[] ColumnName)
        {
            ArrayList[] array = new ArrayList[ColumnName.Length];
            //实例化和查询参数个数一样的ArrayList
            for (int i = 0; i < ColumnName.Length; i++)
            {
                array[i] = new ArrayList();
            }
            DataTable dt = (DataTable)dgv.DataSource;
            //如果第一列是否选框的话
            if (dgv.Columns[0] is DataGridViewCheckBoxColumn)
            {
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    if (dgv.Rows[i].Cells[0].FormattedValue.ToString() == "True")
                    {

                        for (int j = 0; j < ColumnName.Length; j++)
                        {
                            array[j].Add(dt.Rows[i][ColumnName[j]]);
                        }
                    }
                }
            }
            //否则直接获取全部的数据
            else
            {
                for (int i = 0; i < dgv.RowCount; i++)
                {
                    for (int j = 0; j < ColumnName.Length; j++)
                    {
                        array[j].Add(dt.Rows[i][ColumnName[j]]);
                    }
                }
            }
            return array;
        }

        /// <summary>
        /// 通过DataGridView和需要隐藏的字段的数组来对字段进行隐藏
        /// </summary>
        /// <param name="dgv"></param>
        /// <param name="field"></param>
        public static void HideField(DataGridView dgv, string[] field)
        {
            DataTable dt = (DataTable)dgv.DataSource;
            foreach (DataColumn dc in dt.Columns)
            {
                foreach (string s in field)
                {
                    if (dc.Caption == s)
                        dgv.Columns[dc.ColumnName].Visible = false;
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="dgv"></param>
        public static void ExpandDGVCheck(DataGridViewExpand dgv, DataGridViewCellEventArgs e)
        {
            if (e.ColumnIndex == 0 && e.RowIndex >= 0)
            {
                if (dgv.Rows[e.RowIndex] is CollapseDataGridViewRow)
                {
                    int CollapseRowCount = (dgv.Rows[e.RowIndex] as CollapseDataGridViewRow).Rows.Count;
                    if (CollapseRowCount > 0)
                    {
                        for (int i = (e.RowIndex + 2); i < (e.RowIndex + 1 + CollapseRowCount); i++)
                        {
                            try
                            {
                                dgv.Rows[i].Cells[0].Value = dgv.Rows[e.RowIndex].Cells[0].EditedFormattedValue;
                            }
                            catch (Exception) { }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 通过查询的内容获取到字段的描述
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public static string[] GetCaptionFromField(string field)
        {
            string[] caption = field.Split(',');
            for (int i = 0; i < caption.Length; i++)
            {
                caption[i] = caption[i].Substring(0, caption[i].LastIndexOf("as")).Trim();
            }
            return caption;
        }

        /// <summary>
        /// 通过查询的语句获取查询的字段
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public static string[] GetField(string field)
        {
            string[] fields = field.Split(',');
            for (int i = 0; i < fields.Length; i++)
            {
                fields[i] = fields[i].Substring(fields[i].LastIndexOf("as") + 2, fields[i].Length - fields[i].LastIndexOf("as") - 2).Trim();
            }
            return fields;
        }

        /// <summary>
        /// 通过描述取DataTable的列名，主要用于从配置中取数据
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="caption"></param>
        /// <returns></returns>
        public static string GetColumnNameByCaption(DataTable dt, string caption)
        {
            foreach (DataColumn dc in dt.Columns)
            {
                if (dc.Caption.ToLower() == caption)
                {
                    return dc.ColumnName;
                }
            }
            return null;
        }

        //用于封装异常，也可以用于错误的提示
        public static void ShowError(string errorMessage)
        {
            throw new Exception(errorMessage);
        }

        /// <summary>
        /// 判断控件的某个事件是否已经绑定了方法
        /// </summary> 
        /// <param name="Control1"></param>
        /// <param name="EventName"></param>
        /// <returns></returns>
        public static bool ControlHasEvent(Control Control1, string EventName)
        {
            //需要查询的内容
            BindingFlags myBindingFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            Assembly a = Assembly.GetAssembly(Control1.GetType());
            Type t = a.GetType(Control1.GetType().FullName, true);
            //获取控件的事件
            FieldInfo fi = t.GetField(EventName, myBindingFlags);
            EventHandlerList ehl = Control1.GetType().GetProperty("Events", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy).GetValue(Control1, null) as EventHandlerList;
            //判断事件的委托数量是否大于0
            if (ehl != null)
            {
                Delegate d = ehl[fi.GetValue(Control1)];
                if (d != null && d.GetInvocationList().Length > 0)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 获取控件的事件列表
        /// </summary>
        /// <param name="Control1"></param>
        /// <returns></returns>
        public static FieldInfo[] GetControlsEvent(Control Control1)
        {
            BindingFlags myBindingFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            Assembly a = Assembly.GetAssembly(Control1.GetType());
            Type t = a.GetType(Control1.GetType().FullName, true);
            FieldInfo[] finf = t.GetFields(myBindingFlags);
            return finf;
        }

        /// <summary>
        /// 清除DataTable的结构和数据,清除列结构时需要从最后的一列开始删
        /// </summary>
        /// <param name="dt"></param>
        public static void CleanDataTable(DataTable dt)
        {
            for (int i = dt.Columns.Count - 1; i >= 0; i--)
                dt.Columns.Remove(dt.Columns[i]);
        }

        /// <summary>
        /// 获取标签的路径
        /// </summary>
        /// <param name="URL"></param>
        /// <param name="LabelName"></param>
        /// <returns></returns>
        public static string GetLabelUrl(string URL, string LabelName)
        {
            ftpOperater ftp = new ftpOperater();
            return ftp.DownLoadFromSharePath(URL, LabelName);
        }

        /// <summary>
        /// 往DataTable中添加数据
        /// </summary>
        public static void AddDataToDataTable(DataTable dt, params string[] param)
        {
            DataRow dr = dt.NewRow();
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                dr[dt.Columns[i].ColumnName] = param[i];
            }
        }

        /// <summary>
        /// 不清除表结构，只清除数据
        /// </summary>
        /// <param name="dt"></param>
        public static void CleanDataTableData(DataTable dt)
        {
            for (int i = dt.Rows.Count - 1; i >= 0; i--)
            {
                dt.Rows.Remove(dt.Rows[i]);
            }
        }
        /// <summary>
        /// 获取拼接的字段
        /// </summary>
        /// <param name="dt"></param>
        /// <returns></returns>
        public static string GetFieldFromDataTable(DataTable dt)
        {
            StringBuilder sb = new StringBuilder();
            foreach (DataColumn dc in dt.Columns)
            {
                sb.Append(dc.Caption + ",");
            }
            return sb.ToString().Substring(sb.ToString().Length - 1, 1);
        }

        /// <summary>
        /// 已经定义好的DataGridView绑定数据,operate是用来添加操作列的
        /// </summary>
        /// <param name="dgv"></param>
        /// <param name="dt"></param>
        /// <param name="AddOpetateColumn"></param>
        /// <param name="operate"></param>
        public static void FillDgvWithDataTable(DataGridView dgv, DataTable dt, params DataGridViewImageColumn[] operate)
        {
            dgv.AutoGenerateColumns = false;
            dgv.DataSource = dt;
            if (operate.Length > 0)
            {
                if (dgv.Columns[operate[0].Name] != null)
                {
                    dgv.Columns.Remove(dgv.Columns[operate[0].Name]);
                }
                dgv.Columns.Add(operate[0]);
            }
            ////纯英文的列不予展示
            //Regex regEnglish = new Regex("^[A-z]+$");
            //foreach (DataGridViewColumn dgvc in dgv.Columns)
            //{
            //    if (regEnglish.IsMatch(dgvc.HeaderText))
            //    {
            //        dgvc.Visible = false;
            //    }
            //}
        }

        /// <summary>
        /// 清除DataGridView的数据
        /// </summary>
        /// <param name="dgv"></param>
        public static void CleanDGVData(DataGridView dgv)
        {
            for (int i = dgv.Rows.Count - 1; i >= 0; i--)
            {
                dgv.Rows.RemoveAt(i);
            }
        }

        public static void CleanForm(Form Form)
        {
            for (int i = 0; i < Form.Controls.Count; i++)
            {
                if (Form.Controls[i] is EnterTextBox || Form.Controls[i] is TextBox || Form.Controls[i] is ValueLabel || Form.Controls[i] is SearchTextBox || Form.Controls[i] is ValueNumLabel || Form.Controls[i] is MaCodeSearchTextBox)
                    Form.Controls[i].Text = "";
                if (Form.Controls[i] is DataGridView)
                    CleanDGVData((DataGridView)Form.Controls[i]);
            }
        }

        public static void CleanControlsText(params Control[] ctl)
        {
            foreach (Control item in ctl)
                item.Text = "";
        }

        /// <summary>
        /// 需要SQL的顺序和DGV的列的顺序一致
        /// </summary>
        /// <param name="dgv"></param>
        /// <param name="dt"></param>
        /// <param name="CheckBox"></param>
        public static void FillExpandDgvWithDataTable(DataGridViewExpand dgv, DataTable dt, bool CheckBox, bool CheckBoxTrue)
        {
            CleanDGVData(dgv);
            if (CheckBox)
            {
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    CollapseDataGridViewRow collapseRow = new CollapseDataGridViewRow();
                    collapseRow.IsCollapse = true;
                    DataGridViewCheckBoxCell checkcell = new DataGridViewCheckBoxCell();
                    collapseRow.Cells.Add(checkcell);
                    checkcell.Value = CheckBoxTrue;
                    //因为DGV中可能有空置的列多出，所以需要用DataTable的列进行循环
                    for (int j = 0; j < dt.Columns.Count; j++)
                    {
                        DataGridViewTextBoxCell textcell = new DataGridViewTextBoxCell();
                        textcell.Value = dt.Rows[i][j].ToString();
                        collapseRow.Cells.Add(textcell);
                        textcell.ReadOnly = true;
                    }
                    collapseRow.Tag = "MainRow";
                    dgv.Rows.Add(collapseRow);
                }
            }
            else
            {
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    CollapseDataGridViewRow collapseRow = new CollapseDataGridViewRow();
                    collapseRow.IsCollapse = true;
                    for (int j = 1; j <= dt.Columns.Count; j++)
                    {
                        DataGridViewTextBoxCell textcell = new DataGridViewTextBoxCell();
                        textcell.Value = dt.Rows[i][j - 1].ToString();
                        collapseRow.Cells.Add(textcell);
                    }
                    dgv.Rows.Add(collapseRow);
                    collapseRow.ReadOnly = true;
                }
            }
        }

        /// <summary>
        /// 用于给DGV中的Combox列赋静态值
        /// </summary>
        /// <param name="dgvc"></param>
        /// <param name="displayField"></param>
        /// <param name="valueField"></param>
        /// <param name="Value"></param>
        /// <returns></returns>
        public static void SetDgvColumnComboxData(DataGridViewComboBoxColumn dgvc, string DataPropertyName, string displayField, string valueField, string[] Value)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add(displayField);
            dt.Columns.Add(valueField);
            for (int i = 0; i < Value.Length; i++)
            {
                DataGridViewRow row = new DataGridViewRow();
                dt.Rows.Add(row);
                dt.Rows[i][displayField] = Value[i].Split('#')[0];
                dt.Rows[i][valueField] = Value[i].Split('#')[1];
            }
            dgvc.DataPropertyName = DataPropertyName;
            dgvc.DataSource = dt;
            dgvc.DisplayMember = displayField;
            dgvc.ValueMember = valueField;
        }

        /// <summary>
        /// 用于给DGV中的ComboxCell赋静态值
        /// </summary>
        /// <param name="dgvcc"></param>
        /// <param name="displayField"></param>
        /// <param name="valueField"></param>
        /// <param name="Value"></param>
        public static void SetDGVCellComboxData(DataGridViewComboBoxCell dgvcc, string displayField, string valueField, string[] Value)
        {
            DataTable dt = new DataTable();
            dt.Columns.Add(displayField);
            dt.Columns.Add(valueField);
            for (int i = 0; i < Value.Length; i++)
            {
                DataRow dr = dt.NewRow();
                dr[displayField] = Value[i].Split('#')[0];
                dr[valueField] = Value[i].Split('#')[1];
                dt.Rows.Add(dr);
            }
            dgvcc.DisplayMember = displayField;
            dgvcc.ValueMember = valueField;
            dgvcc.DataSource = dt;
        }
        /// <summary>
        /// 获取刷选的SQL语句，传入的是TextBox的Control，传入的SQL不带Where条件
        /// </summary>
        /// <param name="SQL"></param>
        /// <param name="Condition"></param>
        /// <returns></returns>
        public static string GetScreenSqlCondition(params Control[] Condition)
        {
            string condition = "";
            //用于统计传入的控件的空值数
            int EmptyControlCount = 0;
            for (int i = 0; i < Condition.Length; i++)
            {
                //如果Text不为空再进行条件的拼接
                if (Condition[i].Text != "")
                {
                    if (Condition[i] is ComboBox)
                    {
                        condition += "(" + Condition[i].Tag + " like " + "'%" + (Condition[i] as ComboBox).SelectedValue + "%' )";
                    }
                    else
                    {
                        condition += "(" + Condition[i].Tag + " like " + "'%" + Condition[i].Text + "%' )";
                    }
                    //如果不是最后要判断之后有没有空值的如果有一个Text的值不为空都需要添加and
                    //添加了一次And之后跳出循环，因为如果后面多项有值会重复添加and
                    for (int j = i + 1; j < Condition.Length; j++)
                    {
                        if (j < Condition.Length)
                        {
                            if (Condition[j].Text != "")
                            {
                                condition += " and ";
                                break;
                            }
                        }
                    }
                }
                else
                {
                    EmptyControlCount = EmptyControlCount + 1;
                }
            }
            //如果所有的控件传入的都是空值则返回也为空
            if (EmptyControlCount == Condition.Length)
                return "";
            else
                condition = " where " + condition;
            return condition;
        }

        public static void CleanDataGridView(DataGridView dgv)
        {
            for (int i = dgv.Columns.Count - 1; i >= 0; i--)
            {
                dgv.Columns.RemoveAt(i);
            }
        }

        /// <summary>
        /// 取出SQL中的参数占位符
        /// </summary>
        /// <param name="SQL"></param>
        /// <returns></returns>
        public static string[] GetParamFromSQL(string SQL)
        {
            string[] par = SQL.Split(':');
            //用来存参数的数组
            StringBuilder[] addpar = new StringBuilder[par.Length - 1];
            string[] param = new string[par.Length - 1];
            for (int i = 0; i < par.Length - 1; i++)
            {
                //新建一个char类型的数组用来存储每个字节的变量
                char[] c = par[i + 1].ToCharArray();
                addpar[i] = new StringBuilder();
                for (int j = 0; j < c.Length; j++)
                {
                    if (c[j] != ' ' && c[j] != ',' && c[j] != ')')
                    {
                        addpar[i].Append(c[j]);
                    }
                    else
                    {
                        break;
                    }
                }
            }

            for (int i = 0; i < par.Length - 1; i++)
            {
                param[i] = addpar[i].ToString();
            }
            return param;
        }

        public static void SetFormCenter(Form form)
        {
            form.StartPosition = FormStartPosition.CenterParent;
        }

        /// <summary>
        /// 设置DataGridView的指定列可编辑
        /// </summary>
        /// <param name="DGV"></param>
        /// <param name="EditAbleField"></param>
        public static void SetDataGridViewReadOnly(DataGridView DGV, string[] EditAbleField)
        {
            foreach (DataGridViewColumn dc in DGV.Columns)
            {
                dc.ReadOnly = true;
                foreach (string s in EditAbleField)
                {
                    if (dc.Name.ToLower() == s.ToLower())
                    {
                        DGV.Columns[dc.Name].ReadOnly = false;
                    }
                }
            }
        }

        //判断带有CheckBox的DGV是否有项目勾选了
        public static DataTable DGVIfChecked(DataGridView dgv)
        {
            int CheckCount = 0;
            DataTable dt = new DataTable();
            //第一列是勾选框，排除在循环之外
            for (int i = 1; i < dgv.Columns.Count; i++)
            {
                dt.Columns.Add(dgv.Columns[i].Name);
            }
            for (int i = 0; i < dgv.RowCount; i++)
            {
                if (dgv.Rows[i].Cells[0].Value != null)
                {
                    if (dgv.Rows[i].Cells[0].FormattedValue.ToString() == "True")
                    {
                        if (dgv.Rows[i].Tag.ToString() == "SonRow")
                        {
                            DataRow dr = dt.NewRow();
                            for (int j = 1; j < dgv.ColumnCount; j++)
                            {
                                dr[dgv.Columns[j].Name] = dgv.Rows[i].Cells[j].FormattedValue;
                            }
                            dt.Rows.Add(dr);
                            CheckCount++;
                        }
                    }
                }
            }
            //判断是否勾选了明细
            if (CheckCount == 0)
                return null;
            return dt;
        }

        public static void GetExpandDGVCheckedRow(DataGridView dgv, DataTable dt, int RowIndex, int DistinctColumnIndex)
        {
            //第一列是勾选框，排除在循环之外
            if (dt.Columns.Count == 0)
            {
                for (int i = 0; i < dgv.Columns.Count; i++)
                    dt.Columns.Add(dgv.Columns[i].Name);
            }
            //是展开的子行的数据
            if (dgv.Rows[RowIndex].Tag != null && dgv.Rows[RowIndex].Tag.ToString() == "SonRow")
            {
                DataRow dr = dt.NewRow();
                DataRow[] datarow = (dt.Select(dgv.Columns[DistinctColumnIndex].Name + " ='" + dgv.Rows[RowIndex].Cells[DistinctColumnIndex].FormattedValue + "'"));
                //判断值是否存在，存在移除重新添加
                if (datarow.Length > 0)
                {
                    dt.Rows.Remove(datarow[0]);
                }
                for (int j = 0; j < dgv.ColumnCount; j++)
                {
                    dr[dgv.Columns[j].Name] = dgv.Rows[RowIndex].Cells[j].FormattedValue;
                }
                dt.Rows.Add(dr);
            }
        }

        /// <summary>
        /// 设置只允许输入数字
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        public static void NumOnly(object sender, KeyPressEventArgs e)
        {
            if (e.KeyChar != '\b')//这是允许输入退格键
            {
                if ((e.KeyChar < '0') || (e.KeyChar > '9'))//这是允许输入0-9数字
                {
                    e.Handled = true;
                }
            }
        }

        public static string AddField(string[] Fields)
        {
            string sql = " ";
            foreach (string field in Fields)
                sql += field + ",";
            return sql.Substring(0, sql.Length - 1);
        }
        /// <summary>
        /// 筛选DataTable
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="condition"></param>
        /// <returns></returns>
        public static DataTable filterDataTable(DataTable dt, String condition)
        {
            //获取筛选条件中的列名，值
            DataRow[] dataRows = dt.Select(condition);
            DataTable ndt = dt.Clone();
            for (int i = 0; i < dataRows.Length; i++)
            {
                ndt.Rows.Add(dataRows[i].ItemArray);
            }
            return ndt;
        }

        /// <summary>
        /// 图表绘制公共方法样本
        /// </summary>
        /// <param name="chart1"></param>
        /// <param name="_dt"></param>
        /// <param name="seriesChartType"></param>
        /// <param name="_title"></param>
        /// <param name="XValueMember"></param>
        /// <param name="YValueMembers"></param>
        /// <param name="Xname"></param>
        /// <param name="Yname"></param>
        public static void ViewChart(Chart chart1, DataTable _dt, SeriesChartType seriesChartType, string _title, string XValueMember, string YValueMembers, string Xname, string Yname)
        {
            chart1.Series[0].ChartType = seriesChartType;
            chart1.DataSource = _dt;
            chart1.Series[0].MarkerStyle = MarkerStyle.Circle;
            chart1.Series[0].MarkerSize = 8;
            chart1.Series[0].XValueMember = XValueMember;
            chart1.Series[0].YValueMembers = YValueMembers;
            chart1.Series[0].Label = "#VAL";
            chart1.Series[0].LabelToolTip = Xname + ": #VAL\r\n " + Yname + " #VALX";
            chart1.Series[0].BackSecondaryColor = Color.DarkCyan;
            chart1.Series[0].BorderColor = Color.DarkOliveGreen;
            chart1.Series[0].LabelBackColor = Color.Transparent;
            chart1.Series[0].LegendText = Yname;
            chart1.Legends[0].Title = _title;
            //chart1.ChartAreas[0].Area3DStyle.Enable3D = true;
        }


        /// <summary>
        /// 将新增打印进程信息写入静态文件
        /// </summary>
        /// <param name="lbl"></param>
        public static void WriteLbl(ApplicationClass lbl)
        {
            Process[] processes = System.Diagnostics.Process.GetProcessesByName("lppa");
            List<int> PidList = new List<int>();
            List<System.DateTime> Pstarttime = new List<System.DateTime>();
            int PID = 0;
            for (int i = 0; i < processes.Length; i++)
            {
                PidList.Add(processes[i].Id);
                Pstarttime.Add(processes[i].StartTime);
            }
            System.DateTime Temp = Pstarttime[0];
            if (Pstarttime.ToArray().Length > 0)
            {
                PID = PidList[0];
            }
            for (int i = 0; i < PidList.ToArray().Length; i++)
            {
                if (Temp < Pstarttime[i])
                {
                    PID = PidList[i];
                }
                else
                {
                    Temp = Pstarttime[i];
                }
            }
            String str = SystemInf.ProcessesID + "|" + PID;
            string sysdisc = Environment.GetEnvironmentVariable("windir").Substring(0, 1);
            FileStream fs = new FileStream(Directory.GetCurrentDirectory() + @"\" + "lblprocess" + ".txt", FileMode.Append, FileAccess.Write);
            StreamWriter sw = new StreamWriter(fs);
            sw.WriteLine(str, Encoding.UTF8);
            sw.Close();
            fs.Close();
        }

        public static Object GetCacheData(string ParamName)
        {
            Object o = null;
            //根据地址读取xml文件
            XmlDocument doc = new XmlDocument();
            XmlReaderSettings settings = new XmlReaderSettings();
            //忽略文档里面的注释
            settings.IgnoreComments = true;
            XmlReader reader = XmlReader.Create(Environment.GetEnvironmentVariable("windir").Substring(0, 1) + @":\Log\cacheInfo\cacheInfo.xml", settings);
            doc.Load(reader);
            //先得到根节点
            XmlNode rootNode = doc.SelectSingleNode("cacheInfo");
            //再由根节点去找制定的节点
            XmlNodeList nodeList = rootNode.ChildNodes;
            foreach (XmlNode node in nodeList)
            {
                //找到了这个节点名字
                if (node.Name == ParamName)
                {
                    //返回节点的内容
                    switch (((XmlElement)node).GetAttribute("Type"))
                    {
                        case "System.String":
                            o = node.InnerText;
                            break;
                        case "System.Int32":
                            o = int.Parse(node.InnerText);
                            break;
                        case "System.Boolean":
                            o = node.InnerText == "True" ? true : false;
                            break;
                        default:
                            break;
                    }
                    break;
                }
            }
            //关闭reader
            reader.Close();
            if (o == null)
                return "";
            else
                return o;
        }

        public static void SetCacheData(string ParamName, object Value)
        {
            //根据地址读取xml文件
            XmlDocument doc = new XmlDocument();
            XmlReaderSettings settings = new XmlReaderSettings();
            //忽略文档里面的注释
            settings.IgnoreComments = true;
            XmlReader reader = XmlReader.Create(Environment.GetEnvironmentVariable("windir").Substring(0, 1) + @":\Log\cacheInfo\cacheInfo.xml", settings);
            doc.Load(reader);
            //先得到根节点
            XmlNode rootNode = doc.SelectSingleNode("cacheInfo");
            //再由根节点去找制定的节点
            XmlNodeList nodeList = rootNode.ChildNodes;
            bool flag = false;
            foreach (XmlNode node in nodeList)
            {
                //找到了这个节点名字
                if (node.Name == ParamName)
                {
                    //就直接赋值
                    node.InnerText = Value.ToString();
                    flag = true;
                }
            }
            //如果没有该节点，就创建节点保存结果
            if (!flag)
            {
                //创建节点
                XmlElement newNode = doc.CreateElement(ParamName);
                XmlAttribute attr = doc.CreateAttribute("Type");
                attr.InnerText = Value.GetType().ToString();
                newNode.InnerText = Value.ToString();
                newNode.SetAttributeNode(attr);
                //讲新建的节点挂到根节点上
                rootNode.AppendChild(newNode);
            }
            //关闭Reader
            reader.Close();
            doc.Save(Environment.GetEnvironmentVariable("windir").Substring(0, 1) + @":\Log\cacheInfo\cacheInfo.xml");
        }

        public static void ClosePrint(ApplicationClass lbl)
        {
            lblpro = lbl;
            Thread close = new Thread(ClosePrintProcess);
            close.Start();
        }

        static ApplicationClass lblpro;

        private static void ClosePrintProcess()
        {
            try
            {
                lblpro.Quit();
            }
            catch (Exception)
            {

            }
        }
    }
}