常用功能函数

using System;
using System.Collections.Generic;
using System.Text;

using System.Runtime.InteropServices; //调用DLL需要引用空间
using System.Management; //获取计算机硬件信息需要引用的空间，需要添加引用
using System.Windows.Forms;
using System.IO;
//当你引用using Excel = Microsoft.Office.Interop.Excel;时如果出现
//命名空间“Microsoft.Office”中不存在类型或命名空间名称“Interop”(是缺少程序集引用吗?)的错误时，检查你是否添加了
//Microsoft Office 11.0 Object Library 组件；添加引用-->com-->Microsoft Office 11.0 Object Library,
//接着再添加Microsoft.Office.Interop.Excel组件；添加引用-->.net-->Microsoft.Office.Interop.Excel,
using Excel = Microsoft.Office.Interop.Excel;
using System.Reflection;
using System.Net;  // 网络 
using System.Net.Sockets;
namespace Function
{
    public class MyClass
    {
        #region 设置日期格式
        [DllImport("kernel32.dll", EntryPoint = "GetSystemDefaultLCID")]
        public static extern int GetSystemDefaultLCID();
        [DllImport("kernel32.dll", EntryPoint = "SetLocaleInfoA")]
        public static extern int SetLocaleInfo(int Locale, int LCType, string lpLCData);
        public const int LOCALE_SLONGDATE = 0x20;
        public const int LOCALE_SSHORTDATE = 0x1F;
        public const int LOCALE_STIME = 0x1003;
        public void SetDateFormat()
        {
            try
            {
                int x = GetSystemDefaultLCID();
                SetLocaleInfo(x, LOCALE_STIME, "HH:mm:ss");        //时间格式  
                SetLocaleInfo(x, LOCALE_SSHORTDATE, "yyyy-MM-dd");   //短日期格式    
                SetLocaleInfo(x, LOCALE_SLONGDATE, "yyyy-MM-dd");   //长日期格式   
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        #endregion

        #region 全角转半角
        public string ToDBC(string inputString)
        {
            char[] CharacterArray = inputString.ToCharArray();

            for (int i = 0; i < CharacterArray.Length; i++)
            {
                if (CharacterArray[i] == 12288)
                {
                    CharacterArray[i] = (char)32;

                    continue;
                }
                if (CharacterArray[i] > 65280 && CharacterArray[i] < 65375)

                    CharacterArray[i] = (char)(CharacterArray[i] - 65248);
            }
            return new string(CharacterArray);
        }
        #endregion

        #region 金额小写转大写
        private static String[] Ls_ShZ ={ "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖", "拾" };
        private static String[] Ls_DW_Zh ={ "元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万" };
        private static String[] Num_DW ={ "", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾", "佰", "仟", "万" };
        private static String[] Ls_DW_X ={ "角", "分" };
        /// <summary>
        /// 金额小写转中文大写。
        /// 整数支持到万亿；小数部分支持到分(超过两位将进行Banker舍入法处理)
        /// </summary>
        /// <param name="Num">需要转换的双精度浮点数</param>
        /// <returns>转换后的字符串</returns>
        public String NumGetStr(Double Num)
        {
            Boolean iXSh_bool = false;//是否含有小数，默认没有(0则视为没有)
            Boolean iZhSh_bool = true;//是否含有整数,默认有(0则视为没有)

            string NumStr;//整个数字字符串
            string NumStr_Zh;//整数部分
            string NumSr_X = "";//小数部分
            string NumStr_DQ;//当前的数字字符
            string NumStr_R = "";//返回的字符串
            Num = Math.Round(Num, 2);//四舍五入取两位
            //各种非正常情况处理
            if (Num < 0)
                return "不转换欠条";
            if (Num > 9999999999999.99)
                return "很难想象谁会有这么多钱！";
            if (Num == 0)
                return Ls_ShZ[0];
            //判断是否有整数
            if (Num < 1.00)
                iZhSh_bool = false;
            NumStr = Num.ToString();
            NumStr_Zh = NumStr;//默认只有整数部分
            if (NumStr_Zh.Contains("."))
            {//分开整数与小数处理
                NumStr_Zh = NumStr.Substring(0, NumStr.IndexOf("."));
                NumSr_X = NumStr.Substring((NumStr.IndexOf(".") + 1), (NumStr.Length - NumStr.IndexOf(".") - 1));
                iXSh_bool = true;
            }
            if (NumSr_X == "" || int.Parse(NumSr_X) <= 0)
            {//判断是否含有小数部分
                iXSh_bool = false;
            }
            if (iZhSh_bool)
            {//整数部分处理
                // NumStr_Zh = Reversion_Str(NumStr_Zh);//反转字符串
                for (int a = 0; a < NumStr_Zh.Length; a++)
                {//整数部分转换
                    NumStr_DQ = NumStr_Zh.Substring(a, 1);
                    if (int.Parse(NumStr_DQ) != 0)
                        NumStr_R = Ls_ShZ[int.Parse(NumStr_DQ)] + Ls_DW_Zh[a] + NumStr_R;
                    else if (a == 0 || a == 4 || a == 8)
                    {
                        if (NumStr_Zh.Length > 8 && a == 4)
                            continue;
                        NumStr_R = Ls_DW_Zh[a] + NumStr_R;
                    }
                    else if (int.Parse(NumStr_Zh.Substring(a - 1, 1)) != 0)
                        NumStr_R = Ls_ShZ[int.Parse(NumStr_DQ)] + NumStr_R;
                }
                if (!iXSh_bool)
                    return NumStr_R + "整";
                //NumStr_R += "零";
            }
            for (int b = 0; b < NumSr_X.Length; b++)
            {//小数部分转换
                NumStr_DQ = NumSr_X.Substring(b, 1);
                if (int.Parse(NumStr_DQ) != 0)
                    NumStr_R += Ls_ShZ[int.Parse(NumStr_DQ)] + Ls_DW_X[b];
                else if (b != 1 && iZhSh_bool)
                    NumStr_R += Ls_ShZ[int.Parse(NumStr_DQ)];
            }
            return NumStr_R;
        }
        #endregion

        #region 获取计算机硬件信息及系统版本
        private string OSBit()
        {
            try
            {
                ConnectionOptions oConn = new ConnectionOptions();

                System.Management.ManagementScope managementScope = new System.Management.ManagementScope("\\localhost", oConn);

                System.Management.ObjectQuery objectQuery = new System.Management.ObjectQuery("select AddressWidth from Win32_Processor");

                ManagementObjectSearcher moSearcher = new ManagementObjectSearcher(managementScope, objectQuery);

                ManagementObjectCollection moReturnCollection = null;

                string addressWidth = null;

                moReturnCollection = moSearcher.Get();

                foreach (ManagementObject oReturn in moReturnCollection)
                {
                    addressWidth = oReturn["AddressWidth"].ToString();
                }
                return addressWidth;
            }
            catch
            {
                return "获取错误";
            }

        }
        /// <summary>
        /// 获取计算机硬件信息及系统版本
        /// </summary>
        /// <returns></returns>
        public string GetOsVersion()
        {
            string osBitString = OSBit();

            string osVersionString = Environment.OSVersion.ToString();

            return string.Format(@"系统：{0}，{1} 位。", osVersionString, osBitString);
        }

        /// <summary>
        /// 获取获取CPU序列号代码 
        /// </summary>
        /// <returns></returns>
        public string GetCpuID()
        {
            try
            {
                //获取CPU序列号代码 
                string cpuInfo = "";//cpu序列号 

                ManagementClass mc = new ManagementClass("Win32_Processor");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    cpuInfo = mo.Properties["ProcessorId"].Value.ToString();
                }
                moc = null;
                mc = null;
                return "cpu序列号：" + cpuInfo;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary>
        /// 获取网卡硬件地址
        /// </summary>
        /// <returns></returns>
        public string GetMacAddress()
        {
            try
            {
                //获取网卡硬件地址 
                string mac = "";
                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    if ((bool)mo["IPEnabled"] == true)
                    {
                        mac = mo["MacAddress"].ToString();
                        break;
                    }
                }
                moc = null;
                mc = null;
                return "网卡MAC地址：" + mac;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary>
        /// /获取IP地址 
        /// </summary>
        /// <returns></returns>
        public string GetIPAddress()
        {
            try
            {
                //获取IP地址 
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    if ((bool)mo["IPEnabled"] == true)
                    {
                        //st=mo["IpAddress"].ToString(); 
                        System.Array ar;
                        ar = (System.Array)(mo.Properties["IpAddress"].Value);
                        st = ar.GetValue(0).ToString();
                        break;
                    }
                }
                moc = null;
                mc = null;
                return "IP地址:" + st;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary>
        /// 获取硬盘ID 
        /// </summary>
        /// <returns></returns>
        public string GetDiskID()
        {
            try
            {
                //获取硬盘ID 
                String HDid = "";
                ManagementClass mc = new ManagementClass("Win32_DiskDrive");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    HDid = (string)mo.Properties["Model"].Value;
                }
                moc = null;
                mc = null;
                return "硬盘序列号：" + HDid;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary> 
        /// 操作系统的登录用户名 
        /// </summary> 
        /// <returns></returns> 
        public string GetUserName()
        {
            try
            {
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["UserName"].ToString();
                }
                moc = null;
                mc = null;
                return "系统登录用户名：" + st;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary> 
        /// PC类型 
        /// </summary> 
        /// <returns></returns> 
        public string GetSystemType()
        {
            try
            {
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["SystemType"].ToString();
                }
                moc = null;
                mc = null;
                return "电脑类型:" + st;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary> 
        /// 物理内存 
        /// </summary> 
        /// <returns></returns> 
        public string GetTotalPhysicalMemory()
        {
            try
            {
                string st = "";
                ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    st = mo["TotalPhysicalMemory"].ToString();
                }
                moc = null;
                mc = null;
                return "物理内存：" + st;
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        /// <summary> 
        ///  获取计算机名称
        /// </summary> 
        /// <returns></returns> 
        public string GetComputerName()
        {
            try
            {
                return "计算机名：" + System.Environment.GetEnvironmentVariable("ComputerName");
            }
            catch
            {
                return "unknow";
            }
            finally
            {
            }
        }
        #endregion

        #region DataGridView数据显示到Excel
        /// <summary>      
        /// 打开Excel并将DataGridView控件中数据导出到Excel     
        /// </summary>      
        /// <param name="dgv">DataGridView对象 </param>      
        /// <param name="isShowExcle">是否显示Excel界面 </param>      
        /// <remarks>     
        /// add com "Microsoft Excel 11.0 Object Library"     
        /// using Excel=Microsoft.Office.Interop.Excel;     
        /// </remarks>     
        /// <returns> </returns>      
        public bool DataGridviewShowToExcel(DataGridView dgv, bool isShowExcle)
        {
            if (dgv.Rows.Count == 0)
            {
                MessageBox.Show("没有数据可以导出！");
                return false;
            }
            try
            {
                //建立Excel对象 
                //Microsoft.Office.Interop.Excel.Application excel = new Microsoft.Office.Interop.Excel.Application(); 
                Excel.Application excel = new Excel.Application();
                excel.Application.Workbooks.Add(true);
                excel.Visible = isShowExcle;
                //生成字段名称      
                for (int i = 0; i < dgv.ColumnCount; i++)
                {
                    excel.Cells[1, i + 1] = dgv.Columns[i].HeaderText;
                }
                //填充数据      
                for (int i = 0; i < dgv.RowCount - 1; i++)
                {
                    for (int j = 0; j < dgv.ColumnCount; j++)
                    {
                        if (dgv[j, i].ValueType == typeof(string))
                        {
                            excel.Cells[i + 2, j + 1] = "'" + dgv[j, i].Value.ToString();
                        }
                        else
                        {
                            excel.Cells[i + 2, j + 1] = dgv[j, i].Value.ToString();
                        }
                    }
                }
                return true;
            }
            catch (System.Exception ex)
            {
                DataGridViewToExcel_CSV(dgv);
                return true;
            }
        }
        #endregion

        #region DateGridView导出到csv格式的Excel
        /// <summary>     
        /// 常用方法，列之间加/t，一行一行输出，此文件其实是csv文件，不过默认可以当成Excel打开。     
        /// </summary>     
        /// <remarks>     
        /// using System.IO;     
        /// </remarks>     
        /// <param name="dgv"></param>     
        private void DataGridViewToExcel_CSV(DataGridView dgv)
        {
            SaveFileDialog kk = new SaveFileDialog();
            kk.Title = "保存EXECL文件";
            kk.Filter = "EXECL文件(*.xls) |*.xls |所有文件(*.*) |*.*";
            kk.FilterIndex = 1;
            if (kk.ShowDialog() == DialogResult.OK)
            {
                string FileName = kk.FileName;
                if (File.Exists(FileName))
                    File.Delete(FileName);
                FileStream objFileStream;
                StreamWriter objStreamWriter;
                string strLine = "";
                objFileStream = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.Write);
                objStreamWriter = new StreamWriter(objFileStream, System.Text.Encoding.Unicode);
                for (int i = 0; i < dgv.Columns.Count; i++)
                {
                    if (dgv.Columns[i].Visible == true)
                    {
                        strLine = strLine + dgv.Columns[i].HeaderText.ToString() + Convert.ToChar(9);
                    }
                }
                objStreamWriter.WriteLine(strLine);
                strLine = "";

                for (int i = 0; i < dgv.Rows.Count; i++)
                {
                    if (dgv.Columns[0].Visible == true)
                    {
                        if (dgv.Rows[i].Cells[0].Value == null)
                            strLine = strLine + " " + Convert.ToChar(9);
                        else
                            strLine = strLine + dgv.Rows[i].Cells[0].Value.ToString() + Convert.ToChar(9);
                    }
                    for (int j = 1; j < dgv.Columns.Count; j++)
                    {
                        if (dgv.Columns[j].Visible == true)
                        {
                            if (dgv.Rows[i].Cells[j].Value == null) strLine = strLine + " " + Convert.ToChar(9);
                            else
                            {
                                string rowstr = "";
                                rowstr = dgv.Rows[i].Cells[j].Value.ToString();
                                if (rowstr.IndexOf("
") > 0)
                                    rowstr = rowstr.Replace("
", " ");
                                if (rowstr.IndexOf("	") > 0)
                                    rowstr = rowstr.Replace("	", " ");
                                strLine = strLine + rowstr + Convert.ToChar(9);
                            }
                        }
                    }
                    objStreamWriter.WriteLine(strLine);
                    strLine = "";
                }
                objStreamWriter.Close();
                objFileStream.Close();
                MessageBox.Show("保存EXCEL成功", "提示");
            }
        }
        #endregion

        #region <不使用> DataGridView导出到Excel，有一定的判断性
        /// <summary>   
        /// !不使用!，导出DataGridView中的数据到Excel文件
        /// </summary>   
        /// <remarks>  
        /// add com "Microsoft Excel 11.0 Object Library"  
        /// using Excel=Microsoft.Office.Interop.Excel;  
        /// using System.Reflection;  
        /// </remarks>  
        /// <param name= "dgv"> DataGridView </param>   
        public void DataGridViewToExcel(DataGridView dgv)
        {


            #region   验证可操作性

            //申明保存对话框   
            SaveFileDialog dlg = new SaveFileDialog();
            //默然文件后缀   
            dlg.DefaultExt = "xls ";
            //文件后缀列表   
            dlg.Filter = "EXCEL文件(*.XLS)|*.xls ";
            //默然路径是系统当前路径   
            dlg.InitialDirectory = Directory.GetCurrentDirectory();
            //打开保存对话框   
            if (dlg.ShowDialog() == DialogResult.Cancel) return;
            //返回文件路径   
            string fileNameString = dlg.FileName;
            //验证strFileName是否为空或值无效   
            if (fileNameString.Trim() == " ")
            { return; }
            //定义表格内数据的行数和列数   
            int rowscount = dgv.Rows.Count;
            int colscount = dgv.Columns.Count;
            //行数必须大于0   
            if (rowscount <= 0)
            {
                MessageBox.Show("没有数据可供保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            //列数必须大于0   
            if (colscount <= 0)
            {
                MessageBox.Show("没有数据可供保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            //行数不可以大于65536   
            if (rowscount > 65536)
            {
                MessageBox.Show("数据记录数太多(最多不能超过65536条)，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            //列数不可以大于255   
            if (colscount > 255)
            {
                MessageBox.Show("数据记录行数太多，不能保存 ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                return;
            }

            //验证以fileNameString命名的文件是否存在，如果存在删除它   
            FileInfo file = new FileInfo(fileNameString);
            if (file.Exists)
            {
                try
                {
                    file.Delete();
                }
                catch (Exception error)
                {
                    MessageBox.Show(error.Message, "删除失败 ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    return;
                }
            }
            #endregion
            Excel.Application objExcel = null;
            Excel.Workbook objWorkbook = null;
            Excel.Worksheet objsheet = null;
            try
            {
                //申明对象   
                objExcel = new Microsoft.Office.Interop.Excel.Application();
                objWorkbook = objExcel.Workbooks.Add(Missing.Value);
                objsheet = (Excel.Worksheet)objWorkbook.ActiveSheet;
                //设置EXCEL不可见   
                objExcel.Visible = false;

                //向Excel中写入表格的表头   
                int displayColumnsCount = 1;
                for (int i = 0; i <= dgv.ColumnCount - 1; i++)
                {
                    if (dgv.Columns[i].Visible == true)
                    {
                        objExcel.Cells[1, displayColumnsCount] = dgv.Columns[i].HeaderText.Trim();
                        displayColumnsCount++;
                    }
                }
                //设置进度条   
                //tempProgressBar.Refresh();   
                //tempProgressBar.Visible   =   true;   
                //tempProgressBar.Minimum=1;   
                //tempProgressBar.Maximum=dgv.RowCount;   
                //tempProgressBar.Step=1;   
                //向Excel中逐行逐列写入表格中的数据   
                for (int row = 0; row <= dgv.RowCount - 1; row++)
                {
                    //tempProgressBar.PerformStep();   

                    displayColumnsCount = 1;
                    for (int col = 0; col < colscount; col++)
                    {
                        if (dgv.Columns[col].Visible == true)
                        {
                            try
                            {
                                objExcel.Cells[row + 2, displayColumnsCount] = dgv.Rows[row].Cells[col].Value.ToString().Trim();
                                displayColumnsCount++;
                            }
                            catch (Exception)
                            {

                            }

                        }
                    }
                }
                //隐藏进度条   
                //tempProgressBar.Visible   =   false;   
                //保存文件   
                objWorkbook.SaveAs(fileNameString, Missing.Value, Missing.Value, Missing.Value, Missing.Value,
                        Missing.Value, Excel.XlSaveAsAccessMode.xlShared, Missing.Value, Missing.Value, Missing.Value,
                        Missing.Value, Missing.Value);
            }
            catch (Exception error)
            {
                //DataGridViewToExcel_CSV(dgv);
                MessageBox.Show(error.Message, "警告 ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return;
            }
            finally
            {
                //关闭Excel应用   
                if (objWorkbook != null) objWorkbook.Close(Missing.Value, Missing.Value, Missing.Value);
                if (objExcel.Workbooks != null) objExcel.Workbooks.Close();
                if (objExcel != null) objExcel.Quit();

                objsheet = null;
                objWorkbook = null;
                objExcel = null;
            }
            MessageBox.Show(fileNameString + "/n/n导出完毕! ", "提示 ", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
        #endregion

        #region ini文件读写
        /// <summary>
        /// ini文件读写
        /// </summary>
        /// <param name="lpAppName"></param>
        /// <param name="lpKeyName"></param>
        /// <param name="lpDefault"></param>
        /// <param name="lpReturnedString"></param>
        /// <param name="nSize"></param>
        /// <param name="lpFileName"></param>
        /// <returns></returns>
        [DllImport("kernel32.dll")]
        private static extern uint GetPrivateProfileString
        (
            string lpAppName,
            string lpKeyName,
            string lpDefault,
            StringBuilder lpReturnedString,
            int nSize,
            string lpFileName
        );
        [DllImport("kernel32.dll")]
        private static extern uint WritePrivateProfileString(
            string lpappName,
            string lpKeyName,
            string lpstring,
            string lpFileName
        );
        public string ReadINI(string a1, string a2)           //读取配置文件
        {
            StringBuilder buff = new StringBuilder(256);
            GetPrivateProfileString(a1, a2, "", buff, 256, System.Windows.Forms.Application.StartupPath + "\Config.dll");
            return buff.ToString().Trim();
        }
        public string WriteINI(string w1, string w2, string w3)                 //写入配置文件
        {
            long success = WritePrivateProfileString(w1, w2, w3, System.Windows.Forms.Application.StartupPath + "\Config.dll");
            return success.ToString();
        }
        #endregion

       #region 字符串截取
         /// <summary>
        /// str为要进行截取的字符串,start是第一个关键字(字符串),last是第二个关键字(字符串),n截取字符串方式  
         /// </summary>
        /// <param name="str">tr为要进行截取的字符串</param>
        /// <param name="start">start是第一个关键字(字符串)</param>
        /// <param name="last">last是第二个关键字(字符串)</param>
        /// <param name="n">n截取字符串方式  </param>
        /// <returns>string</returns>
        public string GetContent(string str, string start, string last, int n)
        {
            if (str.ToLower().IndexOf(start.ToLower()) >= 0)
            {
                if (str.ToLower().IndexOf(last.ToLower()) > 0)
                {
                    switch (n)
                    {
                        //左右都截取（都取前面）（包含关键字）       
                        case 1: str = str.Substring(str.ToLower().IndexOf(start.ToLower()), str.Length - str.ToLower().IndexOf(start.ToLower()));
                            str = str.Substring(0, str.ToLower().IndexOf(last.ToLower()) + last.Length); break;
                        //左右都截取（都取前面）（去除关键字）                    
                        case 2: str = str.Substring(str.ToLower().IndexOf(start.ToLower()) + start.Length, str.Length - str.ToLower().IndexOf(start.ToLower()) - start.Length);
                            str = str.Substring(0, str.ToLower().IndexOf(last.ToLower())); break;
                        //左右都截取（都取后面）（包含关键字）                    
                        case 3: str = str.Substring(str.ToLower().LastIndexOf(start.ToLower()), str.Length - str.ToLower().LastIndexOf(start.ToLower()));
                            str = str.Substring(0, str.ToLower().LastIndexOf(last.ToLower()) + last.Length); break;
                        //左右都截取（都取后面）（去除关键字）                    
                        case 4: str = str.Substring(str.ToLower().LastIndexOf(start.ToLower()) + start.Length, str.Length - str.ToLower().LastIndexOf(start.ToLower()) - start.Length);
                            str = str.Substring(0, str.ToLower().LastIndexOf(last.ToLower())); break;
                        //左右都截取（一前一后）（包含关键字）                      
                        case 5: str = str.Substring(str.ToLower().IndexOf(start.ToLower()), str.Length - str.ToLower().IndexOf(start.ToLower()));
                            str = str.Substring(0, str.ToLower().LastIndexOf(last.ToLower()) + last.Length); break;
                        //左右都截取（一前一后）（去除关键字）                      
                        case 6: str = str.Substring(str.ToLower().IndexOf(start.ToLower()) + start.Length, str.Length - str.ToLower().IndexOf(start.ToLower()) - start.Length);
                            str = str.Substring(0, str.ToLower().LastIndexOf(last.ToLower())); break;
                        default: str = "Error str"; break;
                    }
                }
                else
                {
                    switch (n)
                    {
                        //只往左截取（取前面的）（包含关键字）           
                        case 7: str = str.Substring(0, str.ToLower().IndexOf(start.ToLower()) + start.Length); break;
                        //只往左截取（取前面的）（去除关键字）                    
                        case 8: str = str.Substring(0, str.ToLower().IndexOf(start.ToLower())); break;
                        //只往左截取（取后面的）（包含关键字）                   
                        case 9: str = str.Substring(0, str.ToLower().LastIndexOf(start.ToLower()) + start.Length); break;
                        //只往左截取（取后面的）（去除关键字）                  
                        case 10: str = str.Substring(0, str.ToLower().LastIndexOf(start.ToLower())); break;
                        //只往右截取（取前面的）（包含关键字）                    
                        case 11: str = str.Substring(str.ToLower().IndexOf(start.ToLower()), str.Length - str.ToLower().IndexOf(start.ToLower())); break;
                        //只往右截取（取前面的）（去除关键字）                  
                        case 12: str = str.Substring(str.ToLower().IndexOf(start.ToLower()) + start.Length, str.Length - str.ToLower().IndexOf(start.ToLower()) - start.Length); break;
                        //只往右截取（取后面的）（包含关键字）                    
                        case 13: str = str.Substring(str.ToLower().LastIndexOf(start.ToLower()), str.Length - str.ToLower().LastIndexOf(start.ToLower())); break;
                        //只往右截取（取后面的）（去除关键字）                     
                        case 14: str = str.Substring(str.ToLower().LastIndexOf(start.ToLower()) + start.Length, str.Length - str.ToLower().LastIndexOf(start.ToLower()) - start.Length); break;
                        default: str = "Error str"; break;
                    }
                }
            }
            else
            {
                str = "Error str";
            }
            return str;
        }
        #endregion

        #region SQL 端口状态检测
        /// <summary>
        /// SQL 端口状态监测
        /// </summary>
        /// <param name="ip">IP</param>
        /// <param name="port">端口号</param>
        /// <returns>boolean</returns>
        public Boolean PortState(string ip, string port)
        {
            if (ToDBC(ip) == ".")
            {
                ip = "127.0.0.1";
            }
            Boolean state;
            bool tcpListen = false;
            bool udpListen = false;//设定端口状态标识位 
            System.Net.IPAddress myIpAddress = null; //字符串转换为IP地址
            System.Net.IPEndPoint myIpEndPoint = null;
            try
            {
                myIpAddress = IPAddress.Parse(ToDBC(ip));
            }
            catch (System.Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }

            try
            {
                myIpEndPoint = new IPEndPoint(myIpAddress, int.Parse(port));
                System.Net.Sockets.TcpClient tcpClient = new TcpClient();
                tcpClient.Connect(myIpEndPoint);
                //对远程计算机的指定端口提出TCP连接请求
                //tcpListen = tcpClient.Connected.Equals(true);
                tcpListen = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
            try
            {
                System.Net.Sockets.UdpClient udpClient = new UdpClient();
                udpClient.Connect(myIpEndPoint);
                //对远程计算机的指定端口提出UDP连接请求
                udpListen = true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
                return false;
            }
            if (tcpListen == true && udpListen == true)
            {
                state = true;
            }
            else
            {
                state = false;
            }
            return state;
        }
        #endregion
    }
}

百度到的，自己整理了一下！