IPPIngCOde

最新推荐文章于 2024-01-23 08:24:15 发布
最新推荐文章于 2024-01-23 08:24:15 发布
阅读量820 收藏
点赞数
文章标签： string null filenames exception byte tree
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GTBGT525/article/details/5254718
版权

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.IO;
using System.Xml;
using YGApp.Encryption;
using System.Configuration;
using System.Reflection;
using System.Collections.Specialized;
using DevExpress.XtraEditors.Controls;
using System.Net;
using System.Runtime.InteropServices;
using System.Management;
using log4net;
using YGApp.Base.Log;
using System.Security.Cryptography;
using System.Collections;
using Microsoft.Win32; //对注册表操作一定要引用这个命名空间
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;

 


namespace YGApp.WinClient
{


    /// <summary>
    /// 公共函数类
    /// </summary>
   
    public class CommFunc
    {
        //ping IP API调用
        [DllImport("Iphlpapi.dll")]
        private static extern int SendARP(Int32 dest, Int32 host, byte[] mac, ref Int32 length);
        [DllImport("Ws2_32.dll")]
        private static extern Int32 inet_addr(string ip);
        public static string IMG_LOGIN_LOGO = "Login_Logo.jpg";
        public static string IMG_LOGIN_OK = "Login_OK.gif";
        public static string IMG_LOGIN_CANCEL = "Login_Cancel.gif";
        public static string IMG_TREE_FLODER = "Tree_Folder.gif";
        public static string IMG_TREE_LEAF = "Tree_FolderLeaf.gif";
        public static string IMG_TREE_SELECTNODE = "Tree_FolderSelectedLeaf.gif";
        public static string IMG_MAIN_BACKGROUND = "YGAppEPBackGround.jpg";
        public static string IMG_TREE_NOTES = "Tree_Notes.gif";
        public static string LOG_FILENAME = Application.StartupPath + "//YGApp.WinClient.exe.log4net";
        public static string APPLICATION_CONFIG = Application.StartupPath + "//YGApp.WinClient.exe.config";
        public static string ICO_APPLICATION = "Application.ico";
        public static int DEFALUT_SESSION_TIMEOUT = 15;
        public static string REMOTE_CONFIG = Application.StartupPath + "//config//YGApp.Remoting.ClientConfig.xml";
        public static string MINVERSIONNUMBER = "1998-12-29 00:00"; //最小版本号
        public static string TEMP_UPATE_PATHS = Environment.GetEnvironmentVariable("Temp") + "//" + "_" + "Update" + "//";


        public enum VerType { cs = 0, personal = 1, none = 2 };

        public static System.Threading.Mutex mutex;

        public static IYGAppLog m_log;

        public static string AppLicationPath = "";

        public static string ApplicationName = "";

        public static DevExpress.XtraEditors.StyleController SystemStyleControl = new DevExpress.XtraEditors.StyleController();

        public static Image GetImages(string fileName)
        {
            fileName = AppLicationPath + "//images//" + fileName;
            if (!File.Exists(fileName))
            {
                return null;
            }
            try
            {
                Image img = Image.FromFile(fileName);
                return img;
            }
            catch
            {
                return null;
            }

        }

        public static Icon GetICON(string fileName)
        {
            fileName = AppLicationPath + "//images//" + fileName;
            if (!File.Exists(fileName))
            {
                return null;
            }
            try
            {
                Icon icon = new Icon(fileName);
                return icon;
            }
            catch
            {
                return null;
            }

        }


        public static void WriteErrorLogs(object message, Exception ex)
        {
            if (m_log != null)
            {
                m_log.Error(message, ex);
            }
        }

        public static void WriteErrorLogs(object message)
        {
            if (m_log != null)
            {
                m_log.Error(message);
            }
        }

        public static void WriteWarnLogs(object message, Exception ex)
        {
            if (m_log != null)
            {
                m_log.Warn(message, ex);
            }
        }

        public static void WriteWarnLogs(object message)
        {
            if (m_log != null)
            {
                m_log.Warn(message);
            }
        }

 

 


        /// <summary>
        /// 从配置文件中获取用户登陆信息
        /// </summary>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        public static string GetUserInfoConfigValue(string attributeName, bool IsEncode)
        {
            try
            {
                NameValueCollection info = ((NameValueCollection)(ConfigurationManager.GetSection("LoginUserInfo")));
                if (info == null || info.AllKeys.Length == 0)
                {
                    return "";
                }

                string[] values = info.GetValues(attributeName);
                if (values.Length == 0)
                {
                    return "";
                }
                if (IsEncode)
                {
                    Encrypt de = new Encrypt();
                    return de.DecodeStr(values[0]);
                }
                else
                {
                    return values[0];
                }
            }
            catch
            {
                return "";
            }

        }

