同步Socket客户端代码
来源：互联网 发布：红杉资本 人工智能 编辑：程序博客网 时间：2024/05/08 11:09
class NewNetWork
{
private static NewNetWork _network = null;
private NewNetWork()
{
//不需要调度到主线程的 命令
_PostList.Clear();
_PostList.Add(SendCommandType.NetGridData);
_PostList.Add(SendCommandType.SquaresGridData);
_PostList.Add(SendCommandType.ExceptionEvent);
_PostList.Add(SendCommandType.NetGridDataFind);
}
public static NewNetWork GetNewNetWdork
{
get
{
if (_network == null)
_network = new NewNetWork();
return _network;
}
}
#region 私有变量
/// <summary>
/// 不需要调度到主线程的 命令枚举
/// </summary>
private List<SendCommandType> _PostList = new List<SendCommandType>();
private Thread mythread;
private LogBlockDecoder lbd = new LogBlockDecoder();
// private FtpOperatingFire _ftp; //ftp访问类
/// <summary>
/// 参数报表 参数
/// </summary>
private List<RePortParamet> _listparamet = null;
/// <summary>
/// 事件报表参数
/// </summary>
private List<ReportException> _listexception = null;
//超时 计时器
private System.Timers.Timer t = new System.Timers.Timer(1000);
//计时 初始值
private int timenum = 0;
#endregion
#region 事件 public
///// <summary>
///// 数据传递完成、IO操作完成 参数传递dataset和 本次回调参数类型
///// </summary>
//public event delegate_load event_load;
///// <summary>
///// 超时设置 会发参数为true 则超时
///// </summary>
//public event IsTimeOut Event_TimeOut;
///// <summary>
///// 连接状态 返回连接状态 和 描述
///// </summary>
//public event Connection_State Event_ConnetionState;
///// <summary>
///// ftp 下载完成 -treelist
///// </summary>
//public event IsFinishFtpLoad Event_FtpLoadFile;
///// <summary>
///// Ftp 上传完成
///// </summary>
//public event IsFinishFtpUpLoad Event_FtpUpLoadFile;
///// <summary>
///// Ftp TreeList下载进度
///// </summary>
//public event FtpLoadPercent Event_FtpLoadPercent;
///// <summary>
///// 公共下载通知事件
///// </summary>
//public event IsFinishFtpLoad Event_FTPDownLoadFile;
//public event Action ReceiveFailEvent;
//#endregion
//# region FTP操作
///// <summary>
///// FTP 地址
///// </summary>
//private string FtpHostName = AFPUtility.GetAppSettingsByKeyName("FtpHostName");
///// <summary>
///// FTP 端口
///// </summary>
//private string FtpPort = AFPUtility.GetAppSettingsByKeyName("FtpPort");
///// <summary>
///// FTP 账号
///// </summary>
//private string FtpUserName = AFPUtility.GetAppSettingsByKeyName("FtpUserName");
///// <summary>
///// FTP密码
///// </summary>
//private string FtpPassword = AFPUtility.GetAppSettingsByKeyName("FtpPassword");
///// <summary>
///// 连接到FTP服务器
///// </summary>
//private FtpOperatingFire ConnectFTP()
//{
// FtpOperatingFire _ftp = new FtpOperatingFire(FtpHostName, "", FtpUserName, FtpPassword, Convert.ToInt32(FtpPort));
// return _ftp;
//}
/////// <summary>
/////// 下载一批文件
/////// </summary>
/////// <param name="strFileNameMask">文件名的匹配字符串</param>
/////// <param name="strFolder">本地目录(不得以\结束)</param>
////public void Get(string strFileNameMask, string strFolder)
////{
//// ConnectFTP();
//// _ftp.Get(strFileNameMask, strFolder);
////}
//SynchronizationContext context = SynchronizationContext.Current;
///// <summary>
///// 公共下载 执行完毕
///// </summary>
///// <param name="obj"></param>
//private void DownLoadFileComlete(object obj)
//{
// string msg = obj as string;
// if (Event_FtpLoadFile != null)
// {
// string head = msg[0].ToString();
// string body = msg.Substring(1);
// switch (head)
// {
// case "0":
// Event_FTPDownLoadFile(false, body);
// break;
// case "1":
// Event_FTPDownLoadFile(true, body);
// break;
// }
// }
//}
///// <summary>
///// 公共下载方法 保存到DownloadLogFile 文件夹
///// </summary>
///// <param name="strRemoteFileName">要下载的文件路径(需要填写扩展名)</param>
//public void DownLoadFile(string strRemoteFileName)
//{
// string strFolder = LoginInfo.LogPath;
// if (!Directory.Exists(strFolder))
// Directory.CreateDirectory(strFolder);
// SynchronizationContext context = SynchronizationContext.Current;
// Thread th = new Thread(delegate()
// {
// try
// {
// FtpOperatingFire _ftp = ConnectFTP();
// _ftp.Get(strRemoteFileName, strFolder, Path.GetFileName(strRemoteFileName), 0);
// context.Post(DownLoadFileComlete, "1" + Path.GetFileName(strRemoteFileName));
// _ftp.DisConnect();
// }
// catch (Exception ex)
// {
// LogInfo.Instance.Log(ex.ToString());
// context.Post(DownLoadFileComlete, "0" + Path.GetFileName(strRemoteFileName) + ": " + ex.Message);
// }
// });
// th.IsBackground = true;
// th.Start();
//}
///// <summary>
///// 子线程执行完毕
///// </summary>
///// <param name="msg"></param>
//private void TrigeEvent_Get(object obj)
//{
// string msg = obj as string;
// if (Event_FtpLoadFile != null)
// {
// string head = msg[0].ToString();
// string body = msg.Substring(1);
// switch (head)
// {
// case "0":
// Event_FtpLoadFile(false, body);
// break;
// case "1":
// Event_FtpLoadFile(true, body);
// break;
// }
// }
//}
///// <summary>
///// 下载一个文件 如果下载失败则尝试下载三次 TreeList使用
///// </summary>
///// <param name="strRemoteFileName">要下载的文件路径(需要填写扩展名)</param>
///// <param name="strFolder">本地目录(不得以\结束)</param>
///// <param name="strLocalFileName">保存在本地时的文件名(需要填写扩展名)</param>
///// <param name="filesize">文件大小</param>
//public void Get(string strRemoteFileName, string strFolder, string strLocalFileName, long filesize)
//{
// if (!Directory.Exists(strFolder))
// Directory.CreateDirectory(strFolder);
// SynchronizationContext context = SynchronizationContext.Current;
// Thread th = new Thread(delegate()
// {
// int tcount = 0; //当前文件下载 失败次数
// int index = 0;
// bool b = false;
// GoBack: //下载失败 继续返回下载
// try
// {
// index = strRemoteFileName.LastIndexOf("/") + 1;
// }
// catch (Exception ex)
// {
// LogInfo.Instance.Log(ex.ToString());
// context.Post(TrigeEvent_Get, "0" + strRemoteFileName.Substring(index) + ": " + ex.Message);
// return;
// }
// try
// {
// FtpOperatingFire _ftp = ConnectFTP();
// _ftp.Event_FtpLoadPercentBase += FtpPercentBack;
// _ftp.Get(strRemoteFileName, strFolder, strLocalFileName, filesize);
// context.Post(TrigeEvent_Get, "1" + strRemoteFileName.Substring(index) + ": " + strFolder + "\\" + strLocalFileName);
// _ftp.DisConnect();
// b = true;
// }
// catch (Exception ex)
// {
// tcount++;
// LogInfo.Instance.Log("第" + tcount + "次失败:" + ex.ToString());
// if (tcount < 4 && !b) //尝试继续连接下载文件
// //Get(strRemoteFileName, strFolder, strLocalFileName, filesize);
// goto GoBack;
// else //连续3次下载失败 抛出下载失败异常
// context.Post(TrigeEvent_Get, "0" + strRemoteFileName.Substring(index) + ": " + ex.Message);
// }
// });
// th.IsBackground = true;
// th.Start();
//}
///// <summary>
///// 下载进度
///// </summary>
///// <param name="name"></param>
///// <param name="percnet"></param>
//private void FtpPercentBack(string name, int percnet)
//{
// if (Event_FtpLoadPercent != null)
// Event_FtpLoadPercent(name, percnet);
//}
///// <summary>
///// 上传一个文件
///// </summary>
///// <param name="filename">本地文件完全路径(包括扩展名)</param>
///// <param name="ftppath">上传路径</param>
//public void Put(string filepath, string ftppath)
//{
// FtpOperatingFire _ftp = ConnectFTP();
// _ftp.Put(filepath, ftppath);
// _ftp.DisConnect();
//}
///// <summary>
///// 开始解析 并开始上传
///// </summary>
///// <param name="message">服务端返回的 上传文件列表</param>
//private void ParseFileAndUpLoad(string message) //服务端返回上传文件列表 不写入xml 直接解析上传
//{
// byte[] b = Encoding.UTF8.GetBytes(message.Trim());
// MemoryStream ms = new MemoryStream(b);
// XmlDocument doc = new XmlDocument();
// doc.Load(ms);
// List<UpLoadFileInfo> list = new List<UpLoadFileInfo>();
// List<UpLoadFileInfo> finish = new List<UpLoadFileInfo>();
// //FtpHostName = (doc.SelectSingleNode("UploadFileNames/FtpHostName") as XmlElement).GetAttribute("value");
// //FtpPort = (doc.SelectSingleNode("UploadFileNames/FtpPort") as XmlElement).GetAttribute("value");
// //FtpUserName = (doc.SelectSingleNode("UploadFileNames/FtpUserName") as XmlElement).GetAttribute("value");
// //FtpPassword = (doc.SelectSingleNode("UploadFileNames/FtpPassword") as XmlElement).GetAttribute("value");
// XmlNodeList nodelist = doc.SelectNodes("//Row");
// foreach (XmlNode node in nodelist)
// {
// string FileName = (node.SelectSingleNode("FileName") as XmlElement).GetAttribute("value");
// string FilePath = (node.SelectSingleNode("FilePath") as XmlElement).GetAttribute("value");
// string Md5 = (node.SelectSingleNode("Md5") as XmlElement).GetAttribute("value");
// UpLoadFileInfo info = new UpLoadFileInfo();
// info.FileName = FileName;
// info.FileFtpPath = FilePath;
// info.Md5 = Md5;
// foreach (KeyValuePair<string, string> kvp in BuildCommand.Instance.UpFileList)
// {
// if (Path.GetFileName(kvp.Key) == FileName)
// {
// info.FileClientPath = kvp.Key;
// break;
// }
// }
// list.Add(info);
// }
// int uploadcount = 0;
// for (int i = 0; i < list.Count; i++)
// {
// try
// {
// Thread.Sleep(100);
// LogInfo.Instance.Log("开始文件上传：" + (i + 1).ToString());
// LogInfo.Instance.Log("文件服务端路径: " + list[i].FileFtpPath + "/" + list[i].FileName);
// LogInfo.Instance.Log("文件客户端路径: " + list[i].FileClientPath);
// LogInfo.Instance.Log("文件MD5: " + list[i].Md5);
// Put(list[i].FileClientPath, list[i].FileFtpPath + "/" + list[i].FileName);
// LogInfo.Instance.Log("文件上传完毕：" + (i + 1).ToString());
// LogInfo.Instance.Log("文件服务端路径: " + list[i].FileFtpPath + "/" + list[i].FileName);
// LogInfo.Instance.Log("文件客户端路径: " + list[i].FileClientPath);
// LogInfo.Instance.Log("文件MD5: " + list[i].Md5);
// uploadcount++;
// finish.Add(list[i]);
// }
// catch (Exception ex)
// {
// LogInfo.Instance.Log("文件上传失败：" + (i + 1).ToString());
// LogInfo.Instance.Log(ex.Message);
// if (Event_FtpUpLoadFile != null)
// Event_FtpUpLoadFile(false, Path.GetFileName(list[i].FileClientPath) + "上传失败:" + ex.Message);
// continue;
// }
// }
// if (uploadcount > 0 && finish.Count > 0)
// {
// BuildCommand.Instance.FileinfoList = finish;
// if (SendCommandTo(SendCommandType.UploadFileFinish, null))
// {
// LogInfo.Instance.Log("文件上传完毕！通知服务器接受数据文件个数： " + finish.Count);
// if (Event_FtpUpLoadFile != null)
// Event_FtpUpLoadFile(true, "上传完毕");
// }
// else
// {
// LogInfo.Instance.Log("文件上传完毕！通知服务器接受文件信息 发送失败!");
// }
// //StopLoadFile();
// }
//}
#endregion
#region 连接、断开、检测、重新连接 网络连接 public
/// <summary>
/// 使用ping 检测网络连接
/// </summary>
/// <param name="IP"></param>
/// <returns></returns>
public bool PingIP(string IP)
{
return BaseNetWork.PingIP(IP);
}
/// <summary>
/// 检测远程服务是否可连接
/// </summary>
/// <param name="IP">ip地址</param>
/// <param name="Port">端口号</param>
/// <returns>true|false</returns>
public static bool TestNetwork(string IP, string Port)
{
return BaseNetWork.TestNetwork(IP, Port);
}
/// <summary>
/// 是否是连接状态
/// </summary>
/// <returns></returns>
public bool IsConnection()
{
if (mythread == null)
return false;
return mythread.IsAlive;
}
/// <summary>
/// 连接到服务器
/// </summary>
public void BeginListen()
{
mythread = null;
mythread = new Thread(new ThreadStart(BaseNetWork.GetNetWork().BeginListen));
mythread.Name = "网络连接线程-" + DateTime.Now.ToString("HH:ss:mm");
mythread.Start();
}
/// <summary>
/// 连接到服务器
/// </summary>
public void BeginListen(string ip, int point)
{
mythread = null;
mythread = new Thread(delegate() { BaseNetWork.GetNetWork().BeginListen(ip, point); });
mythread.Name = "网络连接线程-" + DateTime.Now.ToString("HH:ss:mm");
mythread.Start();
}
void NewNetWork_ReceiveFailEvent()
{
if (this.ReceiveFailEvent != null)
this.ReceiveFailEvent();
}
/// <summary>
/// 停止网络连接
/// </summary>
public void StopLoadFile()
{
LoginInfo.SecretKey = string.Empty;
t.Enabled = false;
if (mythread != null && mythread.IsAlive)
{
try
{
BaseNetWork.GetNetWork().StopLoadFile();
System.Diagnostics.Trace.WriteLine("NewNetWork:StopLoadFile() ThreadName--->:" + Thread.CurrentThread.Name);
mythread = null;
}
catch (Exception ex)
{
LogInfo.Instance.Log("停止网络连接异常: " + ex.ToString());
System.Diagnostics.Trace.WriteLine("NewNetWork:StopLoadFile() Exception--->:" + ex.ToString());
}
}
}
public void StopLoad(object source, System.Timers.ElapsedEventArgs e)
{
LoginInfo.SecretKey = string.Empty;
t.Enabled = false;
if (mythread != null && mythread.IsAlive)
{
try
{
BaseNetWork.GetNetWork().StopLoadFile();
System.Diagnostics.Trace.WriteLine("NewNetWork:StopLoadFile() ThreadName--->:" + Thread.CurrentThread.Name);
mythread = null;
}
catch (Exception ex)
{
LogInfo.Instance.Log("停止网络连接异常: " + ex.ToString());
System.Diagnostics.Trace.WriteLine("NewNetWork:StopLoadFile() Exception--->:" + ex.ToString());
}
}
}
/// <summary>
/// 断开连接状态 并创建一个新的连接
/// </summary>
public void CreateNewConnect()
{
StopLoadFile();
BeginListen();
}
#endregion
#region 接收信息、解压并写入文档 private
/// <summary>
/// 根据枚举类型 提取参数msg中对应枚举中的 字段
/// </summary>
/// <param name="msg">要判断的字符串</param>
/// <param name="type">要判断的枚举类型</param>
private void GetParamet(string msg, SendCommandType type)
{
switch (type)
{
case SendCommandType.ParametView:
_listparamet = new List<RePortParamet>();
foreach (RePortParamet num in Enum.GetValues(typeof(RePortParamet)))
{
string s = "<" + num.ToString() + ">";
if (num.ToString() == "C/R")
{
s = "<CIR>";
}
if (msg.Contains(s))
{
_listparamet.Add((num));
}
}
break;
case SendCommandType.ExceptionEventView:
_listexception = new List<ReportException>();
foreach (ReportException num in Enum.GetValues(typeof(ReportException)))
{
if (msg.Contains("<" + num.ToString() + ">"))
{
_listexception.Add((num));
}
}
break;
}
}
/// <summary>
/// 处理信息并写入相应xml文档
/// </summary>
/// <param name="message">接收的信息</param>
/// <param name="command">执行的命令</param>
private void WriteXmlByCommand(string message, SendCommandType command)
{
string xml = message.Replace("&", "+").Trim();
if (command == SendCommandType.SearchFile)
{
xml = xml.Replace("[GetLogFile]", "").Trim();
}
else
{
xml = xml.Replace("[" + command.ToString() + "]", "").Trim();
}
FileWork.Instance.WriteXml(xml, command.ToString());
}
/// <summary>
/// 接收服务端传来的信息 以注册BaseNetWork的 EventMessage事件
/// </summary>
/// <param name="loginmessage">服务端返回的信息</param>
private void ReceiveMessage(byte[] loginmessage)
{
//解压
string message = "";
try
{
byte[] msbt = lbd.Decode(loginmessage);
message = Encoding.UTF8.GetString(msbt).Trim();
message = message.Replace("UTF-8", "gb2312");
}
catch (Exception ex)
{
t.Enabled = false;
LogInfo.Instance.Log(ex.ToString());
if (Event_ConnetionState != null)
{
Event_ConnetionState(false, "文件解压失败!请重新发送!");
}
// StopLoadFile();
return;
}
if (message.Trim() == "NoData")
{
t.Enabled = false;
if (Event_ConnetionState != null)
{
Event_ConnetionState(true, "未查询到所需的数据!");
}
//StopLoadFile();
return;
}
if (message.Trim() == "NoUser")
{
t.Enabled = false;
if (Event_ConnetionState != null)
{
Event_ConnetionState(false, "用户不合法! ");
}
//StopLoadFile();
return;
}
if (message.Trim() == "RequestError")
{
t.Enabled = false;
if (Event_ConnetionState != null)
{
Event_ConnetionState(false, "RequestError!");
}
//StopLoadFile();
return;
}
if (message.Trim() == "NoDatas")
{
t.Enabled = false;
if (Event_ConnetionState != null)
{
Event_ConnetionState(false, "未查询到所需的数据!");
}
//StopLoadFile();
return;
}
if (message.Trim() == "NoFileCanUpload")
{
//没有文件可上传
t.Enabled = false;
LogInfo.Instance.Log("服务端返回没有文件可上传：NoFileCanUpload");
//StopLoadFile();
return;
}
SendCommandType type;
if (message.Contains("[Login]"))
{
type = SendCommandType.Login;
WriteXmlByCommand(message, SendCommandType.Login);
}
else if (message.Contains("[GetGroup]")) //获得一级域
{
type = SendCommandType.GetGroup;
WriteXmlByCommand(message, SendCommandType.GetGroup);
}
else if (message.Contains("[GetSecondGroup]")) // 获得二级域
{
type = SendCommandType.GetSecondGroup;
WriteXmlByCommand(message, SendCommandType.GetSecondGroup);
}
else if (message.Contains("[GetATUIDList]"))
{
type = SendCommandType.GetATUIDList;
WriteXmlByCommand(message, SendCommandType.GetATUIDList);
}
else if (message.Contains("[GetGrid]"))
{
type = SendCommandType.GetGrid;
WriteXmlByCommand(message, SendCommandType.GetGrid);
}
else if (message.Contains("[GetLogFile]")) //查找文件 时间点和时间区间
{
type = SendCommandType.SearchFile;
WriteXmlByCommand(message, SendCommandType.SearchFile);
}
else if (message.Contains("[Dtconfig]")) //获取实时回放配置文件
{
type = SendCommandType.DtConfig;
message = message.Replace("[Dtconfig]", "");
WriteXmlByCommand(message, SendCommandType.DtConfig);
}
else if (message.Contains("[QueryLogKey]"))
{
type = SendCommandType.QueryLogKey;
message = message.Replace("[QueryLogKey]", "");
WriteXmlByCommand(message, SendCommandType.QueryLogKey);
}
else if (message.Contains("[GroupAssessmentView]")) //集团统计报表
{
type = SendCommandType.GroupAssessmentView;
WriteXmlByCommand(message, SendCommandType.GroupAssessmentView);
}
else if (message.Contains("[ParametView]")) //参数报表 ------多参数
{
GetParamet(message, SendCommandType.ParametView);
type = SendCommandType.ParametView;
WriteXmlByCommand(message, SendCommandType.ParametView);
}
else if (message.Contains("[NetGridView]")) //网格统计报表
{
type = SendCommandType.NetGridView;
WriteXmlByCommand(message, SendCommandType.NetGridView);
}
else if (message.Contains("[CellInfiltrationView]")) //小区渗透报表
{
type = SendCommandType.CellInfiltrationView;
WriteXmlByCommand(message, SendCommandType.CellInfiltrationView);
}
else if (message.Contains("[ExceptionEventView]")) //事件报表 --------------多参数 和 事件/
{
GetParamet(message, SendCommandType.ExceptionEventView);
type = SendCommandType.ExceptionEventView;
WriteXmlByCommand(message, SendCommandType.ExceptionEventView);
}
else if (message.Contains("[AccessDelayView]")) //接入时延报表
{
type = SendCommandType.AccessDelayView;
WriteXmlByCommand(message, SendCommandType.AccessDelayView);
}
else if (message.Contains("[AccessReasonsView]")) //接入原因报表)
{
type = SendCommandType.AccessReasonsView;
WriteXmlByCommand(message, SendCommandType.AccessReasonsView);
}
else if (message.Contains("[DataBusinessView]")) //数据业务报表
{
type = SendCommandType.DataBusinessView;
WriteXmlByCommand(message, SendCommandType.DataBusinessView);
}
//-----------------------------------------------------------
else if (message.Contains("[RoadBlackPoint]")) //道路黑点
{
type = SendCommandType.RoadBlackPoint;
WriteXmlByCommand(message, SendCommandType.RoadBlackPoint);
}
else if (message.Contains("[NetGridDataFind]")) //网格查询
{
type = SendCommandType.NetGridDataFind;
WriteXmlByCommand(message, SendCommandType.NetGridDataFind);
}
else if (message.Contains("[NetGridData]")) //网格渲染
{
type = SendCommandType.NetGridData;
WriteXmlByCommand(message, SendCommandType.NetGridData);
}
else if (message.Contains("[SquaresGridData]")) //栅格
{
type = SendCommandType.SquaresGridData;
WriteXmlByCommand(message, SendCommandType.SquaresGridData);
}
else if (message.Contains("[ExceptionEvent]"))//异常事件查询
{
type = SendCommandType.ExceptionEvent;
WriteXmlByCommand(message, SendCommandType.ExceptionEvent);
}
//------------------------------------------------------------
else if (message.Contains("[UName]")) //上传前 获取服务U设备
{
type = SendCommandType.UName;
WriteXmlByCommand(message, SendCommandType.UName);
}
else if (message.Contains("[UploadFileNames]")) //上传服务端验证 返回上传文件列表
{
WriteXmlByCommand(message, SendCommandType.UploadFileNames); //可无 ---测试
type = SendCommandType.UploadFileNames;
Thread th = new Thread(delegate()
{
ParseFileAndUpLoad(message.Replace("[UploadFileNames]", ""));//解析上传文件列表 bin 开始上传
});
th.IsBackground = true;
th.Start();
}
else if (message.Contains("[TestPlan]"))
{
type = SendCommandType.TestPlan;
WriteXmlByCommand(message, SendCommandType.TestPlan);
}
else if (message.Contains("[Device]"))
{
type = SendCommandType.Device;
WriteXmlByCommand(message, SendCommandType.Device);
}
else if (message.Contains("[LogFileTestPlan]"))
{
type = SendCommandType.LogFileTestPlan;
WriteXmlByCommand(message, SendCommandType.LogFileTestPlan);
}
else if (message.Contains("[LogFileDevice]"))
{
type = SendCommandType.LogFileDevice;
WriteXmlByCommand(message, SendCommandType.LogFileDevice);
}
else if (message.Contains("[RoadInfiltration]"))
{
type = SendCommandType.RoadInfiltration;
WriteXmlByCommand(message, SendCommandType.RoadInfiltration);
}
else if (message.Contains("[AreaGroupAssessmentView]")) //区域统计-集团报表
{
type = SendCommandType.AreaGroupAssessmentView;
WriteXmlByCommand(message, SendCommandType.AreaGroupAssessmentView);
}
else if (message.Contains("[RoadFrequency]")) //道路渗透频度
{
type = SendCommandType.RoadFrequency;
WriteXmlByCommand(message, SendCommandType.RoadFrequency);
}
else if (message.Contains("[GetFtpInformation]"))//获取FTP地址信息
{
type = SendCommandType.GetFtpInformation;
WriteXmlByCommand(message, SendCommandType.GetFtpInformation);
}
else if (message.Contains("[ManualTestQuery]"))//ftp上传文件报表
{
type = SendCommandType.ManualTestQuery;
WriteXmlByCommand(message, SendCommandType.ManualTestQuery);
}
else
{
t.Enabled = false;
if (Event_ConnetionState != null)
Event_ConnetionState(false, "接收文件错误-头文件不存在！");
return;
}
//没有超时 停止计时器
t.Enabled = false;
Thread.Sleep(20);
if (event_load != null)//回发消息
{
DataSet ds = new DataSet();
//if (type != SendCommandType.NetGridData && type != SendCommandType.SquaresGridData && type != SendCommandType.ExceptionEvent)
//{
if (!_PostList.Exists(new Predicate<SendCommandType>(delegate(SendCommandType tp) { return tp == type; })))
{
ds = GetIoFineshTable(type);
if (ds != null)
{
//List<object> list = new List<object>();
//list.Add(ds);
//list.Add(type.ToString());
//context.Post(Complete_Thread, list);
SendCommandType cmdtype = EnumsUtil.StringToEnum<SendCommandType>(type.ToString());
event_load(ds, cmdtype);
}
}
else
{
ds = GetIoFineshTable(type);
event_load(ds, type);
}
}
//StopLoadFile();
}
/// <summary>
/// 调度到主线程
/// </summary>
/// <param name="obj"></param>
public void Complete_Thread(object obj)
{
if (obj != null)
{
DataSet ds = new DataSet();
ds = (obj as List<object>)[0] as DataSet;
SendCommandType type = EnumsUtil.StringToEnum<SendCommandType>((obj as List<object>)[1].ToString());
event_load(ds, type);
}
}
#endregion
#region 解析xml文件 private
/// <summary>
/// 完成数据传递和IO操作后返回 查找文件、登录、统计报表 、所需的dataset对象
/// </summary>
/// <param name="type">操作的枚举类型</param>
/// <returns>所需数据的dataset</returns>
private DataSet GetIoFineshTable(SendCommandType type)
{
DataSet ds = new DataSet();
XmlDocument doc = new XmlDocument();
try
{
doc.Load(Application.StartupPath + "/" + type.ToString() + ".xml");
}
catch (Exception ex)
{
LogInfo.Instance.Log(ex.ToString());
if (Event_ConnetionState != null)
{
Event_ConnetionState(false, "xml格式异常~ 请尝试重新发送");
}
return null;
}
switch (type)
{
#region 梁如超添加-增加login部分 2010-9-10
#region Login
case SendCommandType.Login:
{
DataTable loginData = new DataTable(SendCommandType.Login.ToString());
loginData.Columns.Add("EncryptionString");
loginData.Columns["EncryptionString"].Caption = "加密字符串";
DataRow row = loginData.NewRow();
row[0] = doc.SelectSingleNode("//Result").Attributes["value"].Value;
loginData.Rows.Add(row[0]);
ds.Tables.Add(loginData);
break;
}
#endregion
#region GetGroup
case SendCommandType.GetGroup:
{
DataTable getGroupData = new DataTable(SendCommandType.GetGroup.ToString());
getGroupData.Columns.Add("GroupID", typeof(string));
getGroupData.Columns.Add("GroupName", typeof(string));
XmlNodeList list = doc.SelectNodes("//Group");
DataRow row = null;
foreach (XmlNode node in list)
{
row = getGroupData.NewRow();
row[0] = node.SelectSingleNode("GroupID").Attributes["value"].Value;
row[1] = node.SelectSingleNode("GroupName").Attributes["value"].Value;
getGroupData.Rows.Add(row);
}
ds.Tables.Add(getGroupData);
break;
}
#endregion
#region GetSecondGroup
case SendCommandType.GetSecondGroup:
{
DataTable getSecondGroupData = new DataTable(SendCommandType.GetSecondGroup.ToString());
getSecondGroupData.Columns.Add("GroupID", typeof(string));
getSecondGroupData.Columns.Add("GroupName", typeof(string));
XmlNodeList list = doc.SelectNodes("//Group");
DataRow row = null;
foreach (XmlNode node in list)
{
row = getSecondGroupData.NewRow();
row[0] = node.SelectSingleNode("GroupID").Attributes["value"].Value;
row[1] = node.SelectSingleNode("GroupName").Attributes["value"].Value;
getSecondGroupData.Rows.Add(row);
}
ds.Tables.Add(getSecondGroupData);
break;
}
#endregion
case SendCommandType.GetATUIDList:
{
DataTable GetATUIDList = new DataTable(SendCommandType.GetATUIDList.ToString());
GetATUIDList.Columns.Add("GroupName", typeof(string));
GetATUIDList.Columns.Add("ATUID", typeof(string));
XmlNode root = doc.SelectSingleNode("GetATUIDList");
DataRow row = null;
foreach (XmlNode node in root.ChildNodes)
{
foreach (XmlNode sonNode in node.ChildNodes)
{
row = GetATUIDList.NewRow();
row[0] = node.Attributes[0].Value;
row[1] = sonNode.Attributes[0].Value;
GetATUIDList.Rows.Add(row);
}
}
ds.Tables.Add(GetATUIDList);
break;
}
case SendCommandType.GetGrid:
{
DataTable GetGRIDList = new DataTable(SendCommandType.GetGrid.ToString());
GetGRIDList.Columns.Add("GroupName", typeof(string));
GetGRIDList.Columns.Add("GRIDID", typeof(string));
XmlNode root = doc.SelectSingleNode("GetGrid");
DataRow row = null;
foreach (XmlNode node in root.ChildNodes)
{
row = GetGRIDList.NewRow();
XmlNode groupNode = node.SelectSingleNode("GroupName");
row[0] = groupNode.Attributes[0].Value;
XmlNode gridNode = node.SelectSingleNode("GridId");
row[1] = gridNode.Attributes[0].Value;
GetGRIDList.Rows.Add(row);
}
ds.Tables.Add(GetGRIDList);
break;
}
case SendCommandType.QueryLogKey:
{
DataTable fileMD5 = new DataTable(SendCommandType.QueryLogKey.ToString());
fileMD5.Columns.Add("FileName", typeof(string));
fileMD5.Columns.Add("Key", typeof(string));
XmlNode root = doc.SelectSingleNode("QueryLogKey");
DataRow row = null;
foreach (XmlNode node in root.ChildNodes)
{
row = fileMD5.NewRow();
for (int i = 0; i < node.ChildNodes.Count; i++)
{
row[i] = node.ChildNodes[i].Attributes[0].Value;
}
fileMD5.Rows.Add(row);
}
ds.Tables.Add(fileMD5);
break;
}
#endregion
#region log上传FTP模块
case SendCommandType.GetFtpInformation:
{
DataTable getFtpData = new DataTable(SendCommandType.GetFtpInformation.ToString());
getFtpData.Columns.Add("FtpIP", typeof(string));
getFtpData.Columns.Add("FtpUserName", typeof(string));
getFtpData.Columns.Add("FtpPassword", typeof(string));
XmlNodeList list = doc.SelectNodes("//FtpInformation");
DataRow dr = null;
foreach (XmlNode nd in list)
{
dr = getFtpData.NewRow();
dr[0] = nd.SelectSingleNode("FtpIP").Attributes["value"].Value;
dr[1] = nd.SelectSingleNode("FtpUserName").Attributes["value"].Value;
dr[2] = nd.SelectSingleNode("FtpPassword").Attributes["value"].Value;
getFtpData.Rows.Add(dr);
}
ds.Tables.Add(getFtpData);
break;
}
case SendCommandType.ManualTestQuery:
{
XmlNode xn = null;
DataTable DtRawDataList = new DataTable("DtRawDataList");
DataTable DtExceptionEventList = new DataTable("ExceptionEventList");
#region 创建原始数据列表列
DtRawDataList.Columns.Add("City", typeof(string));
DtRawDataList.Columns.Add("FileName", typeof(string));
DtRawDataList.Columns.Add("StatsState", typeof(string));
DtRawDataList.Columns.Add("FileStartDate", typeof(string));
DtRawDataList.Columns.Add("FileEndDate", typeof(string));
DtRawDataList.Columns.Add("OutGoingTestLength", typeof(double));
DtRawDataList.Columns.Add("InComingTestLength", typeof(double));
DtRawDataList.Columns.Add("CoverMileage", typeof(double));
DtRawDataList.Columns.Add("TestCallNum", typeof(int));
DtRawDataList.Columns.Add("OutGoingConnectNum", typeof(int));
DtRawDataList.Columns.Add("InComingConnectNum", typeof(int));
DtRawDataList.Columns.Add("OutGoingDropCallNum", typeof(int));
DtRawDataList.Columns.Add("InComingDropCallNum", typeof(int));
DtRawDataList.Columns.Add("OutGoingRxlevCount", typeof(int));
DtRawDataList.Columns.Add("InComingRxlevCount", typeof(int));
DtRawDataList.Columns.Add("OutGoingRxlevThanCount", typeof(int));
DtRawDataList.Columns.Add("InComingRxlevLessThanCount", typeof(int));
DtRawDataList.Columns.Add("OutGoingRxQualCount", typeof(int));
DtRawDataList.Columns.Add("InComingRxQualCount", typeof(int));
DtRawDataList.Columns.Add("OutZeroLevelCount", typeof(int));
DtRawDataList.Columns.Add("InZeroLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutOneLevelCount", typeof(int));
DtRawDataList.Columns.Add("InOneLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutTwoLevelCount", typeof(int));
DtRawDataList.Columns.Add("InTwoLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutThreeLevelCount", typeof(int));
DtRawDataList.Columns.Add("InThreeLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutFourLevelCount", typeof(int));
DtRawDataList.Columns.Add("InFourLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutFiveLevelCount", typeof(int));
DtRawDataList.Columns.Add("InFiveLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutSixLevelCount", typeof(int));
DtRawDataList.Columns.Add("InSixLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutSevenLevelCount", typeof(int));
DtRawDataList.Columns.Add("InSevenLevelCount", typeof(int));
DtRawDataList.Columns.Add("OutGoingMosAvg", typeof(double));
DtRawDataList.Columns.Add("CallSetupAverageDelay", typeof(double));
DtRawDataList.Columns.Add("OutGoingEFR", typeof(string));
DtRawDataList.Columns.Add("OutGoingFR", typeof(string));
DtRawDataList.Columns.Add("OutGoingHR", typeof(string));
DtRawDataList.Columns.Add("OutGoingAMRFR", typeof(string));
DtRawDataList.Columns.Add("OutGoingAMRHR", typeof(string));
DtRawDataList.Columns.Add("InComingEFR", typeof(string));
DtRawDataList.Columns.Add("InComingFR", typeof(string));
DtRawDataList.Columns.Add("InComingHR", typeof(string));
DtRawDataList.Columns.Add("InComingAMRFR", typeof(string));
DtRawDataList.Columns.Add("InComingAMRHR", typeof(string));
XmlNodeList list = doc.SelectNodes("//config//DtRawDataList//RawData");
DataRow dr = null;
foreach (XmlNode xNode in list)
{
dr = DtRawDataList.NewRow();
foreach (DataColumn dc in DtRawDataList.Columns)
{
if (dc.DataType.Equals(typeof(double)))
{
double dtemp = -1;
if (double.TryParse(xNode.SelectSingleNode(dc.ColumnName).Attributes["value"].Value, out dtemp))
dr[dc.ColumnName] = dtemp;
}
else if (dc.DataType.Equals(typeof(int)))
{
int itemp = -1;
if (int.TryParse(xNode.SelectSingleNode(dc.ColumnName).Attributes["value"].Value, out itemp))
dr[dc.ColumnName] = itemp;
}
else
dr[dc.ColumnName] = xNode.SelectSingleNode(dc.ColumnName).Attributes["value"].Value;
}
DtRawDataList.Rows.Add(dr);
}
ds.Tables.Add(DtRawDataList);
list = null;
dr = null;
#endregion
#region 异常事件列表
DtExceptionEventList.Columns.Add("Num", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingFileName", typeof(string));
DtExceptionEventList.Columns.Add("InComingFileName", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingCallingTime", typeof(string));
DtExceptionEventList.Columns.Add("InComingCallingTime", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingAlertingTime", typeof(string));
DtExceptionEventList.Columns.Add("InComingAlertingTime", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingConnectedTime", typeof(string));
DtExceptionEventList.Columns.Add("InComingConnectedTime", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingCallEndTime", typeof(string));
DtExceptionEventList.Columns.Add("InComingCallEndTime", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingCallType", typeof(string));
DtExceptionEventList.Columns.Add("InComingCallType", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingCallTimeLength", typeof(string));
DtExceptionEventList.Columns.Add("InComingCallTimeLength", typeof(string));
DtExceptionEventList.Columns.Add("OutGoingCallingDuration", typeof(string));
DtExceptionEventList.Columns.Add("InComingCallingDuration", typeof(string));
DtExceptionEventList.Columns.Add("CallInterval", typeof(string));
DtExceptionEventList.Columns.Add("EventReason", typeof(string));
list = doc.SelectNodes("//config//ExceptionEventList//ExceptionEvent");
foreach (XmlNode xNode in list)
{
dr = DtExceptionEventList.NewRow();
foreach (DataColumn dc in DtExceptionEventList.Columns)
{
dr[dc.ColumnName] = xNode.SelectSingleNode(dc.ColumnName).Attributes["value"].Value;
}
DtExceptionEventList.Rows.Add(dr);
}
ds.Tables.Add(DtExceptionEventList);
list = null;
dr = null;
#endregion
//}
break;
}
#endregion
#region SearchFile
case SendCommandType.SearchFile: //******************************************************查找文件 时间点 时间范围
DataTable dt_SearchFile = new DataTable(SendCommandType.SearchFile.ToString());
dt_SearchFile.Columns.Add("Col_Check", typeof(bool)); //0
dt_SearchFile.Columns.Add("Col_FileName"); //1
dt_SearchFile.Columns.Add("Col_BoxID"); //2
dt_SearchFile.Columns.Add("Cold_ModelNumber"); //3
dt_SearchFile.Columns.Add("Col_Area"); //4
dt_SearchFile.Columns.Add("Col_TelecomOperators"); //5
dt_SearchFile.Columns.Add("Col_BeginTime");//6
dt_SearchFile.Columns.Add("Col_EndTime");//7
dt_SearchFile.Columns.Add("Col_TestDuration");//8
dt_SearchFile.Columns.Add("Col_NetType");//9
dt_SearchFile.Columns.Add("Col_Size", typeof(int));//10
dt_SearchFile.Columns.Add("Col_State");//11
dt_SearchFile.Columns.Add("Col_LogType");//12
dt_SearchFile.Columns.Add("FilePath"); //13
dt_SearchFile.Columns.Add("FtpServerIp"); //14
dt_SearchFile.Columns.Add("FtpServerPort"); //15
dt_SearchFile.Columns.Add("FtpUser"); //16
dt_SearchFile.Columns.Add("FtpPwd"); //17
dt_SearchFile.Columns.Add("SecretKey");
dt_SearchFile.Columns.Add("TestType");
dt_SearchFile.Columns.Add("MasterGridID");
//内容节点集合
XmlNodeList nodeList = doc.SelectNodes("//LogFile");
foreach (XmlNode node in nodeList)
{
DataRow row = dt_SearchFile.NewRow();
row[0] = false;
row[1] = node.SelectSingleNode("FileName").Attributes["value"].Value; //文件名
if (row[1].ToString() == "null")
{
continue;
}
row[2] = node.SelectSingleNode("BoxID").Attributes["value"].Value;//盒子ID
row[3] = node.SelectSingleNode("ModuleID").Attributes["value"].Value;//模块号ID
row[4] = node.SelectSingleNode("GroupName").Attributes["value"].Value;//所属域ID
string mnValue = node.SelectSingleNode("Mnc").Attributes["value"].Value;
if (mnValue == "0")
{
row[5] = "中国移动";
}
else if (mnValue == "1")
{
row[5] = "中国联通";
}
else if (mnValue == "3")
{
row[5] = "中国电信";
}
else
{
row[5] = string.Empty;
}
row[6] = node.SelectSingleNode("BeginTime").Attributes["value"].Value;
row[7] = node.SelectSingleNode("EndTime").Attributes["value"].Value;
row[8] = node.SelectSingleNode("Time").Attributes["value"].Value;
row[9] = node.SelectSingleNode("NetType").Attributes["value"].Value;
int size = 0;
if (node.SelectSingleNode("FileSize").Attributes["value"].Value != string.Empty)
{
size = Convert.ToInt32(node.SelectSingleNode("FileSize").Attributes["value"].Value);
size = size / 1024;
}
row[10] = size.ToString();
string state = node.SelectSingleNode("State").Attributes["value"].Value;
if (state == "0")
{
row[11] = "统计中";
}
else if (state == "1")
{
row[11] = "统计完成";
}
else if (state == "9")
{
row[11] = "统计异常";
}
else
{
row[11] = string.Empty;
}
string logType = node.SelectSingleNode("LogType").Attributes["value"].Value;
if (logType == "1")
{
row[12] = "已完成LOG";
}
else if (logType == "0")
{
row[12] = "未完成LOG";
}
else
{
row[12] = string.Empty;
}
string path = node.SelectSingleNode("FilePath").Attributes["value"].Value + "/";
if (row[9].ToString() == "TD")
{
row[13] = path + row[1].ToString() + ".lot";
}
else if (row[9].ToString() == "CDMA")
{
row[13] = path + row[1].ToString() + ".loc";
}
else if (row[9].ToString() == "WCDMA")
{
row[13] = path + row[1].ToString() + ".low";
}
else if (row[9].ToString() == "EVDO")
{
row[13] = path + row[1].ToString() + ".loe";
}
else if (row[9].ToString() == "GSM")
{
row[13] = path + row[1].ToString() + ".log";
}
else if (row[9].ToString() == "LTE")
{
row[13] = path + row[1].ToString() + ".lte";
}
else
{
row[13] = "";
}
row[14] = node.SelectSingleNode("FtpServerIp").Attributes["value"].Value;
row[15] = node.SelectSingleNode("FtpServerPort").Attributes["value"].Value;
row[16] = node.SelectSingleNode("FtpUser").Attributes["value"].Value;
row[17] = node.SelectSingleNode("FtpPwd").Attributes["value"].Value;
if (node.SelectSingleNode("SecretKey") != null)
row[18] = node.SelectSingleNode("SecretKey").Attributes["value"].Value;
row[19] = node.SelectSingleNode("TestType").Attributes["value"].Value;
if (node.SelectSingleNode("MasterGridId") != null)
row[20] = node.SelectSingleNode("MasterGridId").Attributes["value"].Value;
dt_SearchFile.Rows.Add(row);
}
ds.Tables.Add(dt_SearchFile);
DataTable dt_FlieCount = new DataTable("FileCount");
dt_FlieCount.Columns.Add("FileCount", typeof(string));
DataRow FlieCountRow = dt_FlieCount.NewRow();
FlieCountRow[0] = doc.SelectSingleNode("//FileCount").Attributes["value"].Value;
dt_FlieCount.Rows.Add(FlieCountRow);
ds.Tables.Add(dt_FlieCount);
break;
#endregion
#region 集团报表==和==区域统计-集团报表
case SendCommandType.AreaGroupAssessmentView: //区域统计---------------集团统计报表
goto case SendCommandType.GroupAssessmentView;
case SendCommandType.GroupAssessmentView: //******************************************************集团统计报表
DataTable dt_GroupAssessmentResult = new DataTable(SendCommandType.GroupAssessmentView.ToString()); //结果数据
dt_GroupAssessmentResult.Columns.Add("Index1");
dt_GroupAssessmentResult.Columns.Add("Connect");//接通率
dt_GroupAssessmentResult.Columns.Add("Failure");//掉话率
dt_GroupAssessmentResult.Columns.Add("Rxlev");//覆盖率>90
dt_GroupAssessmentResult.Columns.Add("Rxlev2");//覆盖率>94
dt_GroupAssessmentResult.Columns.Add("Rxqual");//语音质量
dt_GroupAssessmentResult.Columns.Add("MosAvg");//MOS均值
dt_GroupAssessmentResult.Columns.Add("ConvertDrop");//掉话里程对比
dt_GroupAssessmentResult.Columns.Add("Duration");//呼叫建立平均延时
dt_GroupAssessmentResult.Columns["Index1"].Caption = "索引";
dt_GroupAssessmentResult.Columns["Connect"].Caption = "接通率";
dt_GroupAssessmentResult.Columns["Failure"].Caption = "掉话率";
dt_GroupAssessmentResult.Columns["Rxlev"].Caption = "覆盖率(>=-90dBm)";
dt_GroupAssessmentResult.Columns["Rxlev2"].Caption = "覆盖率(>=-94dBm)";
dt_GroupAssessmentResult.Columns["Rxqual"].Caption = "语音质量";
dt_GroupAssessmentResult.Columns["MosAvg"].Caption = "MOS均值";
dt_GroupAssessmentResult.Columns["ConvertDrop"].Caption = "掉话里程对比";
dt_GroupAssessmentResult.Columns["Duration"].Caption = "呼叫建立平均时延(秒)";
string MosAverage = "";
//内容节点集合
XmlNodeList node_GroupAssessmentViewList = doc.SelectNodes("//GsmStatus");
foreach (XmlNode node in node_GroupAssessmentViewList)
{
DataRow row = dt_GroupAssessmentResult.NewRow();
row[0] = (node.SelectSingleNode("Index ") as XmlElement).GetAttribute("value"); //索引
row[1] = (node.SelectSingleNode("Connect ") as XmlElement).GetAttribute("value");
row[2] = (node.SelectSingleNode("Failure") as XmlElement).GetAttribute("value");
row[3] = (node.SelectSingleNode("Rxlev") as XmlElement).GetAttribute("value");
row[4] = (node.SelectSingleNode("Rxlev2") as XmlElement).GetAttribute("value");
row[5] = (node.SelectSingleNode("Rxqual") as XmlElement).GetAttribute("value");
MosAverage = (node.SelectSingleNode("MosAvg") as XmlElement).GetAttribute("value");
row[6] = MosAverage;
row[7] = (node.SelectSingleNode("ConvertDrop") as XmlElement).GetAttribute("value");
row[8] = (node.SelectSingleNode("Duration") as XmlElement).GetAttribute("value");
dt_GroupAssessmentResult.Rows.Add(row);
}
ds.Tables.Add(dt_GroupAssessmentResult);
DataTable GroupAssessmentOld = new DataTable(SendCommandType.GroupAssessmentView.ToString() + "1"); //原始数据
GroupAssessmentOld.Columns.Add("Index");
GroupAssessmentOld.Columns.Add("FileName");//文件名
GroupAssessmentOld.Columns.Add("BeginTime");//文件开始时间
GroupAssessmentOld.Columns.Add("EndTime");//文件结束时间
GroupAssessmentOld.Columns.Add("Times");//测试时常
GroupAssessmentOld.Columns.Add("DistanceSum"); //测试总里程
GroupAssessmentOld.Columns.Add("ConvertLength");//覆盖里程
GroupAssessmentOld.Columns.Add("MoCallTimes");//呼叫次数
GroupAssessmentOld.Columns.Add("MoConnectTimes");//主叫
GroupAssessmentOld.Columns.Add("MtConnectTimes");//被叫
GroupAssessmentOld.Columns.Add("MoFailureTimes");//主叫
GroupAssessmentOld.Columns.Add("MtFailureTimes");//被叫
GroupAssessmentOld.Columns.Add("RlevCount");//rxlev 总采样点
GroupAssessmentOld.Columns.Add("RlevCount2");//rxlev>=90 采样点
GroupAssessmentOld.Columns.Add("RxqualCount");// 总采样点
GroupAssessmentOld.Columns.Add("MosAverage");//Mos均值
GroupAssessmentOld.Columns["Index"].Caption = "索引";
GroupAssessmentOld.Columns["FileName"].Caption = "文件名";
GroupAssessmentOld.Columns["BeginTime"].Caption = "文件开始时间";//--------
GroupAssessmentOld.Columns["EndTime"].Caption = "文件结束时间";
GroupAssessmentOld.Columns["Times"].Caption = "测试时长";
GroupAssessmentOld.Columns["DistanceSum"].Caption = "测试总里程";
GroupAssessmentOld.Columns["ConvertLength"].Caption = "覆盖里程";//--------------
GroupAssessmentOld.Columns["MoCallTimes"].Caption = "呼叫次数";
GroupAssessmentOld.Columns["MoConnectTimes"].Caption = "接通主叫";
GroupAssessmentOld.Columns["MtConnectTimes"].Caption = "接通被叫";
GroupAssessmentOld.Columns["MoFailureTimes"].Caption = "掉话主叫";
GroupAssessmentOld.Columns["MtFailureTimes"].Caption = "掉话被叫";
GroupAssessmentOld.Columns["RlevCount"].Caption = "RxLev总采样点";
GroupAssessmentOld.Columns["RlevCount2"].Caption = "RxLev>=-90dBm采样点";
GroupAssessmentOld.Columns["RxqualCount"].Caption = "RxQual总采样点";
GroupAssessmentOld.Columns["MosAverage"].Caption = "MOS值均值";
XmlNodeList node_GroupAssessmentViewList1 = doc.SelectNodes("//GsmVoice");
foreach (XmlNode node in node_GroupAssessmentViewList1)
{
DataRow row = GroupAssessmentOld.NewRow();
row[0] = (node.SelectSingleNode("Index") as XmlElement).GetAttribute("value"); //索引
row[1] = (node.SelectSingleNode("FileName") as XmlElement).GetAttribute("value");
row[2] = (node.SelectSingleNode("BeginTime") as XmlElement).GetAttribute("value");
row[3] = (node.SelectSingleNode("EndTime") as XmlElement).GetAttribute("value");
row[4] = (node.SelectSingleNode("Times") as XmlElement).GetAttribute("value");
row[5] = (node.SelectSingleNode("DistanceSum") as XmlElement).GetAttribute("value");
row[6] = (node.SelectSingleNode("ConvertLength") as XmlElement).GetAttribute("value");
row[7] = (node.SelectSingleNode("MoCallTimes") as XmlElement).GetAttribute("value");
row[8] = (node.SelectSingleNode("MoConnectTimes") as XmlElement).GetAttribute("value");
row[9] = (node.SelectSingleNode("MtConnectTimes") as XmlElement).GetAttribute("value");
row[10] = (node.SelectSingleNode("MoFailureTimes") as XmlElement).GetAttribute("value");
row[11] = (node.SelectSingleNode("MtFailureTimes") as XmlElement).GetAttribute("value");
row[12] = (node.SelectSingleNode("RlevCount") as XmlElement).GetAttribute("value");
row[13] = (node.SelectSingleNode("RlevCount2") as XmlElement).GetAttribute("value");
row[14] = (node.SelectSingleNode("RxqualCount") as XmlElement).GetAttribute("value");
row[15] = (node.SelectSingleNode("MosAverage") as XmlElement).GetAttribute("value");
GroupAssessmentOld.Rows.Add(row);
}
string Index = "汇总";
string FileName = "";
string BeginTime = "";
string EndTime = "";
string Times = "";
float DistanceSum = 0;
float ConvertLength = 0;
float MoCallTimes = 0;
float MoConnectTimes = 0;
float MtConnectTimes = 0;
float MoFailureTimes = 0;
float MtFailureTimes = 0;
float RlevCount = 0;
float RlevCount2 = 0;
float RxqualCount = 0;
//float MosAverage = 0;
for (int h = 0; h < GroupAssessmentOld.Rows.Count; h++)
{
float a1 = 0;
try
{
a1 += float.Parse(GroupAssessmentOld.Rows[h]["DistanceSum"].ToString());
}
catch { }
DistanceSum += a1;
float a2 = 0;
try
{
a2 += float.Parse(GroupAssessmentOld.Rows[h]["ConvertLength"].ToString());
}
catch { }
ConvertLength += a2;
float a3 = 0;
try
{
a3 += float.Parse(GroupAssessmentOld.Rows[h]["MoCallTimes"].ToString());
}
catch { }
MoCallTimes += a3;
float a4 = 0;
try
{
a4 += float.Parse(GroupAssessmentOld.Rows[h]["MoConnectTimes"].ToString());
}
catch { }
MoConnectTimes += a4;
float a5 = 0;
try
{
a5 += float.Parse(GroupAssessmentOld.Rows[h]["MtConnectTimes"].ToString());
}
catch { }
MtConnectTimes += a5;
float a6 = 0;
try
{
a6 += float.Parse(GroupAssessmentOld.Rows[h]["RlevCount"].ToString());
}
catch { }
RlevCount += a6;
float a7 = 0;
try
{
a7 += float.Parse(GroupAssessmentOld.Rows[h]["RlevCount2"].ToString());
}
catch { }
RlevCount2 += a7;
float a8 = 0;
try
{
a8 += float.Parse(GroupAssessmentOld.Rows[h]["RxqualCount"].ToString());
}
catch { }
RxqualCount += a8;
float a9 = 0;
try
{
a9 += float.Parse(GroupAssessmentOld.Rows[h]["MoFailureTimes"].ToString());
}
catch { }
MoFailureTimes += a9;
float a10 = 0;
try
{
a10 += float.Parse(GroupAssessmentOld.Rows[h]["MtFailureTimes"].ToString());
}
catch { }
MtFailureTimes += a10;
}
DataRow rowc = GroupAssessmentOld.NewRow();
rowc["Index"] = Index;
rowc["FileName"] = FileName;
rowc["BeginTime"] = BeginTime;
rowc["EndTime"] = EndTime;
rowc["Times"] = Times;
rowc["DistanceSum"] = DistanceSum.ToString();
rowc["ConvertLength"] = ConvertLength.ToString();
rowc["MoCallTimes"] = MoCallTimes.ToString();
rowc["MoConnectTimes"] = MoConnectTimes.ToString();
rowc["MtConnectTimes"] = MtConnectTimes.ToString();
rowc["MoFailureTimes"] = MoFailureTimes.ToString();
rowc["MtFailureTimes"] = MtFailureTimes.ToString();
rowc["RlevCount"] = RlevCount.ToString();
rowc["RlevCount2"] = RlevCount2.ToString();
rowc["RxqualCount"] = RxqualCount.ToString();
rowc["MosAverage"] = MosAverage;
GroupAssessmentOld.Rows.Add(rowc);
ds.Tables.Add(GroupAssessmentOld);
break;
#endregion
#region ParametView 参数统计报表
case SendCommandType.ParametView: /// ****************************************************** //参数统计报表
if (_listparamet == null)
{
throw new Exception("参数报表--GetParamet() is null");
}
//添加第一张 文件log表
DataTable logfile = new DataTable("LogFile1");
XmlNodeList node_logfile = doc.SelectNodes("//FileName");
logfile.Columns.Add("Index");
logfile.Columns["Index"].Caption = "索引";
logfile.Columns.Add("FileName");
logfile.Columns["FileName"].Caption = "文件名";
for (int i = 0; i < node_logfile.Count; i++)
{
DataRow row = logfile.NewRow();
row[0] = (i + 1).ToString();
row[1] = (node_logfile[i] as XmlElement).GetAttribute("value");
logfile.Rows.Add(row);
}
ds.Tables.Add(logfile);
string j1 = logfile.Rows[0][0].ToString();
string j2 = logfile.Rows[0][1].ToString();
//添加第二张 基本测试信息
DataTable logfile1 = new DataTable("LogFile2");
XmlNodeList node_logfile1 = doc.SelectNodes("//AllFileResult");
logfile1.Columns.Add("times");
logfile1.Columns.Add("distanceSum");
foreach (XmlNode node in node_logfile1)
{
DataRow row = logfile1.NewRow();
row[0] = (node.SelectSingleNode("Times") as XmlElement).GetAttribute("value");
row[1] = (node.SelectSingleNode("DistanceSum") as XmlElement).GetAttribute("value");
logfile1.Rows.Add(row);
}
ds.Tables.Add(logfile1);
//添加 详细测试信息
for (int i = 0; i < _listparamet.Count; i++)
{
string tablename = _listparamet[i].ToString();
if (_listparamet[i].ToString() == "CIR")
{
tablename = "C/I";
}
DataTable ParametView = new DataTable("ParametView_" + tablename);
ParametView.Columns.Add("Column1");
ParametView.Columns.Add("SamplingCount");
ParametView.Columns.Add("SamplingPercentage");
ParametView.Columns.Add("DistanceSum");
ParametView.Columns.Add("SumPercentage");
ParametView.Columns.Add("TextTimes");
ParametView.Columns.Add("TimePercentage");
if (_listparamet[i].ToString() == "CIR")
{
ParametView.Columns[0].Caption = "C/I";
}
else
{
ParametView.Columns[0].Caption = _listparamet[i].ToString();
}
ParametView.Columns[1].Caption = "采样数";
ParametView.Columns[2].Caption = "采样百分比";
ParametView.Columns[3].Caption = "测试里程";
ParametView.Columns[4].Caption = "里程百分比";
ParametView.Columns[5].Caption = "测试时长";
ParametView.Columns[6].Caption = "时长百分比";
XmlNodeList node_currnt = null;
switch (_listparamet[i])
{
case RePortParamet.CIR:
node_currnt = doc.SelectNodes("//CIR");
break;
case RePortParamet.MOS:
node_currnt = doc.SelectNodes("//MOS");
break;
case RePortParamet.MsTxPower:
node_currnt = doc.SelectNodes("//MsTxPower");
break;
case RePortParamet.RxlevBCCH:
node_currnt = doc.SelectNodes("//RxlevBCCH");
break;
case RePortParamet.RxlevFull:
node_currnt = doc.SelectNodes("//RxlevFull");
break;
case RePortParamet.Rxlevsub:
node_currnt = doc.SelectNodes("//Rxlevsub");
break;
case RePortParamet.RxqualFull:
node_currnt = doc.SelectNodes("//RxqualFull");
break;
case RePortParamet.RxqualSub:
node_currnt = doc.SelectNodes("//RxqualSub");
break;
case RePortParamet.TA:
node_currnt = doc.SelectNodes("//TA");
break;
}
foreach (XmlNode node in node_currnt)
{
DataRow row = ParametView.NewRow();
row[0] = (node.SelectSingleNode("Column1") as XmlElement).GetAttribute("value"); //区间点 ---
row[1] = (node.SelectSingleNode("SamplingCount") as XmlElement).GetAttribute("value"); //采样数
row[2] = (node.SelectSingleNode("SamplingPercentage") as XmlElement).GetAttribute("value");//采样百分比
row[3] = (node.SelectSingleNode("DistanceSum") as XmlElement).GetAttribute("value");//测试里程
row[4] = (node.SelectSingleNode("SumPercentage") as XmlElement).GetAttribute("value"); //里程百分比
row[5] = (node.SelectSingleNode("TextTimes") as XmlElement).GetAttribute("value"); //测试时长
row[6] = (node.SelectSingleNode("TimePercentage") as XmlElement).GetAttribute("value"); //时长百分比
ParametView.Rows.Add(row);
}
ds.Tables.Add(ParametView);
}
break;
#endregion
#region NetGridView 网络统计报表
case SendCommandType.NetGridView: //******************************************************网格统计报表
DataTable dt_Grid = new DataTable(SendCommandType.NetGridView.ToString());
dt_Grid.Columns.Add("Index");
dt_Grid.Columns.Add("NetGridInfo");
dt_Grid.Columns.Add("MoCallTimes");
dt_Grid.Columns.Add("MoConnectTimes");
dt_Grid.Columns.Add("DropTimes");
dt_Grid.Columns.Add("RlevCount");
dt_Grid.Columns.Add("Connect");
dt_Grid.Columns.Add("Failure");
dt_Grid.Columns.Add("Rxlev");
dt_Grid.Columns.Add("Rxlev2");
dt_Grid.Columns.Add("MosAvg");
dt_Grid.Columns.Add("Rxqual");
dt_Grid.Columns.Add("Duration");
dt_Grid.Columns["Index"].Caption = "索引";
dt_Grid.Columns["NetGridInfo"].Caption = "网格名称";
dt_Grid.Columns["MoCallTimes"].Caption = "试呼次数";
dt_Grid.Columns["MoConnectTimes"].Caption = "接通次数";
dt_Grid.Columns["DropTimes"].Caption = "掉话次数";
dt_Grid.Columns["RlevCount"].Caption = "RxLev总采样点";
dt_Grid.Columns["Connect"].Caption = "接通率(%)";
dt_Grid.Columns["Failure"].Caption = "掉话率(%)";
dt_Grid.Columns["Rxlev"].Caption = "覆盖率(>=-90dBm)";
dt_Grid.Columns["Rxlev2"].Caption = "覆盖率(>=-94dBm)";
dt_Grid.Columns["MosAvg"].Caption = "MOS均值";
dt_Grid.Columns["Rxqual"].Caption = "话音质量(%)";
dt_Grid.Columns["Duration"].Caption = "呼叫建立时延均值(s)";
//内容节点集合
XmlNodeList node_NetGridView = doc.SelectNodes("//NetGrid");
foreach (XmlNode node in node_NetGridView)
{
DataRow row = dt_Grid.NewRow();
row[0] = (node.SelectSingleNode("Index ") as XmlElement).GetAttribute("value"); //索引
row[1] = (node.SelectSingleNode("NetGridInfo ") as XmlElement).GetAttribute("value");
row[2] = (node.SelectSingleNode("MoCallTimes") as XmlElement).GetAttribute("value");
row[3] = (node.SelectSingleNode("MoConnectTimes") as XmlElement).GetAttribute("value");
row[4] = (node.SelectSingleNode("DropTimes") as XmlElement).GetAttribute("value");
row[5] = (node.SelectSingleNode("RlevCount") as XmlElement).GetAttribute("value");
row[6] = (node.SelectSingleNode("Connect") as XmlElement).GetAttribute("value");
row[7] = (node.SelectSingleNode("Failure") as XmlElement).GetAttribute("value");
row[8] = (node.SelectSingleNode("Rxlev") as XmlElement).GetAttribute("value");
row[9] = (node.SelectSingleNode("Rxlev2") as XmlElement).GetAttribute("value");
row[10] = (node.SelectSingleNode("MosAvg") as XmlElement).GetAttribute("value");
row[11] = (node.SelectSingleNode("Rxqual") as XmlElement).GetAttribute("value");
row[12] = (node.SelectSingleNode("Duration") as XmlElement).GetAttribute("value");
dt_Grid.Rows.Add(row);
}
ds.Tables.Add(dt_Grid);
break;
#endregion
#region CellInfiltrationView 小区渗透报表
case SendCommandType.CellInfiltrationView: //******************************** 小区渗透报表
//添加第一张 文件log表
DataTable CellInfiltrationView1 = new DataTable("CellInfiltrationView1");
XmlNodeList node_FileList = doc.SelectNodes("//FileName");
CellInfiltrationView1.Columns.Add("Index");
CellInfiltrationView1.Columns.Add("FileName");
CellInfiltrationView1.Columns["Index"].Caption = "索引";
CellInfiltrationView1.Columns["FileName"].Caption = "文件名";
for (int i = 0; i < node_FileList.Count; i++)
{
DataRow row = CellInfiltrationView1.NewRow();
row[0] = (i + 1).ToString();
row[1] = node_FileList[i].InnerXml;
CellInfiltrationView1.Rows.Add(row);
}
ds.Tables.Add(CellInfiltrationView1);
//添加第二张 基本测试信息
DataTable CellInfiltrationView2 = new DataTable("CellInfiltrationView2");
CellInfiltrationView2.Columns.Add("Index1");
CellInfiltrationView2.Columns.Add("Lac");
CellInfiltrationView2.Columns.Add("Ci");
CellInfiltrationView2.Columns.Add("RxLevSub");
CellInfiltrationView2.Columns.Add("RxQualSub");
CellInfiltrationView2.Columns.Add("DropTimes");
CellInfiltrationView2.Columns.Add("MoFailureTimes");
CellInfiltrationView2.Columns.Add("ServiceTime");
CellInfiltrationView2.Columns.Add("ServiceTimePercentage");
CellInfiltrationView2.Columns.Add("ServiceDistance");
CellInfiltrationView2.Columns.Add("ServiceDistancePercentage");
CellInfiltrationView2.Columns["Index1"].Caption = "索引";
CellInfiltrationView2.Columns["Lac"].Caption = "LAC";
CellInfiltrationView2.Columns["Ci"].Caption = "CI";
CellInfiltrationView2.Columns["RxLevSub"].Caption = "RxLevSub平均值";
CellInfiltrationView2.Columns["RxQualSub"].Caption = "RxQualSub平均值";
CellInfiltrationView2.Columns["DropTimes"].Caption = "掉话次数";
CellInfiltrationView2.Columns["MoFailureTimes"].Caption = "主叫呼叫失败次数";
CellInfiltrationView2.Columns["ServiceTime"].Caption = "小区服务时长";
CellInfiltrationView2.Columns["ServiceTimePercentage"].Caption = "服务时长百分比";
CellInfiltrationView2.Columns["ServiceDistance"].Caption = "小区服务里程";
CellInfiltrationView2.Columns["ServiceDistancePercentage"].Caption = "服务里程百分比";
XmlNodeList node_FileList2 = doc.SelectNodes("//CellInfiltration");
int rowcot = 0;
foreach (XmlNode node in node_FileList2)
{
rowcot++;
DataRow row = CellInfiltrationView2.NewRow();
row[0] = rowcot.ToString();
row[1] = (node.SelectSingleNode("Lac") as XmlElement).GetAttribute("value");
row[2] = (node.SelectSingleNode("Ci") as XmlElement).GetAttribute("value");
row[3] = (node.SelectSingleNode("RxLevSub") as XmlElement).GetAttribute("value");
row[4] = (node.SelectSingleNode("RxQualSub") as XmlElement).GetAttribute("value");
row[5] = (node.SelectSingleNode("DropTimes") as XmlElement).GetAttribute("value");
row[6] = (node.SelectSingleNode("MoFailureTimes") as XmlElement).GetAttribute("value");
row[7] = (node.SelectSingleNode("ServiceTime") as XmlElement).GetAttribute("value");
row[8] = (node.SelectSingleNode("ServiceTimePercentage") as XmlElement).GetAttribute("value");
row[9] = (node.SelectSingleNode("ServiceDistance") as XmlElement).GetAttribute("value");
row[10] = (node.SelectSingleNode("ServiceDistancePercentage") as XmlElement).GetAttribute("value");
CellInfiltrationView2.Rows.Add(row);
}
ds.Tables.Add(CellInfiltrationView2);
break;
#endregion
#region ExceptionEventView
case SendCommandType.ExceptionEventView: //*************************************************************异常事件报表
DataTable dt_exception = new DataTable(SendCommandType.ExceptionEventView.ToString());
//基本不变信息
dt_exception.Columns.Add("FileName");
dt_exception.Columns.Add("DateTime");
dt_exception.Columns.Add("Event");
dt_exception.Columns.Add("NetGridInfo");
dt_exception.Columns.Add("SquaregrID");
dt_exception.Columns.Add("BSIC");
dt_exception.Columns.Add("BCCH");
dt_exception.Columns.Add("LAC");
dt_exception.Columns.Add("CI");
dt_exception.Columns["FileName"].Caption = "文件名";
dt_exception.Columns["Event"].Caption = "事件";
dt_exception.Columns["NetGridInfo"].Caption = "网格信息";
dt_exception.Columns["SquaregrID"].Caption = "栅格信息";
dt_exception.Columns["BSIC"].Caption = "BSIC";
dt_exception.Columns["BCCH"].Caption = "BCCH";
dt_exception.Columns["LAC"].Caption = "LAC";
dt_exception.Columns["CI"].Caption = "CI";
//变化信息
//if (_listexception.Count <= 0) break;
foreach (ReportException comd in _listexception)
{
dt_exception.Columns.Add(comd.ToString() + "_Max");
dt_exception.Columns[comd.ToString() + "_Max"].Caption = comd.ToString() + "_Max";
dt_exception.Columns.Add(comd.ToString() + "_Min");
dt_exception.Columns[comd.ToString() + "_Min"].Caption = comd.ToString() + "_Min";
dt_exception.Columns.Add(comd.ToString() + "_Avg");
dt_exception.Columns[comd.ToString() + "_Avg"].Caption = comd.ToString() + "_Avg";
}
XmlNodeList node_exception = doc.SelectNodes("//Row");
foreach (XmlNode node in node_exception)
{
DataRow row = dt_exception.NewRow();
row["FileName"] = (node.SelectSingleNode("FileName") as XmlElement).GetAttribute("value");
row["DateTime"] = (node.SelectSingleNode("EventTime") as XmlElement).GetAttribute("value");
row["Event"] = (node.SelectSingleNode("Event") as XmlElement).GetAttribute("value");
row["BSIC"] = (node.SelectSingleNode("Bsic") as XmlElement).GetAttribute("value");
row["BCCH"] = (node.SelectSingleNode("Bcch") as XmlElement).GetAttribute("value");
row["LAC"] = (node.SelectSingleNode("Lac") as XmlElement).GetAttribute("value");
row["CI"] = (node.SelectSingleNode("Ci") as XmlElement).GetAttribute("value");
row["NetGridInfo"] = (node.SelectSingleNode("NetGridInfo") as XmlElement).GetAttribute("value");
row["SquaregrID"] = (node.SelectSingleNode("SquaregrID") as XmlElement).GetAttribute("value");
foreach (ReportException comd in _listexception)
{
row[comd.ToString() + "_Max"] = (node.SelectSingleNode("Paramet/" + comd.ToString() + "/Max") as XmlElement).GetAttribute("value");
row[comd.ToString() + "_Min"] = (node.SelectSingleNode("Paramet/" + comd.ToString() + "/Min") as XmlElement).GetAttribute("value");
row[comd.ToString() + "_Avg"] = (node.SelectSingleNode("Paramet/" + comd.ToString() + "/Avg") as XmlElement).GetAttribute("value");
}
dt_exception.Rows.Add(row);
}
ds.Tables.Add(dt_exception);
break;
#endregion
#region AccessReasonView 接入原因报表
case SendCommandType.AccessReasonsView: //********接入原因报表 AccessReasonsView
DataTable dt_Reason1 = new DataTable(SendCommandType.AccessReasonsView.ToString() + "1");
DataTable dt_Reason2 = new DataTable(SendCommandType.AccessReasonsView.ToString() + "2");
DataTable dt_Reason3 = new DataTable(SendCommandType.AccessReasonsView.ToString() + "3");
dt_Reason1.Columns.Add("ReasonName");
dt_Reason1.Columns.Add("Count");
dt_Reason1.Columns.Add("CDF");
dt_Reason1.Columns.Add("PDF");
dt_Reason1.Columns["ReasonName"].Caption = "原因";
dt_Reason1.Columns["Count"].Caption = "次数";
dt_Reason1.Columns["CDF"].Caption = "CDF";
dt_Reason1.Columns["PDF"].Caption = "PDF";
dt_Reason2.Columns.Add("ReasonName");
dt_Reason2.Columns.Add("Count");
dt_Reason2.Columns.Add("CDF");
dt_Reason2.Columns.Add("PDF");
dt_Reason2.Columns["ReasonName"].Caption = "原因";
dt_Reason2.Columns["Count"].Caption = "次数";
dt_Reason2.Columns["CDF"].Caption = "CDF";
dt_Reason2.Columns["PDF"].Caption = "PDF";
dt_Reason3.Columns.Add("ReasonName");
dt_Reason3.Columns.Add("Count");
dt_Reason3.Columns.Add("CDF");
dt_Reason3.Columns.Add("PDF");
dt_Reason3.Columns["ReasonName"].Caption = "原因";
dt_Reason3.Columns["Count"].Caption = "次数";
dt_Reason3.Columns["CDF"].Caption = "CDF";
dt_Reason3.Columns["PDF"].Caption = "PDF";
string callcount = (doc.SelectSingleNode("AccessReasonsView/Call") as XmlElement).GetAttribute("value");
string rrccount = (doc.SelectSingleNode("AccessReasonsView/RRC") as XmlElement).GetAttribute("value");
string rbcount = (doc.SelectSingleNode("AccessReasonsView/RB") as XmlElement).GetAttribute("value");
XmlNodeList node_Reason1 = doc.SelectNodes("//Row1");
foreach (XmlNode node in node_Reason1)
{
DataRow row = dt_Reason1.NewRow();
row["ReasonName"] = (node.SelectSingleNode("ReasonName") as XmlElement).GetAttribute("value");
row["Count"] = (node.SelectSingleNode("Count") as XmlElement).GetAttribute("value");
row["CDF"] = (node.SelectSingleNode("CDF") as XmlElement).GetAttribute("value");
row["PDF"] = (node.SelectSingleNode("PDF") as XmlElement).GetAttribute("value");
dt_Reason1.Rows.Add(row);
}
if (node_Reason1.Count > 0)
{
DataRow row_r1 = dt_Reason1.NewRow();
row_r1["ReasonName"] = "总计";
row_r1["Count"] = callcount;
row_r1["CDF"] = "100%";
row_r1["PDF"] = "100%";
dt_Reason1.Rows.Add(row_r1);
ds.Tables.Add(dt_Reason1);
}
XmlNodeList node_Reason2 = doc.SelectNodes("//Row2");
foreach (XmlNode node in node_Reason2)
{
DataRow row = dt_Reason2.NewRow();
row["ReasonName"] = (node.SelectSingleNode("ReasonName") as XmlElement).GetAttribute("value");
row["Count"] = (node.SelectSingleNode("Count") as XmlElement).GetAttribute("value");
row["CDF"] = (node.SelectSingleNode("CDF") as XmlElement).GetAttribute("value");
row["PDF"] = (node.SelectSingleNode("PDF") as XmlElement).GetAttribute("value");
dt_Reason2.Rows.Add(row);
}
if (node_Reason2.Count > 0)
{
DataRow row_r2 = dt_Reason2.NewRow();
row_r2["ReasonName"] = "总计";
row_r2["Count"] = rrccount;
row_r2["CDF"] = "100%";
row_r2["PDF"] = "100%";
dt_Reason2.Rows.Add(row_r2);
ds.Tables.Add(dt_Reason2);
}
XmlNodeList node_Reason3 = doc.SelectNodes("//Row3");
foreach (XmlNode node in node_Reason3)
{
DataRow row = dt_Reason3.NewRow();
row["ReasonName"] = (node.SelectSingleNode("ReasonName") as XmlElement).GetAttribute("value");
row["Count"] = (node.SelectSingleNode("Count") as XmlElement).GetAttribute("value");
row["CDF"] = (node.SelectSingleNode("CDF") as XmlElement).GetAttribute("value");
row["PDF"] = (node.SelectSingleNode("PDF") as XmlElement).GetAttribute("value");
dt_Reason3.Rows.Add(row);
}
if (node_Reason3.Count > 0)
{
DataRow row_r3 = dt_Reason3.NewRow();
row_r3["ReasonName"] = "总计";
row_r3["Count"] = rbcount;
row_r3["CDF"] = "100%";
row_r3["PDF"] = "100%";
dt_Reason3.Rows.Add(row_r3);
ds.Tables.Add(dt_Reason3);
}
break;
#endregion
#region AccessDelayView 接入时延报表
case SendCommandType.AccessDelayView: //*******接入时延报表
//接入时延统计报表数据
DataTable dt_AccessDelayView_t1 = new DataTable(SendCommandType.AccessDelayView.ToString() + "_t1");
DataTable dt_AccessDelayView_t2 = new DataTable(SendCommandType.AccessDelayView.ToString() + "_t2");
DataTable dt_AccessDelayView_t3 = new DataTable(SendCommandType.AccessDelayView.ToString() + "_t3");
dt_AccessDelayView_t1.Columns.Add("callvalue1");
dt_AccessDelayView_t1.Columns.Add("calltime1");
dt_AccessDelayView_t1.Columns["callvalue1"].Caption = "测量值";
dt_AccessDelayView_t1.Columns["calltime1"].Caption = "呼叫建立时延";
dt_AccessDelayView_t2.Columns.Add("callvalue2");
dt_AccessDelayView_t2.Columns.Add("calltime2");
dt_AccessDelayView_t2.Columns["callvalue2"].Caption = "测量值";
dt_AccessDelayView_t2.Columns["calltime2"].Caption = "RRC建立时延";
dt_AccessDelayView_t3.Columns.Add("callvalue3");
dt_AccessDelayView_t3.Columns.Add("calltime3");
dt_AccessDelayView_t3.Columns["callvalue3"].Caption = "测量值";
dt_AccessDelayView_t3.Columns["calltime3"].Caption = "RB建立时延";
DataRow row1 = dt_AccessDelayView_t1.NewRow();
row1["callvalue1"] = "最大值";
row1["calltime1"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/CallMax") as XmlElement).GetAttribute("value");
DataRow row2 = dt_AccessDelayView_t1.NewRow();
row2["callvalue1"] = "最小值";
row2["calltime1"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/CallMin") as XmlElement).GetAttribute("value");
DataRow row3 = dt_AccessDelayView_t1.NewRow();
row3["callvalue1"] = "平均值";
row3["calltime1"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/CallAvg") as XmlElement).GetAttribute("value");
dt_AccessDelayView_t1.Rows.Add(row1);
dt_AccessDelayView_t1.Rows.Add(row2);
dt_AccessDelayView_t1.Rows.Add(row3);
ds.Tables.Add(dt_AccessDelayView_t1);
DataRow row4 = dt_AccessDelayView_t2.NewRow();
row4["callvalue2"] = "最大值";
row4["calltime2"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/RRCMax") as XmlElement).GetAttribute("value");
DataRow row5 = dt_AccessDelayView_t2.NewRow();
row5["callvalue2"] = "最小值";
row5["calltime2"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/RRCMin") as XmlElement).GetAttribute("value");
DataRow row6 = dt_AccessDelayView_t2.NewRow();
row6["callvalue2"] = "平均值";
row6["calltime2"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/RRCAvg") as XmlElement).GetAttribute("value");
dt_AccessDelayView_t2.Rows.Add(row4);
dt_AccessDelayView_t2.Rows.Add(row5);
dt_AccessDelayView_t2.Rows.Add(row6);
ds.Tables.Add(dt_AccessDelayView_t2);
DataRow row7 = dt_AccessDelayView_t3.NewRow();
row7["callvalue3"] = "最大值";
row7["calltime3"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/RBMax") as XmlElement).GetAttribute("value");
DataRow row8 = dt_AccessDelayView_t3.NewRow();
row8["callvalue3"] = "最小值";
row8["calltime3"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/RBMin") as XmlElement).GetAttribute("value");
DataRow row9 = dt_AccessDelayView_t3.NewRow();
row9["callvalue3"] = "平均值";
row9["calltime3"] = (doc.SelectSingleNode("AccessDelayView/DelayStats/RBAvg") as XmlElement).GetAttribute("value");
dt_AccessDelayView_t3.Rows.Add(row7);
dt_AccessDelayView_t3.Rows.Add(row8);
dt_AccessDelayView_t3.Rows.Add(row9);
ds.Tables.Add(dt_AccessDelayView_t3);
DataTable dt_AccessInfo = new DataTable(SendCommandType.AccessDelayView.ToString());
dt_AccessInfo.Columns.Add("AccessFlow");
dt_AccessInfo.Columns.Add("Call");
dt_AccessInfo.Columns.Add("RRC");
dt_AccessInfo.Columns.Add("RB");
dt_AccessInfo.Columns["AccessFlow"].Caption = "CallID";
dt_AccessInfo.Columns["Call"].Caption = "呼叫建立时延";
dt_AccessInfo.Columns["RRC"].Caption = "RRC建立时延";
dt_AccessInfo.Columns["RB"].Caption = "RB建立时延";
XmlNodeList node_accessinfo = doc.SelectNodes("//DelayDetail");
foreach (XmlNode node in node_accessinfo)
{
DataRow row = dt_AccessInfo.NewRow();
row["AccessFlow"] = (node.SelectSingleNode("AccessFlow") as XmlElement).GetAttribute("value");
row["Call"] = (node.SelectSingleNode("Call") as XmlElement).GetAttribute("value");
row["RRC"] = (node.SelectSingleNode("RRC") as XmlElement).GetAttribute("value");
row["RB"] = (node.SelectSingleNode("RB") as XmlElement).GetAttribute("value");
dt_AccessInfo.Rows.Add(row);
}
ds.Tables.Add(dt_AccessInfo);
break;
#endregion
#region DataBusinessView 数据业务报表
case SendCommandType.DataBusinessView: //*****************************************************数据业务报表
DataTable dt_datebus = new DataTable(SendCommandType.DataBusinessView.ToString());
dt_datebus.Columns.Add("Index");
dt_datebus.Columns.Add("FileName");
dt_datebus.Columns.Add("Time");
dt_datebus.Columns.Add("EventType");
dt_datebus.Columns["Index"].Caption = "序号";
dt_datebus.Columns["FileName"].Caption = "文件名";
dt_datebus.Columns["Time"].Caption = "时间";
dt_datebus.Columns["EventType"].Caption = "事件类型";
XmlNodeList node_datebus = doc.SelectNodes("//DataBusiness");
foreach (XmlNode node in node_datebus)
{
DataRow row = dt_datebus.NewRow();
row["Index"] = (node.SelectSingleNode("Index") as XmlElement).GetAttribute("value");
row["FileName"] = (node.SelectSingleNode("FileName") as XmlElement).GetAttribute("value");
row["Time"] = (node.SelectSingleNode("Time") as XmlElement).GetAttribute("value");
row["EventType"] = (node.SelectSingleNode("EventType") as XmlElement).GetAttribute("value");
dt_datebus.Rows.Add(row);
}
ds.Tables.Add(dt_datebus);
break;
#endregion
#region NetFrequencyUseView 网络使用频率使用报表
case SendCommandType.NetFrequencyUseView://**********网络频率使用报表
break;
#endregion
#region UName
case SendCommandType.UName:
DataTable dt_uname = new DataTable(SendCommandType.UName.ToString());
dt_uname.Columns.Add("UName");
dt_uname.Columns["UName"].Caption = "U 名字";
XmlNodeList node_uname = doc.SelectNodes("//Name");
foreach (XmlNode node in node_uname)
{
DataRow row = dt_uname.NewRow();
row["UName"] = (node as XmlElement).GetAttribute("value");
dt_uname.Rows.Add(row);
}
ds.Tables.Add(dt_uname);
break;
#endregion
#region TestPlan 测试计划
case SendCommandType.TestPlan: //测试计划
DataTable dt_TestPlan = new DataTable(SendCommandType.TestPlan.ToString());
dt_TestPlan.Columns.Add("TestPlanName"); //设备名称
dt_TestPlan.Columns.Add("Device"); //测试计划名称
dt_TestPlan.Columns.Add("Version"); //版本号
dt_TestPlan.Columns.Add("LogNums"); //log文件数目
XmlNodeList node_TestPlan = doc.SelectNodes("//TestPlanInfo");
foreach (XmlNode node in node_TestPlan)
{
DataRow row = dt_TestPlan.NewRow();
row["TestPlanName"] = (node.SelectSingleNode("TestPlanName") as XmlElement).GetAttribute("value");
row["Device"] = (node.SelectSingleNode("Device") as XmlElement).GetAttribute("value");
row["Version"] = (node.SelectSingleNode("Version") as XmlElement).GetAttribute("value");
row["LogNums"] = (node.SelectSingleNode("LogNums") as XmlElement).GetAttribute("value");
dt_TestPlan.Rows.Add(row);
}
ds.Tables.Add(dt_TestPlan);
break;
#endregion
#region Device 设备列表
case SendCommandType.Device: //设备列表
DataTable dt_Device = new DataTable(SendCommandType.Device.ToString());
dt_Device.Columns.Add("DeviceName");
dt_Device.Columns.Add("logNumd");
XmlNodeList node_Device = doc.SelectNodes("//DeviceInfo");
foreach (XmlNode node in node_Device)
{
DataRow row = dt_Device.NewRow();
row["DeviceName"] = (node.SelectSingleNode("DeviceName") as XmlElement).GetAttribute("value");
row["logNumd"] = (node.SelectSingleNode("logNumd") as XmlElement).GetAttribute("value");
dt_Device.Rows.Add(row);
}
ds.Tables.Add(dt_Device);
break;
#endregion
#region LogFileTestPlan 测试计划
case SendCommandType.LogFileTestPlan: //测试计划 log文件
DataTable dt_LogFileTestPlan = new DataTable(SendCommandType.LogFileTestPlan.ToString());
dt_LogFileTestPlan.Columns.Add("FileName");
XmlNodeList node_LogFileTestPlan = doc.SelectNodes("//LogFileInfo");
foreach (XmlNode node in node_LogFileTestPlan)
{
DataRow row = dt_LogFileTestPlan.NewRow();
row["FileName"] = (node.SelectSingleNode("FileName") as XmlElement).GetAttribute("value");
dt_LogFileTestPlan.Rows.Add(row);
}
ds.Tables.Add(dt_LogFileTestPlan);
break;
#endregion
#region LogFileDevice 设备列表
case SendCommandType.LogFileDevice: //设别列表 log文件 LogFileInfo FileName
DataTable dt_LogFileDevice = new DataTable(SendCommandType.LogFileDevice.ToString());
dt_LogFileDevice.Columns.Add("FileName");
XmlNodeList node_LogFileDevice = doc.SelectNodes("//LogFileInfo");
foreach (XmlNode node in node_LogFileDevice)
{
DataRow row = dt_LogFileDevice.NewRow();
row["FileName"] = (node.SelectSingleNode("FileName") as XmlElement).GetAttribute("value");
dt_LogFileDevice.Rows.Add(row);
}
ds.Tables.Add(dt_LogFileDevice);
break;
#endregion
#region DtConfig
case SendCommandType.DtConfig:
DataTable dt_DtConfig = new DataTable(SendCommandType.DtConfig.ToString());
#region 添加列
dt_DtConfig.Columns.Add("fileid");
dt_DtConfig.Columns.Add("DtlogVersion");
dt_DtConfig.Columns.Add("Vendor");
dt_DtConfig.Columns.Add("Version");
dt_DtConfig.Columns.Add("NetMode");
dt_DtConfig.Columns.Add("Time");
dt_DtConfig.Columns.Add("Device");
dt_DtConfig.Columns.Add("Type");
dt_DtConfig.Columns.Add("TEST_PLAN_VER");
dt_DtConfig.Columns.Add("UserName");
#endregion
XmlNodeList node_DtConfig = doc.SelectNodes("//config");
foreach (XmlNode node in node_DtConfig)
{
DataRow dtRow = dt_DtConfig.NewRow();
#region 添加行信息
dtRow["fileid"] = (node.SelectSingleNode("fileid") as XmlElement).GetAttribute("value");
dtRow["DtlogVersion"] = (node.SelectSingleNode("DtlogVersion") as XmlElement).GetAttribute("value");
dtRow["Vendor"] = (node.SelectSingleNode("Vendor") as XmlElement).GetAttribute("value");
dtRow["Version"] = (node.SelectSingleNode("Version") as XmlElement).GetAttribute("value");
dtRow["NetMode"] = (node.SelectSingleNode("NetMode") as XmlElement).GetAttribute("value");
dtRow["Time"] = (node.SelectSingleNode("Time") as XmlElement).GetAttribute("value");
dtRow["Device"] = (node.SelectSingleNode("Device") as XmlElement).GetAttribute("value");
dtRow["Type"] = (node.SelectSingleNode("Type") as XmlElement).GetAttribute("value");
dtRow["TEST_PLAN_VER"] = (node.SelectSingleNode("TEST_PLAN_VER") as XmlElement).GetAttribute("value");
dtRow["UserName"] = (node.SelectSingleNode("UserName") as XmlElement).GetAttribute("value");
#endregion
dt_DtConfig.Rows.Add(dtRow);
}
ds.Tables.Add(dt_DtConfig);
break;
#endregion
}
return ds;
}
# endregion
#region 发送命令到服务端 public SendCommandTo
private SendCommandType _type;
private object _obj;
/// <summary>
/// 发送请求命令 除栅格、网格、黑点、异常事件外 第二参数可以为null
/// </summary>
/// <param name="type">命令类型枚举</param>
/// <param name="obj">命令对象</param>
/// <returns></returns>
public bool SendCommandTo(SendCommandType type, object obj)
{
System.Diagnostics.Trace.WriteLine("==============121212 ====");
_type = type;
_obj = obj;
try
{
if (!IsConnection())
{
if (type == SendCommandType.Login || type == SendCommandType.Logoff || type == SendCommandType.SearchFile || type == SendCommandType.GetGroup || type == SendCommandType.GetSecondGroup || type == SendCommandType.DtConfig)
{
BeginListen(LoginInfo.Ip, LoginInfo.ServerPoint);
}
else
{
BeginListen();
}
}
else
{
SendCommand(type, obj);
System.Timers.Timer tim = new System.Timers.Timer(20000);
tim.Elapsed += new System.Timers.ElapsedEventHandler(StopLoad);//到达时间的时候执行事件
tim.AutoReset = false;//设置是执行一次（false）还是一直执行(true)
tim.Enabled = true;//是否执行System.Timers.Timer.Elapsed事件
System.Diagnostics.Trace.WriteLine("==============开始发送数据请求: ====");
}
return true;
}
catch
{
return false;
}
}
/// <summary>
/// 连接状态 返回
/// </summary>
/// <param name="b">b 为true连接成功、否则连接失败</param>
/// <param name="msg">连接失败信息</param>
private void BackConnetState(bool b, string msg)
{
if (b)
{
SendCommand(_type, _obj);
System.Diagnostics.Trace.WriteLine("本次发送次数:++");
}
else
{
StopLoadFile();
if (msg != "服务器连接中断!")
{
if (Event_ConnetionState != null)
Event_ConnetionState(false, msg);
}
//BeginListen();
}
}
/// <summary>
/// 发送请求命令
/// </summary>
/// <param name="type">命令枚举</param>
/// <param name="obj">命令对象</param>
private void SendCommand(SendCommandType type, object obj)
{
bool b = false;
switch (type)
{
case SendCommandType.Login:
FileWork.Instance.ClearXml(SendCommandType.Login.ToString());
break;
case SendCommandType.QueryLogKey:
FileWork.Instance.ClearXml(SendCommandType.QueryLogKey.ToString());
break;
case SendCommandType.Logoff:
FileWork.Instance.ClearXml(SendCommandType.Logoff.ToString());
break;
case SendCommandType.GetGroup:
FileWork.Instance.ClearXml(SendCommandType.GetGroup.ToString());
break;
case SendCommandType.GetSecondGroup:
FileWork.Instance.ClearXml(SendCommandType.GetSecondGroup.ToString());
break;
case SendCommandType.GetATUIDList:
FileWork.Instance.ClearXml(SendCommandType.GetATUIDList.ToString());
break;
case SendCommandType.GetGrid:
FileWork.Instance.ClearXml(SendCommandType.GetGrid.ToString());
break;
case SendCommandType.SearchFile:
FileWork.Instance.ClearXml(SendCommandType.SearchFile.ToString());
break;
case SendCommandType.DtConfig:
FileWork.Instance.ClearXml(SendCommandType.DtConfig.ToString());
break;
case SendCommandType.GroupAssessmentView:
FileWork.Instance.ClearXml(SendCommandType.GroupAssessmentView.ToString());
break;
case SendCommandType.ParametView:
FileWork.Instance.ClearXml(SendCommandType.ParametView.ToString());
break;
case SendCommandType.AccessDelayView:
FileWork.Instance.ClearXml(SendCommandType.AccessDelayView.ToString());
break;
case SendCommandType.AccessReasonsView:
FileWork.Instance.ClearXml(SendCommandType.AccessReasonsView.ToString());
break;
case SendCommandType.CellInfiltrationView:
FileWork.Instance.ClearXml(SendCommandType.CellInfiltrationView.ToString());
break;
case SendCommandType.ExceptionEventView:
FileWork.Instance.ClearXml(SendCommandType.ExceptionEventView.ToString());
break;
case SendCommandType.NetGridView:
FileWork.Instance.ClearXml(SendCommandType.NetGridView.ToString());
break;
case SendCommandType.DataBusinessView:
FileWork.Instance.ClearXml(SendCommandType.DataBusinessView.ToString());
break;
case SendCommandType.NetFrequencyUseView:
FileWork.Instance.ClearXml(SendCommandType.NetFrequencyUseView.ToString());
break;
case SendCommandType.RoadBlackPoint: //道路黑点
FileWork.Instance.ClearXml(SendCommandType.RoadBlackPoint.ToString());
break;
case SendCommandType.NetGridData://网格
FileWork.Instance.ClearXml(SendCommandType.NetGridData.ToString());
break;
case SendCommandType.NetGridDataFind: //网格查询
FileWork.Instance.ClearXml(SendCommandType.NetGridDataFind.ToString());
break;
case SendCommandType.SquaresGridData://栅格
FileWork.Instance.ClearXml(SendCommandType.SquaresGridData.ToString());
break;
case SendCommandType.UName: //获取U
FileWork.Instance.ClearXml(SendCommandType.UName.ToString());
break;
case SendCommandType.UploadFileNames://获取验证后的上船文件列表
FileWork.Instance.ClearXml(SendCommandType.UploadFileNames.ToString());
break;
case SendCommandType.UploadFileFinish://发送上传成功的文件列表
break;
case SendCommandType.ExceptionEvent: //查找异常事件
FileWork.Instance.ClearXml(SendCommandType.ExceptionEvent.ToString());
break;
case SendCommandType.TestPlan: //测试计划
FileWork.Instance.ClearXml(SendCommandType.TestPlan.ToString());
break;
case SendCommandType.Device: //设备列表
FileWork.Instance.ClearXml(SendCommandType.Device.ToString());
break;
case SendCommandType.LogFileTestPlan: //测试计划 log文件列表
FileWork.Instance.ClearXml(SendCommandType.LogFileTestPlan.ToString());
break;
case SendCommandType.LogFileDevice: //设备列表 log文件列表
FileWork.Instance.ClearXml(SendCommandType.LogFileDevice.ToString());
break;
case SendCommandType.ServerDownLogFile_Device:
FileWork.Instance.ClearXml(SendCommandType.ServerDownLogFile_Device.ToString());
break;
case SendCommandType.ServerDownLogFile_Plan:
FileWork.Instance.ClearXml(SendCommandType.ServerDownLogFile_Plan.ToString());
break;
case SendCommandType.RoadInfiltration: //道路渗透
FileWork.Instance.ClearXml(SendCommandType.RoadInfiltration.ToString());
break;
case SendCommandType.AreaGroupAssessmentView: //区域统计集团报表
FileWork.Instance.ClearXml(SendCommandType.AreaGroupAssessmentView.ToString());
break;
case SendCommandType.RoadFrequency: //道路渗透频度
FileWork.Instance.ClearXml(SendCommandType.RoadFrequency.ToString());
break;
case SendCommandType.GetFtpInformation:
FileWork.Instance.ClearXml(SendCommandType.GetFtpInformation.ToString());
break;
case SendCommandType.ManualTestQuery:
FileWork.Instance.ClearXml(SendCommandType.ManualTestQuery.ToString());
break;
default:
b = true;
break;
}
if (b)
{
if (Event_ConnetionState != null)
Event_ConnetionState(false, "错误：请求命令参数错误");
return;
}
List<byte[]> send = BuildCommand.Instance.Buildcommand(type, obj);
if (send == null)
{
if (Event_ConnetionState != null)
Event_ConnetionState(false, "错误：生成发送命令为null");
return;
}
for (int i = 0; i < send.Count; i++)
{
if (!BaseNetWork.GetNetWork().BeginSend(send[i]))
return;
}
if (type != SendCommandType.UploadFileFinish && type != SendCommandType.ServerDownLogFile_Plan && type != SendCommandType.ServerDownLogFile_Device)
{
//开始计时 超时设置
t.Elapsed -= new System.Timers.ElapsedEventHandler(TimeOutMethod);
t.Elapsed += new System.Timers.ElapsedEventHandler(TimeOutMethod);
t.AutoReset = true;
timenum = 0;
t.Enabled = true;
}
//if (type == SendCommandType.ServerDownLogFile_Device || type == SendCommandType.ServerDownLogFile_Plan)
//{
// StopLoadFile();
//}
}
/// <summary>
/// 计时方法
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void TimeOutMethod(object sender, System.Timers.ElapsedEventArgs e)
{
timenum += 1;
if (timenum == 50)
{
if (Event_TimeOut != null)
{
//StopLoadFile();
Event_TimeOut(true);
}
t.Enabled = false;
}
}
#endregion
}
using System;
using System.Collections.Generic;
using System.Text;
using System.Net.Sockets;
using System.Net;
using System.Threading;
using System.IO;
using System.Configuration;
using System.Net.NetworkInformation;
namespace UltraPower.TDAPBasis
{
public class BaseNetWork
{
private BaseNetWork() { }
public static BaseNetWork GetNetWork()
{
if (_bnw == null)
_bnw = new BaseNetWork();
return _bnw;
}
#region 私有变量
private Socket _socket;
private NetworkStream ns;
private bool _IsFinish = true;
private static BaseNetWork _bnw = null;
#endregion
#region 事件
/// <summary>
/// 通知每次接收的数据
/// </summary>
public event delegateMessage EventMessage;
/// <summary>
/// 连接状态 回发通知
/// </summary>
public event Connection_State Event_ConnectionState;
public event Action ReceiveFailEvent;
#endregion
#region 检测方法
/// <summary>
/// 用Ping命令检测某个IP地址是否存在
/// </summary>
/// <param name="IP"></param>
/// <returns></returns>
public static bool PingIP(string IP)
{
PingReply reply = new Ping().Send(IP);
if (reply.Status == IPStatus.Success)
return true;
else
return false;
}
/// <summary>
/// 检查服务是否可以连接
/// </summary>
/// <param name="IP"></param>
/// <param name="Port"></param>
/// <returns></returns>
public static bool TestNetwork(string IP, string Port)
{
bool res = true;
Socket s;
try
{
using (s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
s.Connect(IP, int.Parse(Port));
}
}
catch { res = false; }
return res;
}
/// <summary>
/// 检查Socket是否可用
/// </summary>
/// <param name="socket"></param>
/// <returns></returns>
public bool IsConnected(Socket socket, out bool isReceiveFail)
{
isReceiveFail = false;
try
{
if (socket.Connected && socket.Poll(0, SelectMode.SelectRead))
{
byte[] msg = new byte[1];
int count = 0;
try
{
count = socket.Receive(msg, 0, 1, SocketFlags.Peek);
}
catch (SocketException sex)
{
isReceiveFail = true;
}
if (count != 0)
return true;
else
return false;
}
}
catch
{
return false;
}
return socket.Connected;
}
#endregion
#region 连接、断开、发送、开始线程
/// <summary>
/// 创建对应终结点的socket对象 -未连接
/// </summary>
/// <returns>socket</returns>
public Socket SocekConnection()
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
return _socket;
}
/// <summary>
/// 停止网络传输
/// </summary>
public void StopLoadFile()
{
_IsFinish = false;
if (_socket != null)
{
ns = null;
_socket.Close();
_socket = null;
}
}
public void StopLoad(object source, System.Timers.ElapsedEventArgs e)
{
_IsFinish = false;
if (_socket != null)
{
ns = null;
_socket.Close();
_socket = null;
}
}
/// <summary>
/// 开始 监听线程
/// </summary>
public void BeginLoadFile()
{
_IsFinish = true;
}
/// <summary>
/// 向服务端发送信息 发送失败返回false
/// </summary>
/// <param name="byteMessage">发送的信息</param>
/// <returns></returns>
public bool BeginSend(byte[] byteMessage)
{
try
{
if (_socket != null)
_socket.Send(byteMessage);
else
return false;
}
catch (Exception ex)
{
LogInfo.Instance.Log("fasong chu cuo" + ex.ToString());
_socket.Close();
_socket = null;
if (Event_ConnectionState != null)
{
Event_ConnectionState(false, ex.Message);
}
return false;
}
return true;
}
#endregion
/// <summary>
/// 开始 连接 接受数据
/// </summary>
public void BeginListen()
{
int _port = 0;
string _ip;
try
{
_port = int.Parse(AFPUtility.GetAppSettingsByKeyName("ServerPort").Trim());
_ip = AFPUtility.GetAppSettingsByKeyName("ServerIP").Trim();
BeginListen(_ip, _port);
}
catch (Exception ex)
{
LogInfo.Instance.Log(ex.ToString());
_socket.Close();
_socket = null;
if (Event_ConnectionState != null)
Event_ConnectionState(false, "配置文件<ServerIP><ServerPort>无效");
return;
}
}
public void BeginListen(string ip, int _port)
{
_IsFinish = true;
_socket = SocekConnection();
IPAddress _ip;
_ip = IPAddress.Parse(ip);
IPEndPoint iep = new IPEndPoint(_ip, _port);
try
{
_socket.Connect(iep);
if (Event_ConnectionState != null)
Event_ConnectionState(true, "");
}
catch (Exception ex)
{
_socket.Close();
_socket = null;
LogInfo.Instance.Log(ex.ToString());
if (Event_ConnectionState != null)
Event_ConnectionState(false, "连接断开！" + ex.Message);
_IsFinish = false;
return;
}
ns = new NetworkStream(_socket, true);
List<byte[]> list = new List<byte[]>();
int tcount = 0;
bool isReceiveFail = false;
while (_IsFinish)
{
if (!IsConnected(_socket, out isReceiveFail))
{
if (Event_ConnectionState != null)
{
System.Diagnostics.Trace.WriteLine("服务器连接中断");
Event_ConnectionState(false, "服务器连接中断!");
_IsFinish = false;
if (isReceiveFail && this.ReceiveFailEvent != null)
this.ReceiveFailEvent();
return;
}
}
try
{
if (ns.CanRead)
{
_socket.NoDelay = true;
_socket.ReceiveBufferSize = 65406;
Thread.Sleep(50);
while (ns != null && ns.DataAvailable)
{
System.Diagnostics.Trace.WriteLine("============当前NetworkStream开始读取：===========");
byte[] RecFlagBuffer = new byte[2];
ns.Read(RecFlagBuffer, 0, 2);
int ContentSize = RecFlagBuffer[0] << 8 | RecFlagBuffer[1] << 0;
byte[] byteMessage = new byte[ContentSize];
int nscount = 0;
int receivcount = 0;
int first = 0;
int allcount = ContentSize;
int readcount = 0;
while ((nscount = ns.Read(byteMessage, first, allcount)) != 0)
{
System.Diagnostics.Trace.WriteLine("本次接收到的数据大小：" + nscount.ToString());
readcount++;
receivcount += nscount;
if (receivcount >= ContentSize)
break;
first = receivcount;
allcount = ContentSize - receivcount;
}
tcount++;
System.Diagnostics.Trace.WriteLine("本次接收次数：" + tcount.ToString() + " 实际大小：" + ContentSize.ToString() + " 接收到的大小：" + receivcount.ToString());
System.Diagnostics.Trace.WriteLine("byteMessage开始和结束字符：" + byteMessage[0].ToString() + " " + byteMessage[ContentSize - 1].ToString());
if (tcount == 1 && ContentSize < 65400)
{
if (EventMessage != null)
{
tcount = 0;
System.Diagnostics.Trace.WriteLine("数据小于65400回发");
EventMessage(byteMessage);
}
}
else
{
if (ContentSize < 65400)
{
list.Add(byteMessage);
if (list.Count > 1)
{
int count = 0;
for (int i = 0; i < list.Count; i++)
{
count += list[i].Length;
}
byte[] msg = new byte[count];
int c = 0;
for (int i = 0; i < list.Count; i++)
{
if (i == 0)
{
list[i].CopyTo(msg, 0);
}
else
{
c += list[i - 1].Length;
list[i].CopyTo(msg, c);
}
}
if (EventMessage != null)
{
tcount = 0;
System.Diagnostics.Trace.WriteLine("数据大于65400回发");
EventMessage(msg);
}
}
}
else
{
list.Add(byteMessage);
}
}
}//end while (ns != null && ns.DataAvailable)
}
}
catch (ObjectDisposedException odx)
{
_socket.Close();
_socket = null;
LogInfo.Instance.Log("socket chucuo" + odx.Message.ToString());
System.Diagnostics.Trace.WriteLine("BaseNetWork:ns.DataAvailable:--->:" + odx.Message);
_IsFinish = false;
}
//catch (Exception ex)
//{
// //_IsFinish = false;
// LogInfo.Instance.Log(ex.ToString());
// _socket.Close();
// _socket = null;
// if (Event_ConnectionState != null)
// Event_ConnectionState(false, ex.Message.ToString());
//}
}
}
}
}
- 同步Socket客户端代码
- 网络同步校时客户端代码(RFC868/C++/WIN32/SOCKET)
- socket客户端代码
- git客户端之间同步代码
- socket的客户端测试代码
- C# socket编程 异步服务端 同步客户端
- socket 简单实例2.客户端代码
- Socket编程服务端和客户端代码
- C# Socket通信 客户端 服务器端代码
- Java Socket通讯客户端代码详解
- Java Socket通信 客户端服务器端基本代码
- Java Socket通讯客户端代码编写教程
- php简单socket服务器客户端代码实例
- C++ Socket发送文件客户端代码
- C# socket编程 异步服务端 同步客户端(转)
- Java socket客户端与服务端同步通信实例
- PC客户端与Android服务端的Socket同步通信
- PC客户端与Android服务端的Socket同步通信
- inno setup详解
- hadoop错误INFO ipc.Client: Retrying connect to server: localhost/127.0.0.1
- kVC 与 KVO初步认识
- 利用strace 调试程序
- iOS block用法
- 同步Socket客户端代码
- iOS- 详解文本属性Attributes
- Oracle 无法创建视图。
- UVA - 575 Skew Binary
- 二叉树（15）----由中序遍历和后序遍历重建二叉树，递归方式
- 关于oracle数据库段segment的总结
- shell 脚本命令
- php---数字格式化
- C++中的虚函数(表)实现机制以及用C语言对其进行的模拟实现
