C#编码风格小总结

最近连续使用了3个月时间的C#，对C#的类库基本可以驾轻就熟的应用了，在这段时间里也总结出了合适的编程风格，最近刚刚写完了一个网络状态监测的小程序，自认为风格可以代表自己的编程风格，主要单元全部贴出来了。

1、单元开头写一段预想中的“功能设计”；

2、凡是类级别的变量声明，一律使用三条线风格注释；

3、界面部分跟函数部分分隔开，这样运行逻辑看得更加清楚，可以适当运用public partial class这种风格，也可以加条长横线分开；

4、凡是界面事件处理的，先写一行，永完成时态去写这个事件是什么（比如：点击了调度状态图标）

       然后再写n行，这个事件处理什么，就是在那里做和做什么的两个问题，写在一起，总体比如

      这种注释，使用双线风格就好，理由，参数为系统设计的标准参数，不需要注释
        //加载窗体
        //设定图例颜色
        //初始化日志
        //初始化数据库
        //初始化终端列表,是终端的赋值，是空位的清空
        //启动刷新线程

5、代码中抛出事件性质的函数，要用名词中心的短语，时态上也用完成时态；

      比如：
        /// <summary>
        /// 网络故障已经发生了
        /// </summary>
        /// <param name="balloonTip">气球提示文本</param>
        private void Error_HasHappened(string balloonTip)

       {

       }

6、类级别的私有变量，沿用Delphi风格，以F开头；

      实际上，在这段时间，我用过“_”、“M”、“m”、大写开头，诸多方式，最后发现，还是用F最好，理由么，F按键最容易；
7、枚举变量，全部定义成中文，反正用提示输入，一样的方便，而且进一步的注释都可以省去了；

8、函数内的变量定义，优先使用“全小写，中间下划线连接”风格；

     也可以混合使用sqlStr这种风格的命名，但是必须小写开头；

9、所有的MessageBox都出现在界面直接相关的事件处理程序中，其他的地方要么以返回值的形式出现，要么记入日志；

10、对我不熟悉的程序添加代码，比如

        //add.xue.23
        //原因:为的是记下net数据包socket地址
        if (gp.Mode.ToLower() == "net")
        {
            net_pack_iep = ipport;
        }

        这样，发现数个问题其根源相同，就可以找段事件，专门的处理，一旦问题完美解决，就可以删除注释；

11、从我不熟悉的代码中删除，比如

                //del.xue.22
                //原因：重量稳不稳，这样判断没有意义，因为已经取数了
                //if (double.Parse(_WeightTemp) - double.Parse(tbx_jlsj.Text) > 50 || double.Parse(_WeightTemp) - double.Parse(tbx_jlsj.Text) < -50)
                //{
                //    string msg = "重量不稳定,取值与读数差距过大,确认要继续计量吗?";
                //    if (MessageBox.Show(msg, Application.ProductName, MessageBoxButtons.YesNo) == DialogResult.No)
                //    {
                //        V.AppLog.NewLog_UserClicked(msg + "[否]");
                //        return;
                //    }
                //    else
                //    {
                //        V.AppLog.NewLog_UserClicked(msg + "[是]");
                //    }
                //    modelmain.Txtinfo = modelmain.Txtinfo + "|重量不稳";
                //}

        删除这些注释的时机，可以定在一个月之后

12、给我不熟悉的程序添加注释

            //cmt.xue.22
            //经检查,ToClientData的第一个参数为虚设,所以传递空字符串
            //虽然ToClientData没有用到，但是该函数引用的SeatSocketKey是坐席业务专用，并且与包heartbeat有关
            //所以net包必须启用第一个参数
            //已经使用net_pack_iep用于net包处理

        之所以需要这样注释，一般是因为源程序中的命名区分度不够，不能见名知意，一旦代码被重构，这些注释也可以清除了。

13、类中用到的枚举，定义在类当中；类中用到的小类，也定义在类中，并且设为private，仅当是接口的一部分，才设为public；

 

FrmTestNet.cs

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using J.Util;
using J.Data;
using J.Log;
using System.Threading;
using System.Net.Sockets;
using System.Net.NetworkInformation;
using System.Text;
using System.Runtime.InteropServices;
using GAM.PlatForm.MesSocket;