        /// <summary>
        /// 获取当前系统运行版本
        /// </summary>
        /// <returns></returns>
        public static VerType SystemVerType()
        {
            string ver = GetSystemInfoConfigValue("VerType", false);
            if (ver.ToLower() == "cs")
            {
                return VerType.cs;
            }
            else if (ver.ToLower() == "personal")
            {
                return VerType.personal;
            }
            else
            {
                return VerType.none;
            }
        }

 

        /// <summary>
        /// 从配置文件获取系统信息
        /// </summary>
        /// <param name="attributeName"></param>
        /// <returns></returns>
        public static string GetSystemInfoConfigValue(string attributeName, bool IsEncode)
        {

            try
            {
                NameValueCollection info = ((NameValueCollection)(ConfigurationManager.GetSection("SystemConfigInfo")));
                if (info == null || info.AllKeys.Length == 0)
                {
                    return "";
                }

                string[] values = info.GetValues(attributeName);
                if (values.Length == 0)
                {
                    return "";
                }
                if (IsEncode)
                {
                    Encrypt de = new Encrypt();
                    return de.DecodeStr(values[0]);
                }
                else
                {
                    return values[0];
                }
            }
            catch
            {
                return "";
            }
        }

        /// <summary>
        /// 给属性赋值
        /// </summary>
        /// <param name="xPath"></param>
        /// <param name="attributeName"></param>
        /// <param name="value"></param>
        public static void SetLoginAttributeValue(string attributeName, string value, bool isEnCode)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(Application.StartupPath + @"/" + "YGApp.WinClient.exe.config");
            XmlNodeList list = doc.SelectNodes("configuration/LoginUserInfo");
            if (list == null || list.Count == 0)
            {
                return;
            }
            foreach (XmlNode node in list[0].ChildNodes)
            {
                if (node.Attributes[0].Value.ToLower() == attributeName.ToLower())
                {
                    if (isEnCode)
                    {
                        Encrypt en = new Encrypt();
                        node.Attributes[1].Value = en.EncodeStr(value);
                    }
                    else
                    {
                        node.Attributes[1].Value = value;
                    }
                    doc.Save(Application.StartupPath + @"/" + "YGApp.WinClient.exe.config");
                    break;
                }
            }

        }

        public static BorderStyles GetEnumStyle(string style)
        {
            switch (style.ToLower())
            {
                case "default":
                    return BorderStyles.Default;
                case "flat":
                    return BorderStyles.Flat;
                case "hotflat":
                    return BorderStyles.HotFlat;
                case "noborder":
                    return BorderStyles.NoBorder;
                case "office2003":
                    return BorderStyles.Office2003;
                case "simple":
                    return BorderStyles.Simple;
                case "style3d":
                    return BorderStyles.Style3D;
                case "ultraflat":
                    return BorderStyles.UltraFlat;
                default:
                    return BorderStyles.Default;
            }
        }

