C# NLogEx.LoggerEx.Trace方法代码示例

        /// <summary>
        /// 初始化rtp模块
        /// </summary>
        public void ESDK_RTP_Init()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: RtpAdapter.ESDK_RTP_Init().");

            try
            {
                int iRet = 0;
                if (!isInited)
                {
                    iRet = SdkRtpInterface.ESDK_RTP_Init();
                    logEx.Trace("Enter: RtpAdapter.ESDK_RTP_Init(). This is first init!");
                }
                if (iRet != 0)
                {
                    logEx.Error("RtpAdapter.ESDK_RTP_Init ,error:{0}", iRet);
                    isInited = false;
                }
                else
                {
                    logEx.Trace("Enter: RtpAdapter.ESDK_RTP_Init().Success");
                    isInited = true;
                }
                logEx.Trace("Enter: RtpAdapter.ESDK_RTP_Init(). inited is {0}!", isInited);
            }
            catch (System.Exception ex)
            {
                logEx.Error("RtpAdapter.ESDK_RTP_Init ,Exception:{0}", ex.ToString());
                isInited = false;
            }
        }

        /// <summary>
        /// 分配监控通道
        /// </summary>
        public SmcErr AssignMonitorChannel(List<ChannelInfo> ChannelInfoList)
        {
            SmcErr err = new CgwError();
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            err = CheckSession();
            if (err.IsSuccess())
            {
                if (ChannelInfoList != null)
                {
                    err = MonitorChannelBll.Instance().AssignMonitorChannel(ChannelInfoList);

                }
                else
                {
                    err.SetErrorNo(CgwError.ERR_CGW_BUSINESS_CHANNELLIST_NULL);
                }

            }
            if (err.IsSuccess())
            {
                logEx.Trace("AssignMonitorChannel Successful");
            }
            else
            {
                logEx.Error("AssignMonitorChannel failed,ErrNo :{0}", err.ErrNo);
            }
            return err;
        }

        /// <summary>
        /// 获取自定义设备列表
        /// </summary>
        /// <returns>成功返回对象列表，失败返回null</returns>
        public List<Resource> GetCustomTree()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyHttpClient.GetCustomTree().");

            //设置访问天地伟业登陆接口的uri
            string requestUrl = string.Format(
                                "{0}/GetCustomTree.jsp?CurrentUserId={1}&UserId={2}&Password={3}",
                                this.serverUrl,
                                this.user,
                                this.user,
                                pwd);
            //日志不能记密码，单独处理
            string logString = string.Format(
                                "{0}/GetCustomTree.jsp?CurrentUserId={1}&UserId={2}&Password=******",
                                this.serverUrl,
                                this.user,
                                this.user);

            logEx.Trace("Call function TiandyHttpClient.GetResourceTree({0}).", logString);
            List<Resource> resources = GetResourceTree(requestUrl);

            return resources;
        }

        /// <summary>
        /// 关闭通道
        /// </summary>
        /// <param name="uiChannel"></param>
        public void ESDK_RTP_CloseChannel(uint uiChannel)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: RtpAdapter.ESDK_RTP_CloseChannel().");

            try
            {
                int iRet = SdkRtpInterface.ESDK_RTP_CloseChannel(uiChannel);

                if (iRet != 0)
                {
                    logEx.Error("RtpAdapter.ESDK_RTP_CloseChannel ,error:{0}", iRet);
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("RtpAdapter.ESDK_RTP_CloseChannel ,Exception:{0}", ex.ToString());
            }
        }

        /// <summary>
        /// 获取摄像头列表及分组信息
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void GetAllCamerasTimer(object sender, System.Timers.ElapsedEventArgs e)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.GetAllCamerasTimer().");

            if (refreshMonitorCameraOperateLock.TryEnterWriteLock(CgwConst.EFRESH_MONITOR_CAMERA_WAIT_TIME))
            {
                try
                {
                    GetAllCamerasMethod();
                }
                finally
                {
                    refreshMonitorCameraOperateLock.ExitWriteLock();
                }
            }
        }

        /// <summary>
        /// 清除缓存数据
        /// </summary>
        private void ClearCamera()
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.ClearCamera().");
            if (this.cameraOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    this.tiandyCameraDictionary = new Dictionary<string, TiandyCamera>();
                    this.hostDictionary = new Dictionary<string, Host>();
                    this.mediaServerDictionary = new Dictionary<string, MediaServer>();

                    this.groupDic = new Dictionary<string, CameraGroup>();
                    this.nodeRelationList = new List<NodeRelation>();
                }
                finally
                {
                    this.cameraOperateLock.ExitWriteLock();
                }
            }
            logEx.Trace("Clear Camera which in the cache success.");
        }

        /// <summary>
        /// 停止预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns>成功返回0，失败返回错误码</returns>
        public SmcErr StopReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.StopReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();

            //需要停止的预览句柄
            int needToStopHandel = CgwConst.START_RECEIVE_VIDEO_DATA_FAILED;
            if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (this.cameraVideoHandeDic.ContainsKey(cameraNo))
                    {
                        needToStopHandel = this.cameraVideoHandeDic[cameraNo];
                        this.videoHandleCameraDic.Remove(needToStopHandel);
                        this.cameraVideoHandeDic.Remove(cameraNo);
                    }
                    else
                    {
                        //不存在，表示已经删除，不返回错误
                        //err.SetErrorNo(CgwError.STOP_RECEIVE_VIDEO_FAILED);
                        logEx.Warn("Stop Receive camera video data failed. Don't need to end the preview.Camera No:{0}.", cameraNo);
                    }
                }
                finally
                {
                    this.handelOperateLock.ExitWriteLock();
                }
            }

            //调用sdk的停止方法，放在handelOperateLock外面，防止长时间占用锁
            if (needToStopHandel != CgwConst.START_RECEIVE_VIDEO_DATA_FAILED)
            {
                this.sdkClient.StopReceiveVideo(needToStopHandel);
            }

            logEx.Info("Stop Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, needToStopHandel);
            return err;
        }

        /// <summary>
        /// 启动摄像头预览
        /// </summary>
        /// <param name="cameraNo">摄像头编号</param>
        /// <returns></returns>
        public SmcErr StartReceiveVideo(string cameraNo)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.StartReceiveVideo({0}).", cameraNo);
            SmcErr err = new CgwError();

            TiandyCamera camera = null;
            Host host = null;

            //摄像头所连接的流媒体服务器
            MediaServer cameraMediaServer = null;
            if (this.cameraOperateLock.TryEnterReadLock(CgwConst.ENTER_LOCK_WAIT_TIME))
            {
                try
                {
                    if (!this.tiandyCameraDictionary.ContainsKey(cameraNo))
                    {
                        err.SetErrorNo(CgwError.CAMERA_NOT_FOUND);
                        logEx.Error("Start Receive camera video data failed.Camera No is not found.Camera No:{0}", cameraNo);
                        return err;
                    }
                    camera = this.tiandyCameraDictionary[cameraNo];
                    host = this.hostDictionary[camera.HostNo];
                    cameraMediaServer = this.mediaServerDictionary[host.MediaServerNo];
                }
                catch (Exception e)
                {
                    err.SetErrorNo(CgwError.START_RECEIVE_VIDEO_FAILED);
                    logEx.Error("Start Receive camera video data failed.Camera No:{0},Execption message:{1}", cameraNo, e.Message);
                    return err;
                }
                finally
                {
                    this.cameraOperateLock.ExitReadLock();
                }
            }

            if (camera == null)
            {
                err.SetErrorNo(CgwError.START_RECEIVE_VIDEO_FAILED);
                logEx.Error("Start Receive camera video data failed.Camera No is not found.Camera No:{0}", cameraNo);
                return err;
            }

            RealPlayInfo real = new RealPlayInfo();
            real.ch = camera.Channel;
            real.data_type = (int)TiandyDateType.PRIMARY;
            real.hPlayWnd = null;

            int result = this.sdkClient.StartReceiveVideo(host.No, cameraMediaServer, ref real);

            //如果为负数，表示预览失败
            if (result < 0)
            {
                err.SetErrorNo(CgwError.START_RECEIVE_VIDEO_FAILED);
                logEx.Error("Start Receive camera video data failed.Camera No:{0}.", cameraNo);
                return err;
            }
            else
            {
                //需要停止的预览句柄
                int needToStopHandel = CgwConst.START_RECEIVE_VIDEO_DATA_FAILED;
                if (this.handelOperateLock.TryEnterWriteLock(CgwConst.ENTER_LOCK_WAIT_TIME))
                {
                    try
                    {
                        //如果预览句柄已经存在，删除掉原来的句柄,用新的句柄替换
                        if (this.cameraVideoHandeDic.ContainsKey(cameraNo))
                        {
                            needToStopHandel = this.cameraVideoHandeDic[cameraNo];
                            this.videoHandleCameraDic.Remove(needToStopHandel);
                            this.cameraVideoHandeDic.Remove(cameraNo);
                        }
                        this.cameraVideoHandeDic.Add(cameraNo, result);
                        this.videoHandleCameraDic.Add(result, cameraNo);
                    }
                    finally
                    {
                        this.handelOperateLock.ExitWriteLock();
                    }
                }
                logEx.Info("Start Receive camera video data success.Camera No:{0},Handle:{1}.", cameraNo, result);
                //重新预览后，更新了预览句柄，需要将原来的预览停止，放在handelOperateLock外面，防止长时间占用锁
                if (needToStopHandel != CgwConst.START_RECEIVE_VIDEO_DATA_FAILED)
                {
                    this.sdkClient.StopReceiveVideo(needToStopHandel);
                }
            }

            return err;
        }

 /// <summary>
 /// 指定码流回调函数
 /// </summary>
 /// <param name="videoDataCallBack"></param>
 /// <param name="sender"></param>
 public void SetDataCallBackFunc(DataCallBack dataCallBack, string sender)
 {
     NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
     logEx.Trace("Enter: TiandyVideoMonitor.SetDataCallBackFunc().");
     this.dataCallBack = dataCallBack;
     this.sender = sender;
 }

        /// <summary>
        /// 初始化天地伟业监控平台
        /// </summary>
        /// <param name="monitorConfigElement">监控平台配置节点</param>
        /// <returns></returns>
        public SmcErr Load(XmlElement monitorConfigElement)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyVideoMonitor.Load().");
            SmcErr err = new CgwError();

            string userLevel = "";
            //解析xml节点，获取所需参数
            try
            {
                #region Tiandy视频监控平台（Easy7）连接信息
                this.monitorId = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.ID_TAG);

                userLevel = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PTZCONTROLLEVEL_TAG);

                string httpUser = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PLATFORM_USER_TAG);

                string httpPassword = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PLATFORM_PASSWORD_TAG);

                string httpUrl = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PLATFORM_URL_TAG);

                string mediaServerId = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.MEDIASERVER_SERVERID_TAG);
                #endregion
                this.httpClient = new TiandyHttpClient(httpUrl, httpUser, httpPassword);

                //使用线程轮询加载监控平台
                Thread loaderThread = new Thread(LoaderThread);
                loaderThread.Start(mediaServerId);

            }
            catch (Exception e)
            {
                err.SetErrorNo(CgwError.MONITOR_CONFIG_FILE_INVALID);
                logEx.Error("Load Tiandy monitor failed.Execption message:{0}.", e.Message);
                return err;
            }

            this.sdkClient = new TiandySdkClient();
            //如果控制级别配置错误，只记录错误日志，不向外报错
            try
            {
                this.sdkClient.PtzControlLevel = int.Parse(userLevel);
            }
            catch (Exception e)
            {
                logEx.Error("Ptz Control Level is invalid.Execption message:{0}.", e.Message);
                this.sdkClient.PtzControlLevel = CgwConst.PTZ_CONTROL_LEVEL;
            }
            logEx.Info("Load video monitor success.Monitor id:{0}.", this.monitorId);
            return err;
        }

 /// <summary>
 /// 指定码流回调函数
 /// </summary>
 /// <param name="videoDataCallBack"></param>
 /// <param name="sender"></param>
 public void SetDataCallBackFunc(DataCallBack videoDataCallBack, string sender)
 {
     NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
     logEx.Trace("Enter: IvsVideoMonitor.SetVideoDataCallBackFunc().");
     this.dataCallBack = videoDataCallBack;
     this.sender = sender;
     logEx.Info("Set VideoDataCallBackFunc success. Monitor id:{0}", this.monitorId);
 }

 /// <summary>
 /// 重发I帧（暂不支持）
 /// </summary>
 /// <param name="cameraNo">摄像头编号</param>
 /// <returns></returns>
 public SmcErr MakeIFrame(string cameraNo)
 {
     NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
     logEx.Trace("Enter: IvsVideoMonitor.MakeIFrame({0}).", cameraNo);
     SmcErr err = new CgwError();
     return err;
 }

        /// <summary>
        /// 初始化IVS监控平台
        /// </summary>
        /// <param name="monitorConfigElement">监控平台配置节点</param>
        /// <returns></returns>
        public SmcErr Load(XmlElement monitorConfigElement)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Info("Enter: IvsVideoMonitor.Load().");
            SmcErr err = new CgwError();

            try
            {
                //解析xml节点，获取所需参数
                this.monitorId = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.ID_TAG);
                ip = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.IP_TAG);
                port = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PORT_TAG);
                user = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.USER_TAG);

                //password = CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PASSWORD_TAG);
                pwdByte = CommonFunction.EncryptStr2Byte(CommonFunction.GetSingleNodeValue(monitorConfigElement, CgwConst.PASSWORD_TAG),CgwConst.PASSWORD_TAG);

                //从配置文件读取的参数要简单判断一下合法性

                //初始化之前设置日志路径
                logEx.Trace("Call SetLogPath:{0}", ivsLogPath);
                this.ivsSdkClient.SetLogPath(ivsLogPath);

                logEx.Trace("Call ivsSdkClient.Init().");
                //初始化
                int result = this.ivsSdkClient.Init();
                if (result != CgwConst.IVS_SDK_SUCCESS_TAG)
                {
                    //直接将IVS的错误码返回
                    err.SetErrorNo(CgwError.MONITOR_LOAD_FAILED);
                    logEx.Error("Init ivs monitor failed.Monitor id:{0}.ivs sdk error code:{1}.", this.monitorId, result);
                    return err;
                }
                else
                {
                    logEx.Info("Init ivs sdk success.Monitor id:{0}", this.monitorId);
                }

                //设置监控平台id
                this.ivsSdkClient.SetId(this.monitorId);

                this.sdkCallbackFunc = IvsRealPlayCallBackRaw;
                this.ivsSdkClient.SetRealPlayCBRawCallBackFunc(this.sdkCallbackFunc);

                //sdk事件回调
                this.ivsEventCallBackFunc = IvsEventCallBackFunc;
                this.ivsSdkClient.SetEventCallBackFunc(this.ivsEventCallBackFunc);

                IvsLoginInfo loginInfo = new IvsLoginInfo();
                loginInfo.Ip = ip;
                loginInfo.Port = int.Parse(port);
                loginInfo.User = user;
                //loginInfo.Pwd = password;
                loginInfo.Pwd = CommonFunction.DecryptByte2Str(pwdByte,CgwConst.PASSWORD_TAG);

                loadResult = false;
                //使用线程轮询加载监控平台
                Thread loaderThread = new Thread(LoginThread);
                loaderThread.IsBackground = true;
                loaderThread.Start(loginInfo);
            }
            catch (Exception e)
            {
                err.SetErrorNo(CgwError.MONITOR_CONFIG_FILE_INVALID);
                logEx.Error("Load ivs monitor failed.Execption message:{0}.", e.Message);
                return err;
            }

            logEx.Info("Load video monitor success.Monitor id:{0}.", this.monitorId);
            return err;
        }

        /// <summary>
        /// 监控平台加载器，轮询加载，直到成功
        /// </summary>
        /// <param name="loginInfo"></param>
        private void LoginThread(Object loginInfoObj)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: IvsVideoMonitor.LoginThread().");
            try
            {

                IvsLoginInfo loginInfo = loginInfoObj as IvsLoginInfo;

                while (!loadResult)
                {
                    if (loginInfo == null)
                    {
                        logEx.Error("loginInfoObj is Null.");
                        return;
                    }
                    //等待ivs sdk事件回调结束，再调用sdk接口，否则调用失败
                    Thread.Sleep(1000);
                    logEx.Trace("Call ivsSdkClient.Login({0},{1},{2},******).", loginInfo.Ip, loginInfo.Port, loginInfo.User);
                    //登陆
                    int result = this.ivsSdkClient.Login(loginInfo.Ip, loginInfo.Port, loginInfo.User, loginInfo.Pwd);
                    if (result != CgwConst.IVS_SDK_SUCCESS_TAG)
                    {
                        logEx.Error("Login to ivs monitor failed.Monitor id:{0}.ip:{1}, port:{2}, user:{3}.ivs sdk error code:{4}.",
            this.monitorId, loginInfo.Ip, loginInfo.Port, loginInfo.User, result);

                        //登陆失败，等待1分钟后再次尝试登陆
                        Thread.Sleep(CgwConst.RELOAD_MONITOR_WAIT_TIME);
                        loadResult = false;
                        continue;
                    }
                    else
                    {
                        logEx.Info("Login to ivs monitor success.Monitor id:{0}.ip:{1}, port:{2}, user:{3}.",
            this.monitorId, loginInfo.Ip, loginInfo.Port, loginInfo.User);
                        loadResult = true;
                    }

                    this.GetAllCamerasTimer(null, null);

                    //启动定时器
                    this.updateCameraTimer.Start();
                }
            }
            catch (System.Exception ex)
            {
                logEx.Error("Load IVS monitor failed. Exception message:{0}.", ex.Message);
            }
        }

        /// <summary>
        /// 调用天地伟业http接口
        /// </summary>
        /// <param name="requestUrl"></param>
        /// <returns>成功返回json字符串，失败返回null</returns>
        private string CallHttpInterface(string requestUrl)
        {
            NLogEx.LoggerEx logEx = new NLogEx.LoggerEx(log);
            logEx.Trace("Enter: TiandyHttpClient.CallHttpInterface().");
            Stream stream = null;
            string result = null;
            try
            {
                //调用http接口
                WebClient webClient = new WebClient();

                stream = webClient.OpenRead(requestUrl);
                StreamReader streamReader = new StreamReader(stream);

                //调用HTTP接口返回json字符串
                result = streamReader.ReadToEnd();
            }
            catch (Exception e)
            {
                result = null;
                logEx.Error("Call http function failed.Exception message:{0}.", e.Message);
            }
            finally
            {
                //记录日志，待日志模块合入后补充日志信息
                if (stream != null)
                {
                    stream.Close();
                }
            }
            return result;
        }