/**************************************
 * 功能设计：xue.1.20
 * 1、实时显示网络状态，故障时以任务栏图标闪动的方式通知
 * 2、有故障的要记入数据库
 * 3、可以手动立即刷新
 * 4、刷新总是在线程中运行的，连接采用短连接
 *************************************/

namespace NetMon.监测
{
    /// <summary>
    /// 网络状态
    /// </summary>
    public enum NetState
    {
        正常运行,
        已断线,
        未启动,
        未开机
    }

    /// <summary>
    /// 网络状态的颜色
    /// </summary>
    public struct NetStateColor
    {
        public static Color 正常运行 = Color.Green;
        public static Color 已断线 = Color.Red;
        public static Color 未启动 = Color.Silver;
        public static Color 未开机 = Color.Gray;
        public static Color 空位 = SystemColors.Control;
    }

    public partial class FrmTestNet : Form
    {
        /// <summary>
        /// 是否退出系统
        /// 控制点击"退出"
        /// 控制线程"终止"
        /// </summary>
        private bool FExitingSys = false;
        /// <summary>
        /// 调度Ip
        /// </summary>
        private string FDispatchIp;
        /// <summary>
        /// 调度端口
        /// </summary>
        private int FDispatchPort;
        /// <summary>
        /// 是否需要闪烁或正在闪烁
        /// 原本是想用Timer直接控制的，可是线程中的代码启动Timer会不执行，因此只能写个控制变量让Timer自己去检测执行
        /// </summary>
        private bool FNeedFlashing = false;
        /// <summary>
        /// 下标为零的终端在控件命名上是几
        /// 比如下标为零的终端命名的控件是panel2，label2
        /// </summary>
        private const int C_Name_Diff = 2;
        /// <summary>
        /// 元素数量
        /// </summary>
        private const int C_Elem_Count = 16;
        /// <summary>
        /// 任务栏闪烁图标
        /// </summary>
        private Icon FCaiYunIcon = new Icon("Res\\彩云.ico");
        /// <summary>
        /// 透明图标
        /// </summary>
        private Icon FEmptyIcon = new Icon("Res\\透明图标.ico");
        /// <summary>
        /// SQL管理实例
        /// </summary>
        private SQLApp FSQLApp = new SQLApp();

        public FrmTestNet()
        {
            InitializeComponent();
        }