        /// <summary>
        /// 获取本机MAC地址
        /// </summary>
        /// <returns></returns>
        public static string GetNetCardMacAddress()
        {
            try
            {
                ManagementClass mc;
                ManagementObjectCollection moc;
                mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    if ((bool)mo["IPEnabled"] == true)
                    {
                        return mo["MacAddress"].ToString().Replace(":", "-"); ;
                        //macAddress = ((string[])(mo["IpAddress"]))[0].ToString();
                    }

                }
            }
            catch
            {
                return "";
            }
            return "";
        }

        /// <summary>
        /// 获取本机IP地址
        /// </summary>
        /// <returns></returns>
        public static string GetIpAddress()
        {
            try
            {
                ManagementClass mc;
                ManagementObjectCollection moc;
                mc = new ManagementClass("Win32_NetworkAdapterConfiguration");
                moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                {
                    if ((bool)mo["IPEnabled"] == true)
                    {
                        return ((string[])(mo["IpAddress"]))[0].ToString();
                    }
                }
            }
            catch
            {
                return "";
            }
            return "";
        }

        /// <summary>
        /// 获取本机主板信息(标识位+型号+序列号)
        /// </summary>
        /// <returns></returns>
        public static string GetMainboarInfo(out string error)
        {
            error = string.Empty;
            string mainboardSerialInfo = string.Empty;
            string strMachineIdentifier = string.Empty;
            try
            {
                string path = Path.Combine(AppLicationPath + @"/", "Config//YGApp.AppPrivateConfig.xml");
                XmlDocument XmlDoc = new XmlDocument();
                XmlDoc.Load(path);
                XmlNodeList MachineIdentifierList = XmlDoc.SelectNodes("//MachineIdentifier");//读取机器码标识符
                foreach (XmlNode Nodes in MachineIdentifierList)
                    strMachineIdentifier = Nodes.InnerText;
                ManagementClass mc = new ManagementClass("WIN32_BaseBoard");
                ManagementObjectCollection moc = mc.GetInstances();
                foreach (ManagementObject mo in moc)
                    mainboardSerialInfo = strMachineIdentifier +":"+ mo["Product"].ToString() + mo["SerialNumber"].ToString();
            }
            catch (Exception ex)
            {
                error = "获取本机机器码信息失败:" + ex.Message + ex.StackTrace;
            }
            return mainboardSerialInfo;
        }


        #region 客户端mD5文件验证

        /// <summary>
        /// md5物理文件验证
        /// </summary>
        /// <param name="XmlDoc"></param>
        /// <param name="dicFiles"></param>
        /// <returns></returns>
        public static bool BalanceFileMd5(XmlDocument localFileConfig, out Dictionary<string, string> localFiles)
        {
            localFiles = new Dictionary<string, string>();
            XmlNodeList svrFileList = localFileConfig.SelectNodes("//File");
            foreach (XmlNode FileNode in svrFileList)
            {
                string svrfileName = (FileNode.InnerText.StartsWith("//") ? FileNode.InnerText.Substring(1) : FileNode.InnerText);
                string svrMD5 = FileNode.SelectSingleNode("@md5").Value;
                string localFileName = Path.Combine(CommFunc.AppLicationPath, svrfileName);
                if (File.Exists(localFileName))
                {
                    string localMD5 = MD5File(localFileName).ToUpper();
                    if (svrMD5 == localMD5)
                    {
                        localFiles.Add(svrfileName, svrMD5);
                    }
                }
            }
            return (localFiles.Count == svrFileList.Count);
        }


        /// <summary>
        /// 找出Md5的值
        /// </summary>
        /// <param name="xmldoc"></param>
        /// <returns></returns>
        public static Dictionary<string, string> GetMd5Value(XmlDocument XmlDoc)
        {
            Dictionary<string, string> dicMd5Value = new Dictionary<string, string>();
            XmlNodeList NodeList = XmlDoc.SelectNodes("//File");
            foreach (XmlNode FileNode in NodeList)
            {
                dicMd5Value.Add(FileNode.InnerText, FileNode.SelectSingleNode("@md5").Value);
            }
            return dicMd5Value;
        }


        /// <summary>
        /// 找出需要更新的文件
        /// </summary>
        /// <param name="XmlDoc"></param>
        /// <param name="dicFiles"></param>
        /// <returns></returns>
        public static Dictionary<string, string> FindUpdateFile(string serverFileConfig, Dictionary<string, string> localFileMD5Values)
        {
            XmlDocument XmlDoc = new XmlDocument();
            XmlDoc.LoadXml(serverFileConfig);
            Dictionary<string, string> Updatelist = new Dictionary<string, string>();
            string AppMianName = string.Empty;
            XmlNodeList AppMianList = XmlDoc.SelectNodes("//AppMain");

            foreach (XmlNode Nodes in AppMianList)
                AppMianName = Nodes.InnerText;

            XmlNodeList NodeList = XmlDoc.SelectNodes("//File");
            foreach (XmlNode FileNode in NodeList)
            {
                if (FileNode.InnerText != AppMianName)
                {
                    string srvFileMd5 = FileNode.SelectSingleNode("@md5").Value;
                    if (localFileMD5Values.ContainsKey(FileNode.InnerText))
                    {
                        if (!localFileMD5Values[FileNode.InnerText].Equals(srvFileMd5))
                        {
                            Updatelist.Add(FileNode.InnerText, srvFileMd5);
                        }
                    }
                    else
                    {
                        Updatelist.Add(FileNode.InnerText, srvFileMd5);
                    }
                }
            }
            Updatelist.Add(AppMianName, "");
            Updatelist.Add("YGApp.WinClient.pdb", "");
            return Updatelist;

        }

 

        /// <summary>
        /// 获取客户端版本号
        /// </summary>
        /// <param name="XmlDoc"></param>
        /// <param name="dicFiles"></param>
        /// <returns></returns>
        public static string GetEdition(XmlDocument XmlDoc)
        {
            string FileNames = string.Empty;

            XmlNodeList NodeList = XmlDoc.SelectNodes("//AppVersion");
            foreach (XmlNode FileNode in NodeList)
            {
                FileNames = FileNode.InnerText;
            }

            return FileNames;

        }


        /// <summary>
        /// 通过物理验证得到发送服务端的版本号
        /// </summary>
        /// <param name="XmlDoc"></param>
        /// <param name="?"></param>
        /// <returns></returns>
        public static string GetEditionAccord(XmlDocument localFileConfig, out Dictionary<string, string> localFiles)
        {
            if (!BalanceFileMd5(localFileConfig, out  localFiles))
            {
                //如果物理验证不相符合返回最小版本号
                return MINVERSIONNUMBER;
            }
            else
            {
                return CommFunc.GetEdition(localFileConfig);
            }
        }

 

        /// <summary>
        /// 计算文件的 MD5 值
        /// </summary>
        /// <param name="fileName">要计算 MD5 值的文件名和路径</param>
        /// <returns>MD5 值16进制字符串</returns>
        public static string MD5File(string fileName)
        {
            return HashFile(fileName, "md5");
        }

 

        /// <summary>
        /// 计算文件的哈希值
        /// </summary>
        /// <param name="fileName">要计算哈希值的文件名和路径</param>
        /// <param name="algName">算法:sha1,md5</param>
        /// <returns>哈希值16进制字符串</returns>
        public static string HashFile(string fileName, string algName)
        {
            if (!System.IO.File.Exists(fileName))
                return string.Empty;

            FileStream fs = File.OpenRead(fileName);
            byte[] hashBytes = HashData(fs, algName);
            fs.Close();
            return ByteArrayToHexString(hashBytes);
        }

 

        /// <summary>
        /// 计算哈希值
        /// </summary>
        /// <param name="stream">要计算哈希值的 Stream</param>
        /// <param name="algName">算法:sha1,md5</param>
        /// <returns>哈希值字节数组</returns>
        public static byte[] HashData(Stream stream, string algName)
        {
            HashAlgorithm algorithm;
            if (string.Compare(algName, "sha1", true) == 0)
            {
                algorithm = SHA1.Create();
            }
            else
            {
                algorithm = MD5.Create();
            }
            return algorithm.ComputeHash(stream);
        }

 

        ///<summary>
        /// 字节数组转换为16进制表示的字符串
        /// </summary>
        public static string ByteArrayToHexString(byte[] buf)
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in buf)
                sb.AppendFormat("{0:x2}", b);
            return sb.ToString();

        }

        /// <summary>
        /// 获取更新工具名称
        /// </summary>
        /// <returns></returns>
        public static string GetUpdateToolExe(XmlDocument XmlDoc)
        {
            string UpdateToolNames = string.Empty;

            XmlNodeList NodeList = XmlDoc.SelectNodes("//ToolsName");
            foreach (XmlNode FileNode in NodeList)
            {
                UpdateToolNames = FileNode.InnerText;
            }

            return UpdateToolNames;


        }


        #endregion


        #region 单点登陆  wdk
        /// <summary>
        /// 注册表注册
        /// </summary>
        public static bool SetRegistry(out string error)
        {
            error = "";
            string ProtocolName = string.Empty;
            string ApploctionName = string.Empty;

            XmlDocument XmlDoc = new XmlDocument();
            //不能使用Directory.GetCurrentDirectory() 因为在游览器访问的时候Directory.GetCurrentDirectory()的地址是游览器的地址
            string path = Path.Combine(AppLicationPath + @"/", "Config//YGApp.AppPrivateConfig.xml");
            try
            {
                XmlDoc.Load(path);
                XmlNodeList ProtocolNameList = XmlDoc.SelectNodes("//ProtocolName");//读取要注册到注册的名称
                XmlNodeList AppNameList = XmlDoc.SelectNodes("//ApplicationName");//启动程序的名称
                foreach (XmlNode Nodes in ProtocolNameList)
                    ProtocolName = Nodes.InnerText;
                foreach (XmlNode AppNodes in AppNameList)
                    ApploctionName = AppNodes.InnerText;
                RegistryKey pregkey;
                pregkey = Registry.ClassesRoot.OpenSubKey(ProtocolName);//AppMianName
                string GetRegisValue = string.Empty;
                string RegisterPath = Path.Combine(AppLicationPath + @"/", "Config//YGAPP.RegisterTemplate.config");
                if (pregkey != null && pregkey.GetValue("URL Protocol") != null)
                {

                    //判断注册信息的注册路径是否正确
                    GetRegisValue = pregkey.GetValue("URL Protocol").ToString();
                    if (!GetRegisValue.Equals(Path.Combine(AppLicationPath + @"/", ApploctionName)))
                    {
                        //路径不正确删除项重新注册
                        Registry.ClassesRoot.DeleteSubKeyTree(ProtocolName);
                        WriteFileToTempDir(RegisterPath, ProtocolName, ApploctionName, out error);
                    }
                }
                else
                {

                    if (pregkey != null)
                        Registry.ClassesRoot.DeleteSubKeyTree(ProtocolName);

                    WriteFileToTempDir(RegisterPath, ProtocolName, ApploctionName, out error);
                }
            }
            catch (System.Exception ex)
            {
                error = ex.Message;
            }
            return string.IsNullOrEmpty(error);
        }

        /// <summary>
        /// 生成文件到临时目录
        /// </summary>
        private static bool WriteFileToTempDir(string LoaclFilePath, string BindingName, string ApploctionName, out string error)
        {
            error = "";
            FileStream FileCreate = null;
            byte[] buffer = null;
            // @"D:/TestUrl/URl.config";
            try
            {
                //读取文件
                FileCreate = File.OpenRead(LoaclFilePath);
                buffer = new byte[FileCreate.Length];
                FileCreate.Read(buffer, 0, buffer.Length);
                FileCreate.Close();
                //模版内容
                string TemplateText = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
                //程序的路径
                string AppLocalPath = Path.Combine(Directory.GetCurrentDirectory(), ApploctionName).Replace("//", "");
                //临时目录的路径
                string TempRegisterPath = Path.Combine(Environment.GetEnvironmentVariable("Temp") + @"/", "Temp_Register.reg");
                //模版替换
                TemplateText = TemplateText.Replace("#SysName#", BindingName).Replace("#ProgrammePath#", AppLocalPath);

                //FileStream _FileCreate = null;
                StreamWriter FileStreamWrite = null;

                FileCreate = new FileStream(TempRegisterPath, FileMode.Create);
                FileStreamWrite = new StreamWriter(FileCreate, System.Text.Encoding.Unicode);
                //开始写入
                FileStreamWrite.Write(TemplateText);
                //清空缓冲区
                FileStreamWrite.Flush();
                //关闭流
                FileStreamWrite.Close();
                FileCreate.Close();

                Process process = new Process();
                process.StartInfo = new ProcessStartInfo("regedit.exe", "/s " + TempRegisterPath);
                process.Start();// Start(startInfo);
                process.WaitForExit();
                //删除临时注册文件
                File.Delete(TempRegisterPath);
                RegistryKey pregkey;
                pregkey = Registry.ClassesRoot.OpenSubKey(BindingName);
                if (pregkey == null)
                {
                    error = "系统无法将信息写入到注册表!/r/n请检查是否有windows系统注册表写入权限,并请暂时停用杀毒软件与防火墙";
                }
            }
            catch (System.Exception ex)
            {
                error = "系统信息写入注册表发生错误" + ex.Message;
            }
            return string.IsNullOrEmpty(error);
        }

        /// <summary>
        /// 获取更新提示
        /// </summary>
        /// <param name="strUpateMegs"></param>
        /// <returns></returns>
        public static string GetUpdateMessage(string strUpateMegs)
        {
            //MessageBox.Show(strUpateMegs);
        
            if (strUpateMegs.Split('|').Length > 1)
                return System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(strUpateMegs.Split('|')[1]));
            else
                return "";

        }

        /// <summary>
        /// 令牌字符串解析
        /// </summary>
        public static string strTokenParse(string strToken,out string userName)
        {
            // YgSale://?Token=1jh34jh213j4kj&para1=value1
            userName="";
            string ParseToken = "";
            //单点登录的解析
            if (strToken.Contains(@":") && strToken.Contains("Token=") )
            {
                string[] strTokenArray = strToken.Split(':');
                if (strTokenArray != null && strTokenArray.Length > 1)
                {
                    string[] strTokenParam = strTokenArray[1].Split(new string[] { "&&" }, StringSplitOptions.None);
                    if (strTokenParam != null && strTokenParam.Length > 1)
                    {
                        userName = strTokenParam[0].Replace("Token=", string.Empty);
                        ParseToken = strTokenParam[1];
                    }
                }
              
              
            }
            //程序更新时的解析
            else if (strToken.Contains("&&"))
            {
                string[] strTokenParam = strToken.Split(new string[] { "&&" }, StringSplitOptions.None);
                if (strTokenParam != null && strTokenParam.Length > 1)
                {
                    userName = strTokenParam[0];
                    ParseToken = strTokenParam[1];
                }
            }
            else
            {
                ParseToken = strToken;
            }
            return ParseToken;
        }


        /// <summary>
        /// 解析提取更新内容提示
        /// </summary>
        /// <param name="Edition"></param>
        /// <returns></returns>
        public static string ParseXmlGetMessages(string strloadXml, out string error)
        {
            error = "";
            XmlDocument xmlDoc = new XmlDocument();
            string Messages = string.Empty;
            try
            {
                xmlDoc.LoadXml(strloadXml.Split('|')[1]);

                XmlNodeList NodeList = xmlDoc.SelectNodes("//ToolipMesg");
                foreach (XmlNode FileNode in NodeList)
                {
                    Messages = FileNode.InnerText;
                }

            }
            catch (System.Exception ex)
            {
                error = "获取提示信息文件读取失败" + ex.Message + "/r/n" + ex;
            }
            return Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(Messages));

        }


        /// <summary>
        /// 根据ip得到网卡mac地址
        /// </summary>
        /// <param name="ip">给出的ip地址</param>
        /// <returns>对应ip的网卡mac地址</returns>
        public static string GetMACByIP(string ip,out string error)
        {
            error = string.Empty;
            string macinfo = string.Empty;//mac信息
            try
            {
                Int32 len = 6;
                byte[] _byte = new byte[len];
                Int32 destinationIp = inet_addr(ip); //目的地的ip
               // Int64 macinfo = new Int64();
                int res = SendARP(destinationIp, 0, _byte, ref len);
                macinfo = BitConverter.ToString(_byte, 0, len);
                if (macinfo.Equals("00-00-00-00-00-00"))
                {
                    error = "检测到提供的环境服务器IP访问无效,检查该网段是否已被限制访问或管理员没有设置限制环境服务器的IP";
                    macinfo = string.Empty;
                }
             
            }
            catch (Exception err)
            {
                error = "Ping IP获取MAC地址出错, 原因:" + err.Message + err.StackTrace;
            }
            return macinfo;
        }

 

        #endregion


    }


}

GTBGT525
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Ping code 实现分享
dreamordream的博客
07-11 3132
   很久之前参阅文档写了ping实现，当时不甚在意，没有留档，导致后续需要的时候又得费力，发此code，一是留档，而是共勉，能为他人提供方便，将不甚荣幸，结构或有不够严谨，但作为ping测试却是可以了，报文结构网述颇多，这里就不再详述了    该code中icmp报文结构为自组装，适合轻量级嵌入式系统中调用#include &lt;stdio.h&gt;#include &lt;sys/time...
PingCode 的环境和环境管理
weixin_sjk6070的博客
05-05 2305
我们还需要将软件的新版本持续的通过 CD 部署到不同的环境中，再进一步，我们随时需要创建一个新的环境，然后将 CD 接入进去，实现首次的部署，再进一步，我们只需要一个信号，就可以销毁掉这个环境，释放掉它占用的硬件、网络等资源。除了功能层面的测试，预发布环境还会进行部署层面的测试，不同于通过主分支上的代码变动实现测试环境的持续部署，我们通过打 Tag 来实现预发布环境的部署，而这次部署用的制品（Docker 镜像）将被长期存放在制品库里，也只有经过验证的制品才能用于后面的环境，相当于功能锁定了。
PingCode 是用来干嘛的？
柚橙论
11-12 7077
PingCode 是一款研发管理工具，相信这一点大家都普遍了解，但具体干啥的你可能心里还是没底。具体来说，PingCode 是一个研发管理工具集合，截止今年11月已经发布7款子产品，分别有着如下作用： 1、PingCode Agile ：提供标准的敏捷项目管理（Scrum、Kanban），支持需求管理、任务管理、缺陷管理、迭代管理等； 2、PingCode Tesnthub：提供全流程的测试用例管理与缺陷追踪方案，并与需求、任‌‌务相关联，自动生成测试报告； 3、PingCode Wiki：企业知
PingCode 3.0 发布，开启国产研发自动化时代
柚橙论
05-26 871
PingCode Agile帮助团队实施敏捷开发，通过Scrum或Kanban规范团队的协作流程。 PingCode Testhub组织测试团队的测试用例和测试计划，为最终的产品质量保驾护航。 PingCode Wiki将知识与经验进行总结和沉淀，保证了团队信息的准确性和正确性。 PingCode Plan和PingCode Goals通过规模化敏捷和OKr，将管理能力向上延伸到跨团队以及整个研发体系，保证了产品目标的一致性。 那么问题是，研发团队在使用了上述的几款产品之后，是否还有提升的空间呢？ .
PingCode Insight 正式发布，让研发效能真正可量化、可分析、可提升
柚橙论
04-07 5966
PingCode Insight 正式发布，让研发效能真正可量化、可分析、可提升
PingCode 产品怎么样？产品底层逻辑是什么样的？
柚橙论
05-01 1138
PingCode作为国内首款主打智简研发理念的研发管理产品，经过3年时间的迭代与升级，累计发布480个版本，上线7款子产品（第8款子产品即将上线）。 PingCode 形成了涵盖项目管理 Project 、测试管理 Testhub、知识管理 Wiki、效能度量 Insight 、目标管理 Goals 等场景在内的All-in-One 研发管理工具。 本篇文章，我们会重点来聊聊 PingCode 产品设计的底层逻辑。 分层设计体系 在企业数字化转型的时代，研发管理能力已经成为一家公司的核心竞争..
SaaSBase：什么是PingCode？
HelpLook的博客
07-19 717
作为SaaS产品的发掘者，SaaSBase（saasbase.cn）今天带大家了解一个优秀的项目管理软件：PingCode ——智能化研发管理工具。
禅道与PingCode哪个好？
柚橙论
07-08 1730
本文将会从PingCode与禅道的公司背景、功能性、非功能性、服务等几个方面来对比两个产品。帮助每一个选型者快速的找到适合自己的那一款。
Worktile旗下智能化研发管理工具PingCode 宣布25人以下免费
柚橙论
11-05 4369
Worktile旗下智能化研发管理工具PingCode，宣布免费！ 自2020年11月5日起，25人以下研发团队，可不限时间、不限用量，免费使用PingCode所提供的Agile（敏捷开发）、Wiki（知识库）、Testhub（测试管理）、Plan（项目集）四款子产品，零成本实现研发全流程管理，降本增效。 源自Worktile，厚积而薄发 PingCode由Worktile团队打造，而今天，是Worktile的7周年生日。 7年是沉淀，Worktile团队围绕企业协作、智能研发管...
PingCode 全年上线功能盘点
柚橙论
12-31 1万+
2020即将完结，回顾过去一年，PingCode从正式发布，到上线全新的子产品、小程序，丰富应用市场，以及上线非常多的重要功能，我们实现了非常大的成长。 下面，我们就从五个方面来为大家进行简单介绍： 1、在2020年，我们收到了非常多用户关于管理场景的诉求，就比如查看工时、规划管理等等，而这些诉求，我们也在这一年中尽可能的做了优化和上线，就比如Plan、Agile的各种规划、工时统计等； 2、同时，我们针对研发管理中最普遍的问题——使用众多研发管理工具而造成数据割裂的问题，我们也上线了Marketplace
PingCode新成员Goals开放内测！
柚橙论
03-02 371
​四年前，随着6.0版本上线，Worktile 成为国内首家将 OKR 方法以软件形式实施落地的企业级协作平台。四年中，我们帮助500+企事业单位在理念和工具层面成功落地 OKR，同时也注意到： 目标管理和敏捷模式，正在被越来越多的科技公司所选用，用以激发产研团队潜能，创造更受欢迎的产品； 去年2020版 Scrum Guide 正式引入了“产品目标（Product Goal）”这个概念，旨在为敏捷团队提供更长期主义、更具价值的指引； 通用型 OKR 工具难以回应敏捷研发场景的特殊
PingCode：引领敏捷开发的项目管理新范式
最新发布
欢迎来到软件测试jeffky博客！在这里，我们将探讨各种与软件测试相关的主题，包括测试策略、方法、工具、最佳实践和行业趋势。我们的目标是帮助读者提高软件质量，确保用户满意度，并分享在软件测试领域的知识和经验。
01-23 966
在快速变化的软件开发行业中，项目管理工具的选择对于团队的协作效率和项目的成功率至关重要。通过采用PingCode，团队可以实现更高效的协作，更高的项目透明度，以及更快的交付速度。随着敏捷开发理念的普及，PingCode这样的工具将成为推动软件开发行业进步的重要力量。PingCode是一款专为软件开发团队设计的项目管理工具，它融合了敏捷开发的方法论，提供了从需求收集、项目规划、任务分配到进度跟踪、质量保证等一系列功能。PingCode的目标是帮助团队更好地协作，提高项目的透明度，确保项目按时交付。
国内外最顶级的十大敏捷项目管理软件【2022】
柚橙论
02-11 1万+
随着敏捷的普及，支持其开发模式的工具也越来越多。它和瀑布工具的巨大差异在于一个是任务管理模式，一个是需求驱动管理模式。在这里，我列出了在国内外最知名最好用的敏捷工具及其网站。 1、PingCode 适用对象：500人以下的中小型企业 品牌知名度介绍： 由国内老牌SaaS 厂商Worktile 打造，成立于2012年，在2021年PingCode 在36氪企服点评发布的研发项目管理工具榜排名 TOP1 。 除此以外，PingCode 在国内多个领域出于领先地位，比如具有国内最先进的研发自动化管理
瀑布式项目管理软件测评！
柚橙论
06-15 1924
专业的瀑布项目管理工具是专门用来帮助计划和控制项目资源、成本与进度的工具。通常来说，瀑布项目管理工具包括项目计划、需求管理、开发过程管理、测试缺陷管理、构建发布、文档管理、可视化报表等功能模块。......
敏捷团队如何在 PingCode 这类敏捷开发工具中管理 Scrum 开发管理流程
柚橙论
04-13 1093
在创建迭代（Sprint）时，产品负责人通常会确定迭代目标。这为迭代中要完成的工作提供了一个方向。迭代目标还为迭代中完成的用户故事数量提供了一定的灵活性。如果迭代目标已实现，那么迭代就可以被认为是成功的。
国内外9大最佳测试管理平台
柚橙论
08-13 6053
软件测试管理是软件开发项目中一个很重要的环节，近些年随着可用的测试工具越来越多，测试系统本身越来越复杂，管理测试活动的各个方面已经成为一个越来越大的挑战。
让你的GitHub下载飞速提升到2M/s以上
评布客
07-28 5731
2020年7月27日整理发布多种GitHub加速方式！ 转载自：https://code.pingbook.top/blog/2020/How-To-Speed-Github.html 1. GitHub 镜像访问 这里提供两个最常用的镜像地址： https://github.com.cnpmjs.org https://hub.fastgit.org 也就是说上面的镜像就是一个克隆版的Github，你可以访问上面的镜像网站，网站的内容跟Github是完整同步的镜像，然后在这个网站里面进行下载克隆等操作
禅道、码云、coding、redmine、jira、teambition几大敏捷开发项目管理系统试用对比体验
热门推荐
大路的博客
09-01 5万+
作为一个软件公司的管理人员，在项目和人员多起来后，就需要通过系统来对项目和人员进行管理。 我们是典型的软件外包公司，专为客户定制软件，所以我们的业务都是项目型的。因此，在管理模式上，我们就要用所谓的敏捷开发。 到目前为止，我们同时进行的项目有四五个，人员有十来个。 我们都是土枪土炮，PM（Project Manage）的管理不是专业出生，对敏捷开发的模式和精髓也是一知半解。因此，寻找一款适合...
研发管理工具之迭代管理测评：PingCode VS Jira
柚橙论
04-19 3386
本文由 Worktile 产品研发部负责人@徐海峰分享 Jira是国外著名的敏捷研发管理工具，PingCode是近几年国内最亮眼、发展最快的智能化研发管理工具；两大明星产品到底哪个做迭代管理更胜一筹呢？ 在正式开始对比之前，我们先来复习一些关于敏捷开发、迭代和 Scrum 的知识点。 一、基本概念 什么是敏捷开发？ 敏捷开发是一种以人为核心、迭代、循序渐进的开发方法。在敏捷开发中，软件项目的构建被切分成多个子项目，各个子项目的成果都经过测试，具备集成和可运行的特征。 什么是迭代？ ..
关于远程办公，微软MVP 15年研发团队的经验分享
柚橙论
02-06 5187
今天是2月5日，春节假期结束后的第三天了。为了能够应对来势汹汹的疫情，众多互联网企业纷纷开启了远程办公模式。不知道各团队前两天的远程办公效果如何，我们 Worktile 管理层在大年初四就开始讨论远程办公的事情，并且将可能出现的问题都尽量提前想到并做了准备。从这两天实际执行的情况看，我所在的研发团队执行的还不错，基本没有受到什么明显的影响。因此我们希望将我们远程办公的一些思考、准备和实践分享给大家...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值