        //--界面部分开始--------------------------------------------------------------------------
        //加载窗体
        //设定图例颜色
        //初始化日志
        //初始化数据库
        //初始化终端列表,是终端的赋值，是空位的清空
        //启动刷新线程
        private void FrmTestNet_Load(object sender, EventArgs e)
        {
            try
            {
                panel18.BackColor = NetStateColor.正常运行;
                panel19.BackColor = NetStateColor.已断线;
                panel20.BackColor = NetStateColor.未启动;
                panel21.BackColor = NetStateColor.未开机;
                V.AppLog.FileName = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "Log\\网络检测_" + DateTime.Now.ToString("MM_dd") + ".log";
                V.AppLog.NewLog_AppStart("NetMon.exe");
                CheckForIllegalCrossThreadCalls = false;
                string fn = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "AppConfig.ini";
                FSQLApp.ConnStr = Ini.ReadStr(fn, "Option", "ConnStr");
                FDispatchIp = Ini.ReadStr(fn, "Option", "DispatchIp");
                FDispatchPort = Ini.ReadInt(fn, "Option", "DispatchPort");
                V.AppLog.NewLog("调度服务器:" + FDispatchIp + ":" + FDispatchPort.ToString());
                panel22.Visible = false;
                notifyIcon1.Icon = FCaiYunIcon;
                notifyIcon1.Visible = true;
                panel1.BackColor = NetStateColor.未开机;
                label1.Text = "调度服务器";
                notifyIcon1.Text = "网络状态监测";
                string sqlStr = "select ScaleCode,ScaleName,ScaleIP from GamScaleDetails";
                DataTable dt = FSQLApp.GetDataTable(sqlStr);
                for (int i = 0; i < dt.Rows.Count; i++)
                {
                    GetLabel(i).Text = dt.Rows[i]["ScaleName"].ToString();
                    GetPanel(i).BackColor = NetStateColor.未开机;
                }
                int iEmpty = C_Elem_Count - dt.Rows.Count;
                for (int i = 0; i < iEmpty; i++)
                {
                    int empty_index = dt.Rows.Count + i;
                    GetLabel(empty_index).Text = "";
                    GetPanel(empty_index).BackColor = NetStateColor.空位;
                }
                Thread t = new Thread(new ParameterizedThreadStart(InThread_ShuaXin));
                t.Start(null);
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("加载窗体", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }

        //点击了调度状态图标
        //立即刷新调度
        private void IconDiaodu_Click(object sender, EventArgs e)
        {
            try
            {
                Mach_Gam_Or_DiaoDu o_mach_diaodu = new Mach_Gam_Or_DiaoDu("00", FDispatchIp, "调度服务器", FDispatchPort);
                Thread t0 = new Thread(new ParameterizedThreadStart(InThread_ShuaXin_OneGamOrDiaodu));
                BeginTip(o_mach_diaodu.Name);
                t0.Start(o_mach_diaodu);
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("点击了调度状态图标", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }

        //点击了终端状态图标
        //立即刷新该终端
        private void IconGam_Click(object sender, EventArgs e)
        {
            try
            {
                Panel p = (Panel)sender;//panelx 或 panelxx
                string gam_id = (int.Parse(p.Name.Substring(5)) - 1).ToString("00");
                string sqlStr = string.Format("select ScaleCode,ScaleName,ScaleIP from GamScaleDetails where ScaleCode = {0}", gam_id.ToString());
                DataTable dt = FSQLApp.GetDataTable(sqlStr);
                if (dt.Rows.Count == 1)
                {
                    string gid = dt.Rows[0]["ScaleCode"].ToString();
                    string gip = dt.Rows[0]["ScaleIP"].ToString();
                    string gname = dt.Rows[0]["ScaleName"].ToString();
                    int gport = 9002;
                    Mach_Gam_Or_DiaoDu o_mach_gam = new Mach_Gam_Or_DiaoDu(gid, gip, gname, gport);
                    BeginTip(o_mach_gam.Name);
                    Thread t = new Thread(new ParameterizedThreadStart(InThread_ShuaXin_OneGamOrDiaodu));
                    t.Start(o_mach_gam);
                }
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("点击终端状态图标", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }

        //触发了闪烁时钟
        //闪烁图标效果
        private void tmr_Tray_Tick(object sender, EventArgs e)
        {
            if (FNeedFlashing)
            {
                try
                {
                    int i = DateTime.Now.Second % 2;
                    switch (i)
                    {
                        case 0: notifyIcon1.Icon = FCaiYunIcon; break;
                        case 1: notifyIcon1.Icon = FEmptyIcon; break;
                    }
                }
                catch (System.Exception ex)
                {
                    V.AppLog.NewExCatched("时钟闪烁图标效果", ex);
                    MessageBox.Show(ex.Message, "Exception");
                }
            }
        }

        //点击了状态说明
        //弹出提示
        private void button1_Click(object sender, EventArgs e)
        {
            try
            {
                string msg =
                    "正常运行:ping检测成功 + 发送成功 + 回复成功" + Environment.NewLine + Environment.NewLine +
                    "已断线: ping检测成功 + 发送成功(没有收到回复)" + Environment.NewLine + Environment.NewLine +
                    "未启动: ping检测成功 + (发送失败了)" + Environment.NewLine + Environment.NewLine +
                    "未开机: ping检测失败了";
                MessageBox.Show(msg, "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("点击状态说明", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }

        //点击托盘图标
        //取消闪烁
        //如果主窗口已经最小化了，打开它
        private void notifyIcon1_Click(object sender, EventArgs e)
        {
            try
            {
                FNeedFlashing = false;
                notifyIcon1.Icon = FCaiYunIcon;
                this.TopMost = true;
                this.Show();
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("点击托盘图标", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }

        //触发了更新日志文件名时钟
        //更新日志文件名
        private void tmr_LogFile_Tick(object sender, EventArgs e)
        {
            try
            {
                V.AppLog.FileName = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "Log\\网络检测_" + DateTime.Now.ToString("MM_dd") + ".log";
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("时钟更新日志文件名", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }

        //点击了气球提示
        //取消闪烁
        private void notifyIcon1_BalloonTipClicked(object sender, EventArgs e)
        {
            try
            {
                FNeedFlashing = false;
                notifyIcon1.Icon = FCaiYunIcon;
            }
            catch (System.Exception ex)
            {
                V.AppLog.NewExCatched("点击气球提示", ex);
                MessageBox.Show(ex.Message, "Exception");
            }
        }
  
        //点击了查阅日志
        //使用系统关联打开日志
        private void button2_Click(object sender, EventArgs e)
        {
            this.TopMost = false;
            Os.RunNoWait(V.AppLog.FileName, "");
        }

        //触发了关闭窗体
        //隐藏到托盘
        private void FrmTestNet_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (FExitingSys == false)
            {
                this.Hide();
                this.TopMost = false;
                e.Cancel = true;
            }
        }

        //点击了退出
        //删除托盘图标
        //结束线程
        //退出系统
        private void button3_Click(object sender, EventArgs e)
        {
            FExitingSys = true;
            if (MessageBox.Show("你确定退出？", "询问", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                notifyIcon1.Visible = false;
                V.AppLog.NewLog_AppExit();
                Environment.Exit(0);
            }
        }

        //点击了隐藏到托盘
        //关闭
        private void button4_Click(object sender, EventArgs e)
        {
            Close();
        }

        //--界面部分结束--------------------------------------------------------------------------

        /// <summary>
        /// 网络故障已经发生了
        /// </summary>
        /// <param name="balloonTip">气球提示文本</param>
        private void Error_HasHappened(string balloonTip)
        {
            V.AppLog.NewLog(balloonTip);
            notifyIcon1.BalloonTipIcon = ToolTipIcon.Error;
            notifyIcon1.BalloonTipText = balloonTip;
            notifyIcon1.BalloonTipTitle = "网络故障";
            notifyIcon1.ShowBalloonTip(3000);
            FNeedFlashing = true;
        }

        /// <summary>
        /// 刷新网络状态的线程
        /// </summary>
        /// <param name="o_mach_null">机器信息,传null值代表全部刷新</param>
        private void InThread_ShuaXin(object o_mach_null)
        {
            string sqlStr = "";
            if (o_mach_null == null)
            {
                sqlStr = "select ScaleCode,ScaleName,ScaleIP from GamScaleDetails";
                DataTable dt = FSQLApp.GetDataTable(sqlStr);
                int i_cnt = 0;
                while (FExitingSys == false)
                {
                    V.AppLog.NewLog("第{0}次轮询中.....", i_cnt++);
                    Mach_Gam_Or_DiaoDu o_diaodu = new Mach_Gam_Or_DiaoDu("00", FDispatchIp, "调度服务器", FDispatchPort);
                    Thread t0 = new Thread(new ParameterizedThreadStart(InThread_ShuaXin_OneGamOrDiaodu));
                    t0.Start(o_diaodu);
                    for (int i = 0; i < dt.Rows.Count; i++)
                    {
                        string gid = dt.Rows[i]["ScaleCode"].ToString();
                        string gip = dt.Rows[i]["ScaleIP"].ToString();
                        string gname = dt.Rows[i]["ScaleName"].ToString();
                        int gport = 9002;
                        Mach_Gam_Or_DiaoDu o_gam_info = new Mach_Gam_Or_DiaoDu(gid, gip, gname, gport);
                        Thread t = new Thread(new ParameterizedThreadStart(InThread_ShuaXin_OneGamOrDiaodu));
                        t.Start(o_gam_info);
                    }
                    Thread.Sleep(1000 * 60);
                }
            }
            else
            {
                Thread t = new Thread(new ParameterizedThreadStart(InThread_ShuaXin_OneGamOrDiaodu));
                Mach_Gam_Or_DiaoDu mach = (Mach_Gam_Or_DiaoDu)o_mach_null;
                t.Start(mach);
            }
        }

        /// <summary>
        /// Gam终端或调度信息
        /// </summary>
        private class Mach_Gam_Or_DiaoDu
        {
            /// <summary>
            /// Id，对终端需要，调度不需要
            /// </summary>
            public string Id;
            /// <summary>
            /// Ip地址
            /// </summary>
            public string Ip;
            /// <summary>
            /// 名称
            /// </summary>
            public string Name;
            /// <summary>
            /// 端口
            /// </summary>
            public int Port;
            public Mach_Gam_Or_DiaoDu(string gid, string gip, string gname, int gport)
            {
                Id = gid;
                Ip = gip;
                Name = gname;
                Port = gport;
            }
        }

        /// <summary>
        /// 对一个主机刷新网络状态
        /// </summary>
        /// <param name="o_mach">主机信息</param>
        private void InThread_ShuaXin_OneGamOrDiaodu(object o_mach)
        {
            try
            {
                Mach_Gam_Or_DiaoDu mach = (Mach_Gam_Or_DiaoDu)o_mach;
                if (To_J_Util.Ping(mach.Ip))
                {
                    try
                    {
                        Socket sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                        sock.Connect(mach.Ip, mach.Port);
                        string packStr = new GAMProtocol("net", "", Os.GetFirstIp()).ToString();
                        byte[] pack = Encoding.ASCII.GetBytes(packStr);
                        V.AppLog.NewLog_SockSendStr(sock, packStr);
                        int sent_len = sock.Send(pack);
                        V.AppLog.NewLog_OK();
                        pack = null;
                        if (sent_len == packStr.Length)
                        {
                            pack = new byte[100];
                            sock.ReceiveTimeout = 2000;
                            sock.Receive(pack);//同步调用，主机如果不回，2秒钟后爆异常
                            string replyStr = Encoding.ASCII.GetString(pack);
                            V.AppLog.NewLog_SockReceivedStr(sock, replyStr);
                            GAMProtocol gp = new ProtocolHelper(replyStr).GetProtocol();
                            if (gp.Mode.ToLower() == "net_reply")
                            {
                                GetPanel(mach.Id).BackColor = NetStateColor.正常运行;
                            }
                            else
                            {
                                GetPanel(mach.Id).BackColor = NetStateColor.已断线;
                                Error_HasHappened(string.Format("【{0}】终端发生网络故障!", mach.Name));
                            }
                        }
                        else
                        {
                            GetPanel(mach.Id).BackColor = NetStateColor.未启动;
                        }
                    }
                    catch (Exception ex)
                    {
                        //del.xue.23
                        //原因：为日志看起来清爽，对此异常不做记录
                        //V.AppLog.NewExCatched("对一个主机刷新网络状态", ex);
                        GetPanel(mach.Id).BackColor = NetStateColor.已断线;
                        Error_HasHappened(string.Format("【{0}】发生网络故障!", mach.Name));
                    }
                }
                else
                {
                    GetPanel(mach.Id).BackColor = NetStateColor.未开机;
                }
            }
            finally
            {
                EndTip();
            }
        }

        /// <summary>
        /// 设置提示消息并显示出来
        /// </summary>
        /// <param name="my_name"></param>
        private void BeginTip(string my_name)
        {
            label22.Text = string.Format("正在刷新 {0}", my_name);
            panel22.Visible = true;
        }

        /// <summary>
        /// 结束提示
        /// </summary>
        private void EndTip()
        {
            panel22.Visible = false;
        }

        /// <summary>
        /// 根据gam_id定位图标性质的Panel
        /// 这个列表的定位能力超过终端数量，最大是Groupbox中Panel的数量
        /// </summary>
        /// <param name="gam_id">下标,00代表调度</param>
        /// <returns></returns>
        private Panel GetPanel(string gam_id)
        {
            Panel r = null;
            switch (gam_id)
            {
                case "00": r = panel1; break;//调度
                case "01": r = panel2; break;
                case "02": r = panel3; break;
                case "03": r = panel4; break;
                case "04": r = panel5; break;
                case "05": r = panel6; break;
                case "06": r = panel7; break;
                case "07": r = panel8; break;
                case "08": r = panel9; break;
                case "09": r = panel10; break;
                case "10": r = panel11; break;
                case "11": r = panel12; break;
                case "12": r = panel13; break;
                case "13": r = panel14; break;
                case "14": r = panel15; break;
                case "15": r = panel16; break;
                case "16": r = panel17; break;
            }
            return r;
        }

        /// <summary>
        /// 根据下标定位Panel
        /// 这个列表的定位能力超过终端数量，最大是Groupbox中Panel的数量
        /// </summary>
        /// <param name="abs_index">下标,从零开始,-1代表调度</param>
        /// <returns></returns>
        private Panel GetPanel(int abs_index)
        {
            Panel r = null;
            switch ((abs_index + 1).ToString("00"))
            {
                case "00": r = panel1; break;//调度
                case "01": r = panel2; break;
                case "02": r = panel3; break;
                case "03": r = panel4; break;
                case "04": r = panel5; break;
                case "05": r = panel6; break;
                case "06": r = panel7; break;
                case "07": r = panel8; break;
                case "08": r = panel9; break;
                case "09": r = panel10; break;
                case "10": r = panel11; break;
                case "11": r = panel12; break;
                case "12": r = panel13; break;
                case "13": r = panel14; break;
                case "14": r = panel15; break;
                case "15": r = panel16; break;
                case "16": r = panel17; break;
            }
            return r;
        }

        /// <summary>
        /// 根据gam_id定位标签
        /// 这个列表的定位能力超过终端数量，最大是Groupbox中label的数量
        /// </summary>
        /// <param name="gam_id">下标,00代表调度</param>
        /// <returns></returns>
        private Label GetLabel(string gam_id)
        {
            Label r = null;
            switch (gam_id)
            {
                case "00": r = label1; break;//调度
                case "01": r = label2; break;
                case "02": r = label3; break;
                case "03": r = label4; break;
                case "04": r = label5; break;
                case "05": r = label6; break;
                case "06": r = label7; break;
                case "07": r = label8; break;
                case "08": r = label9; break;
                case "09": r = label10; break;
                case "10": r = label11; break;
                case "11": r = label12; break;
                case "12": r = label13; break;
                case "13": r = label14; break;
                case "14": r = label15; break;
                case "15": r = label16; break;
                case "16": r = label17; break;
            }
            return r;
        }

        /// <summary>
        /// 根据下标定位标签
        /// 这个列表的定位能力超过终端数量，最大是Groupbox中label的数量
        /// </summary>
        /// <param name="abs_index">下标,从零开始,-1代表调度</param>
        /// <returns></returns>
        private Label GetLabel(int abs_index)
        {
            Label r = null;
            switch ((abs_index + 1).ToString("00"))
            {
                case "00": r = label1; break;//调度
                case "01": r = label2; break;
                case "02": r = label3; break;
                case "03": r = label4; break;
                case "04": r = label5; break;
                case "05": r = label6; break;
                case "06": r = label7; break;
                case "07": r = label8; break;
                case "08": r = label9; break;
                case "09": r = label10; break;
                case "10": r = label11; break;
                case "11": r = label12; break;
                case "12": r = label13; break;
                case "13": r = label14; break;
                case "14": r = label15; break;
                case "15": r = label16; break;
                case "16": r = label17; break;
            }
            return r;
        }
    }

    ///////////////////////////////////////////////
    /// <summary>
    /// 网络函数
    /// 需要移动到J.Util
    /// </summary>
    public class To_J_Util
    {
        /// <summary>
        /// 根据IP地址获得主机名称
        /// </summary>
        /// <param name="ip">主机的IP地址</param>
        /// <returns>主机名称</returns>
        public static string GetHostNameByIp(string ip)
        {
            ip = ip.Trim();
            if (ip == string.Empty)
                return string.Empty;
            try
            {
                // 是否 Ping 的通
                if (To_J_Util.Ping(ip))
                {
                    System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry(ip);
                    return host.HostName;
                }
                else
                    return string.Empty;
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 根据主机名（域名）获得主机的IP地址
        /// </summary>
        /// <param name="hostName">主机名或域名</param>
        /// <example> GetIPByDomain("http://www.google.com%22);%3c/example>
        /// <returns>主机的IP地址</returns>
        public static string GetIpByHostName(string hostName)
        {
            hostName = hostName.Trim();
            if (hostName == string.Empty)
                return string.Empty;
            try
            {
                System.Net.IPHostEntry host = System.Net.Dns.GetHostEntry(hostName);
                return host.AddressList.GetValue(0).ToString();
            }
            catch (Exception)
            {
                return string.Empty;
            }
        }

        /// <summary>
        /// 是否能 Ping 通指定的主机
        /// </summary>
        /// <param name="ip">ip 地址或主机名或域名</param>
        /// <returns>true 通，false 不通</returns>
        public static bool Ping(string ip)
        {
            System.Net.NetworkInformation.Ping p = new System.Net.NetworkInformation.Ping();
            System.Net.NetworkInformation.PingOptions options = new System.Net.NetworkInformation.PingOptions();
            options.DontFragment = true;
            string data = "Test Data!";
            byte[] buffer = Encoding.ASCII.GetBytes(data);
            int timeout = 1000; // Timeout 时间，单位：毫秒
            System.Net.NetworkInformation.PingReply reply = p.Send(ip, timeout, buffer, options);
            if (reply.Status == System.Net.NetworkInformation.IPStatus.Success)
                return true;
            else
                return false;
        }
    }
}