WinForm小收集：短信程序监控IDC

Program类：

 1using System.Collections.Generic;
 2using System.ServiceProcess;
 3using System.Text;
 4#region
 5namespace IDC_SECURITY
 6{
 7static class Program
 8{
 9/**//// <summary>
/// 应用程序的主入口点。
/// </summary>
static void Main()
{
ServiceBase[] ServicesToRun;

// 同一进程中可以运行多个用户服务。若要将
// 另一个服务添加到此进程中，请更改下行以
// 创建另一个服务对象。例如，
//
//   ServicesToRun = new ServiceBase[] {new Service1(), new MySecondUserService()};
//
ServicesToRun = new ServiceBase[] { new IDC_SECURITY_SMS() };

ServiceBase.Run(ServicesToRun);
}
}

}

 服务的主类：

 1using System;
 2using System.Collections.Generic;
 3using System.ComponentModel;
 4using System.Data;
 5using System.Diagnostics;
 6using System.ServiceProcess;
 7using System.Text;
 8using System.Timers;
 9using System.Data.SqlClient;

namespace IDC_SECURITY
{
public partial class IDC_SECURITY_SMS : ServiceBase
{
public System.Timers.Timer Check_Timer = new System.Timers.Timer();
public BackgroundWorker AsyncChkThd = new System.ComponentModel.BackgroundWorker();
        
public IDC_SECURITY_SMS()
{
//配置服务信息
this.AutoLog = true;
this.CanPauseAndContinue = true;
this.CanShutdown = true;
this.CanStop = true;
this.ServiceName = "短信检测IDC状况";

//配置Timer
this.Check_Timer.Interval = Convert.ToInt32(MyConfig.GetTimeTick());
this.Check_Timer.Elapsed += new ElapsedEventHandler(Check_Timer_Elapsed);

//配置BackgroundWorker
this.AsyncChkThd.DoWork += new DoWorkEventHandler(AsyncChkThd_DoWork);

InitializeComponent();
}

void AsyncChkThd_DoWork(object sender, DoWorkEventArgs e)
{
RunChk();
}

void RunChk()
{
//检查WEB
//检查DB
List<DB_MSG> DBLIST = MyConfig.GetAllDBCONFIG();
foreach (DB_MSG DM in DBLIST)
{
CHECK.CheckAndLog(DM);
}
List<WEB_MSG> WEBLIST = MyConfig.GetAllWebCONFIG();
foreach (WEB_MSG WM in WEBLIST)
{
CHECK.CheckAndLog(WM);
}
}

void Check_Timer_Elapsed(object sender, ElapsedEventArgs e)
{
AsyncChkThd.RunWorkerAsync();
}

protected override void OnStart(string[] args)
{
// TODO: 在此处添加代码以启动服务。
Check_Timer.Enabled = true;
}

protected override void OnStop()
{
// TODO: 在此处添加代码以执行停止服务所需的关闭操作。    
Check_Timer.Enabled = false;
}
}
}

 服务设计类：

 1namespace IDC_SECURITY
 2{
 3partial class IDC_SECURITY_SMS
 4{
 5/**//// <summary> 
 6/// 必需的设计器变量。
 7/// </summary>
 8private System.ComponentModel.IContainer components = null;
 9
/**//// <summary>
/// 清理所有正在使用的资源。
/// </summary>
/// <param name="disposing">如果应释放托管资源，为 true；否则为 false。</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}

组件设计器生成的代码#region 组件设计器生成的代码

/**//// <summary> 
/// 设计器支持所需的方法 - 不要
/// 使用代码编辑器修改此方法的内容。
/// </summary>
private void InitializeComponent()
{
components = new System.ComponentModel.Container();
this.ServiceName = "Service1";
}

#endregion
}
}

 配置获取工具类：

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Xml;
  5using System.IO;
  6
  7namespace IDC_SECURITY
  8{
  9public abstract class MyConfig
 10{
 11public static readonly string XmlPath = "D:/SMS/SMS_CONFIG.xml";
 12//配置类型
 13public enum CONFIGTYPE { DBCONFIG, WEBCONFIG, LOGCONFIG, TIMECONFIG, COMNAME };
 14//XML属性列表
 15public enum AttriNames 
 16{ 
 17DB_NAME, DB_CONNSTR, DB_VAL, DB_CMDSTR, DB_SENDPHONE, DB_ERRORMSG,
 18WEB_NAME, WEB_URL, WEB_USEMETA, WEB_METANAME, WEB_VAL, WEB_SENDPHONE, WEB_ERRORMSG,
 19LOG_PATH,
 20TIME_COUNT,
 21NAME
 22};
 23
 24/**//// <summary>
 25/// 获取配置子列
 26/// </summary>
 27/// <param name="ConfigType">配置节类型</param>
 28/// <returns></returns>
 29public static XmlNodeList GetConfigs(CONFIGTYPE ConfigType)
 30{
 31XmlDocument XmlDoc = new XmlDocument();
 32XmlDoc.Load(XmlPath);
 33
 34XmlNode RootNode = null;
 35if (ConfigType == CONFIGTYPE.DBCONFIG)
 36{
 37RootNode = XmlDoc.SelectSingleNode("CONFIG/DB_CONFIG");
 38}
 39else if (ConfigType == CONFIGTYPE.LOGCONFIG)
 40{
 41RootNode = XmlDoc.SelectSingleNode("CONFIG/LOG_CONFIG");
 42}
 43else if (ConfigType == CONFIGTYPE.WEBCONFIG)
 44{
 45RootNode = XmlDoc.SelectSingleNode("CONFIG/WEB_CONFIG");
 46}
 47else if (ConfigType == CONFIGTYPE.TIMECONFIG)
 48{
 49RootNode = XmlDoc.SelectSingleNode("CONFIG/TIME_CONFIG");
 50}
 51else if (ConfigType == CONFIGTYPE.COMNAME)
 52{
 53RootNode = XmlDoc.SelectSingleNode("CONFIG/COM_NAME");
 54}
 55
 56return RootNode.ChildNodes;
 57}
 58/**//// <summary>
 59/// 获取节点属性值
 60/// </summary>
 61/// <param name="AttributeName"></param>
 62/// <param name="XNode"></param>
 63/// <returns></returns>
 64public static string GetXmlNodeValue(AttriNames AttributeName,XmlNode XNode)
 65{
 66return XNode.Attributes[AttributeName.ToString()].Value;
 67}
 68/**//// <summary>
 69/// 获取日志存放根目录
 70/// </summary>
 71/// <returns></returns>
 72public static string GetLogPath()
 73{
 74string PathRtn="";
 75XmlNodeList XNL = GetConfigs(CONFIGTYPE.LOGCONFIG);
 76for(int i=0;i<XNL.Count;i++)
 77{
 78if(XNL[i].NodeType==XmlNodeType.Element)
 79{
 80PathRtn=XNL[i].Attributes[AttriNames.LOG_PATH.ToString()].Value;
 81break;
 82}
 83}
 84return PathRtn;
 85}
 86/**//// <summary>
 87/// 遍历获取所有待测试数据库连接
 88/// </summary>
 89/// <returns></returns>
 90public static List<DB_MSG> GetAllDBCONFIG()
 91{
 92List <DB_MSG> DBOBJ_LIST= new List<DB_MSG>();
 93foreach (XmlNode XN in GetConfigs(CONFIGTYPE.DBCONFIG))
 94{
 95if (XN.NodeType == XmlNodeType.Element)
 96{
 97DB_MSG DBMOBJ = new DB_MSG();
 98DBMOBJ.CmdStr = GetXmlNodeValue(AttriNames.DB_CMDSTR, XN);
 99DBMOBJ.ConnStr = GetXmlNodeValue(AttriNames.DB_CONNSTR, XN);
DBMOBJ.Name = GetXmlNodeValue(AttriNames.DB_NAME, XN);
DBMOBJ.SendList = GetXmlNodeValue(AttriNames.DB_SENDPHONE, XN);
DBMOBJ.Val = GetXmlNodeValue(AttriNames.DB_VAL, XN);
DBMOBJ.ErrorMsg = GetXmlNodeValue(AttriNames.DB_ERRORMSG, XN);

DBOBJ_LIST.Add(DBMOBJ);
}
}

return DBOBJ_LIST;
}
/**//// <summary>
/// 遍历获取所有待测试网页
/// </summary>
/// <returns></returns>
public static List<WEB_MSG> GetAllWebCONFIG()
{
List<WEB_MSG> WEBOBJ_LIST = new List<WEB_MSG>();
foreach (XmlNode XN in GetConfigs(CONFIGTYPE.WEBCONFIG))
{
if (XN.NodeType == XmlNodeType.Element)
{
WEB_MSG WEBOBJ = new WEB_MSG();
WEBOBJ.ErrorMsg = GetXmlNodeValue(AttriNames.WEB_ERRORMSG, XN);
WEBOBJ.MetaName = GetXmlNodeValue(AttriNames.WEB_METANAME, XN);
WEBOBJ.Name = GetXmlNodeValue(AttriNames.WEB_NAME, XN);
WEBOBJ.SendList = GetXmlNodeValue(AttriNames.WEB_SENDPHONE, XN);
WEBOBJ.Url = GetXmlNodeValue(AttriNames.WEB_URL, XN);
WEBOBJ.UseMeta = bool.Parse(GetXmlNodeValue(AttriNames.WEB_USEMETA, XN));
WEBOBJ.Val = GetXmlNodeValue(AttriNames.WEB_VAL, XN);

WEBOBJ_LIST.Add(WEBOBJ);
}
}

return WEBOBJ_LIST;
}
/**//// <summary>
/// 获取定时器时间间隔
/// </summary>
/// <returns></returns>
public static int GetTimeTick()
{
int RtnTick = 0;
XmlNodeList XNL = GetConfigs(CONFIGTYPE.TIMECONFIG);
for (int i = 0; i < XNL.Count; i++)
{
if (XNL[i].NodeType == XmlNodeType.Element)
{
RtnTick = 
Convert.ToInt32(XNL[i].Attributes[AttriNames.TIME_COUNT.ToString()].Value);
break;
}
}

return RtnTick;
}
/**//// <summary>
/// 获取发送串口名
/// </summary>
/// <returns></returns>
public static string GetComName()
{
string RtnComName = "";
XmlNodeList XNL = GetConfigs(CONFIGTYPE.COMNAME);
for (int i = 0; i < XNL.Count; i++)
{
if (XNL[i].NodeType == XmlNodeType.Element)
{
RtnComName = XNL[i].Attributes[AttriNames.NAME.ToString()].Value;
break;
}
}

return RtnComName;
}
}
}

 配置XML文件：

 1<?xml version="1.0" encoding="utf-8" ?>
 2<CONFIG>
 3<DB_CONFIG>
 4<!--名称，连接串，表，值，操作命令-->
 5<!--如不指定CMDSTR，则默认为SELECT COUNT(*) FROM-->
 6<!--发送手机列采用|分割-->
 7<DB_MSG DB_NAME="客服中心数据库" DB_CONNSTR="."  DB_CMDSTR="SELECT top 1 * FROM tmpOrder(nolock)" DB_VAL="jfj" DB_SENDPHONE="13810450902" DB_ERRORMSG="客服中心数据库无法访问!"></DB_MSG>
 8</DB_CONFIG>
 9<WEB_CONFIG>
<!--地址，正则关键字，值-->
<!--如果没有制定正则，则默认获取MATE-->
<!--如果正则和MATE都为空，则直接获取网页内容-->
<!--当设定USEMETA为true，则执行Meta检查，否则不执行-->
<WEB_MSG WEB_NAME="网站首页"  WEB_URL="http://www.Example.com"  WEB_VAL="Exalple"  WEB_USEMATE="true" WEB_METANAME="ExamMeta" WEB_SENDPHONE="13811111111" WEB_ERRORMSG="网站首页出现问题"></WEB_MSG>
<WEB_MSG WEB_NAME="网站单品页"  WEB_URL="http://www.Example.com/ProductInfo/1111.html" WEB_VAL="单品" WEB_USEMETA="true" WEB_METANAME="Meta_A" WEB_SENDPHONE="13811111111" WEB_ERRORMSG="网站单品页出现问题!"></WEB_MSG>
</WEB_CONFIG>
<LOG_CONFIG>
<!--运行日志-->
<!--日志文件目录分级:根目录/年/月/日-->
<!--日志文件名：yyyyMMdd-->
<LOG_MSG LOG_PATH="D:/SMSLOG/"></LOG_MSG>
</LOG_CONFIG>
<TIME_CONFIG>
<!--定时器时间，毫秒为单位-->
<TIME_TICK TIME_COUNT="600000"></TIME_TICK>
</TIME_CONFIG>
<COM_NAME>
<!--发送串口名-->
<SEND_COM NAME="COM1"></SEND_COM>
</COM_NAME>
</CONFIG>

 检查类：

  1using System;
  2using System.Collections;
  3using System.Text;
  4using System.Data;
  5using System.Data.SqlClient;
  6using System.Net;
  7using System.Web;
  8using System.IO;
  9using System.Text.RegularExpressions;
 10using System.Configuration;
 11
 12namespace IDC_SECURITY
 13{
 14public class CHECK
 15{
 16public CHECK()
 17{
 18}
 19/**//// <summary>
 20/// 检查数据库
 21/// </summary>
 22/// <param name="dbmsg"></param>
 23public static void CheckAndLog(DB_MSG dbmsg)
 24{
 25//声明返回对象
 26CheckResults ChkRtn = new CheckResults();
 27ChkRtn.ChkName = dbmsg.Name;
 28ChkRtn.ChkTime = System.DateTime.Now;
 29ChkRtn.ChkType = MyConfig.CONFIGTYPE.DBCONFIG;
 30ChkRtn.ChkErrorMsg = dbmsg.ErrorMsg;
 31
 32string[] SendArray = dbmsg.SendList.Split('|');
 33ArrayList AL = new ArrayList();
 34foreach (string SendTo in SendArray)
 35{
 36AL.Add(SendTo);
 37}
 38ChkRtn.ChkList = AL;
 39//数据库检查
 40SqlConnection SqlConn = new SqlConnection(dbmsg.ConnStr);
 41SqlCommand SqlCmd = new SqlCommand();
 42SqlCmd.Connection = SqlConn;
 43SqlCmd.CommandType = CommandType.Text;
 44
 45//如果存在测试命令
 46if (dbmsg.CmdStr != "" && dbmsg.Val != "")
 47{
 48try
 49{
 50SqlCmd.CommandText = dbmsg.CmdStr;
 51SqlConn.Open();
 52string ChkVal = SqlCmd.ExecuteScalar().ToString();
 53if (ChkVal == dbmsg.Val)
 54{
 55ChkRtn.ChkResult = true;
 56}
 57else
 58{
 59ChkRtn.ChkResult = false;
 60}
 61}
 62catch
 63{
 64//如果发生异常，表明数据库出问题
 65ChkRtn.ChkResult = false;
 66}
 67}
 68else
 69{
 70//如过不存在数据库测试命令
 71try
 72{
 73SqlConn.Open();
 74SqlConn.Close();
 75ChkRtn.ChkResult = true;
 76}
 77catch
 78{
 79//数据库无法打开，表明数据库出问题
 80ChkRtn.ChkResult = false;
 81}
 82}
 83
 84LOG.WriteCheckResult(ChkRtn);
 85if (!ChkRtn.ChkResult)
 86{
 87string ComName = MyConfig.GetComName();
 88
 89foreach (object SendToObj in ChkRtn.ChkList)
 90{
 91SMS_SEND SMSObj = 
 92new SMS_SEND();
 93string SendResult = 
 94SMSObj.SendMsg(ChkRtn.ChkName + ":" + ChkRtn.ChkErrorMsg, SendToObj.ToString(), ComName);
 95LOG.WriteSmsOpLog(ChkRtn.ChkName + ":" + ChkRtn.ChkErrorMsg, SendResult);
 96}
 97}
 98}
 99/**//// <summary>
/// 检查WEB
/// </summary>
/// <param name="webmsg"></param>
/// <returns></returns>
public static void CheckAndLog(WEB_MSG webmsg)
{
//声明测试对象
CheckResults ChkRtn = new CheckResults();
ChkRtn.ChkName = webmsg.Name;
ChkRtn.ChkTime = System.DateTime.Now;
ChkRtn.ChkType = MyConfig.CONFIGTYPE.WEBCONFIG;
ChkRtn.ChkErrorMsg = webmsg.ErrorMsg;
//测试结果发送对象
ArrayList AL = new ArrayList();
string[] TArray = webmsg.SendList.Split('|');
foreach (string TA in TArray)
{
AL.Add(TA);
}
ChkRtn.ChkList = AL;

if (webmsg.UseMeta)
{
//如果测试目标为META
try
{
if (GetMeta(webmsg.MetaName, GetResponseBack(webmsg.Url)) == webmsg.Val)
{
ChkRtn.ChkResult = true;
}
else
{
ChkRtn.ChkResult = false;
}
}
catch
{
//如果访问出错，则网站出问题
ChkRtn.ChkResult = false;
}
}
else
{
//如果测试目标不是META
//则直接验证返回页面是否是制定值
try
{
string AllSrcCode = GetResponseBack(webmsg.Url);

if (AllSrcCode.Contains(webmsg.Val))
{
ChkRtn.ChkResult = true;
}
else
{
ChkRtn.ChkResult = false;
}
}
catch
{
ChkRtn.ChkResult = false;
}
}

LOG.WriteCheckResult(ChkRtn);
if (!ChkRtn.ChkResult)
{
string ComName = MyConfig.GetComName();

foreach (object SendToObj in ChkRtn.ChkList)
{
SMS_SEND SMSObj = new SMS_SEND();
string SendResult = 
SMSObj.SendMsg(ChkRtn.ChkName + ":" + ChkRtn.ChkErrorMsg, SendToObj.ToString(), ComName);
LOG.WriteSmsOpLog(ChkRtn.ChkName + ":" + ChkRtn.ChkErrorMsg, SendResult);
}
}
}

/**//// <summary>
/// 获取网络响应
/// </summary>
/// <param name="Uri"></param>
/// <returns></returns>
private static string GetResponseBack(string Uri)
{
try
{
HttpWebRequest myRequest = (HttpWebRequest)WebRequest.Create(Uri);
myRequest.Timeout = 3000;


HttpWebResponse myResponse = (HttpWebResponse)myRequest.GetResponse();

Stream Stm = myResponse.GetResponseStream();
StreamReader srd = new StreamReader(Stm);
string BackStr = srd.ReadToEnd();
srd.Close();
Stm.Close();
myResponse.Close();
                
return BackStr;
}
catch
{
return "Error";
}
}

/**//// <summary>
/// 获取响应数据中指定Meta的值
/// </summary>
/// <param name="MetaName"></param>
/// <param name="SrcStr"></param>
/// <returns></returns>
private static string GetMeta(string MetaName,string SrcStr)
{
string RegexStr = 
string.Format(@"<meta Name=\""{0}\"" content[\s]?=[\s\""\']+(.*?)[\""\']+.*?>", MetaName);
Regex MetaRegex = 
new Regex(RegexStr, RegexOptions.IgnoreCase);
Match Mc = 
MetaRegex.Match(SrcStr);
if (Mc != null)
{
return Mc.Groups[1].ToString();
}
else
{
return "";
}
}
}
}

 检查结果类：

 1using System;
 2using System.Collections;
 3using System.Text;
 4
 5namespace IDC_SECURITY
 6{
 7public class CheckResults
 8{
 9private MyConfig.CONFIGTYPE checktype;
private bool checkresult;
private DateTime checktime;
private string checkname;
private ArrayList checklist;
private string errormsg;

public CheckResults()
{
}
public CheckResults(
MyConfig.CONFIGTYPE Chk_Type, 
bool Chk_Result, DateTime Chk_Time, 
string Chk_Name,ArrayList Chk_List,
string Chk_ErrorMsg)
{
this.checktype = Chk_Type;
this.checkresult = Chk_Result;
this.checktime = Chk_Time;
this.checkname = Chk_Name;
this.checklist=Chk_List;
this.errormsg = Chk_ErrorMsg;
}
/**//// <summary>
/// 测试类型
/// </summary>
public MyConfig.CONFIGTYPE ChkType
{
set { this.checktype = value; }
get { return this.checktype; }
}
/**//// <summary>
/// 测试结果
/// </summary>
public bool ChkResult
{
set { this.checkresult = value; }
get { return this.checkresult; }
}
/**//// <summary>
/// 测试时间
/// </summary>
public DateTime ChkTime
{
set { this.checktime = value; }
get { return this.checktime; }
}
/**//// <summary>
/// 测试名称
/// </summary>
public string ChkName
{
set { this.checkname = value; }
get { return this.checkname; }
}
/**//// <summary>
/// 测试结果发送列表
/// </summary>
public ArrayList ChkList
{
set { this.checklist = value; }
get { return checklist; }
}
/**//// <summary>
/// 测试错误信息
/// </summary>
public string ChkErrorMsg
{
set { this.errormsg = value; }
get { return this.errormsg; }
}
}
}

 数据库信息：

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4
 5namespace IDC_SECURITY
 6{
 7/**//// <summary>
 8/// 数据库连接
 9/// </summary>
public class DB_MSG
{
public DB_MSG()
{
}
/**//// <summary>
/// 连接名
/// </summary>
private string DB_Name;
/**//// <summary>
/// 连接字符串
/// </summary>
private string DB_ConnStr;
/**//// <summary>
/// 测试命令
/// </summary>
private string DB_CmdStr;
/**//// <summary>
/// 测试值，与测试命令或者测试表名配套使用
/// </summary>
private string DB_Value;
/**//// <summary>
/// 手机短信发送目标列表，用|分割
/// </summary>
private string DB_SendList;
/**//// <summary>
/// 错误信息
/// </summary>
private string DB_ErrorMsg;
/**//// <summary>
/// 错误信息
/// </summary>
public string ErrorMsg
{
set { this.DB_ErrorMsg = value; }
get { return DB_ErrorMsg; }
}
/**//// <summary>
/// 连接名
/// </summary>
public string Name
{
set { DB_Name = value; }
get { return DB_Name; }
}
/**//// <summary>
/// 连接字符串
/// </summary>
public string ConnStr
{
set { DB_ConnStr = value; }
get { return DB_ConnStr; }
}
/**//// <summary>
/// 测试命令
/// </summary>
public string CmdStr
{
set { DB_CmdStr = value; }
get { return DB_CmdStr; }
}
/**//// <summary>
/// 测试值
/// </summary>
public string Val
{
set { DB_Value = value; }
get { return DB_Value; }
}
/**//// <summary>
/// 手机短信发送目标列表，用|分割
/// </summary>
public string SendList
{
set { DB_SendList = value; }
get { return DB_SendList; }
}
}
}

 WEB信息类:

  1using System;
  2using System.Collections;
  3using System.Text;
  4
  5namespace IDC_SECURITY
  6{
  7/**//// <summary>
  8/// 网站测试
  9/// </summary>
 10public class WEB_MSG
 11{
 12public WEB_MSG()
 13{
 14
 15}
 16/**//// <summary>
 17/// 测试名
 18/// </summary>
 19private string WEB_Name;
 20/**//// <summary>
 21/// 测试URL
 22/// </summary>
 23private string WEB_URL;
 24/**//// <summary>
 25/// 是否使用Meta
 26/// </summary>
 27private bool WEB_UseMeta;
 28/**//// <summary>
 29/// 测试Meta名
 30/// </summary>
 31private string WEB_MetaName;
 32/**//// <summary>
 33/// 测试错误信息
 34/// </summary>
 35private string WEB_ErrorMsg;
 36private string WEB_Value;
 37/**//// <summary>
 38/// 测试结果发送列表
 39/// </summary>
 40private string WEB_List;
 41
 42/**//// <summary>
 43/// 测试网站名
 44/// </summary>
 45public string Name
 46{
 47set { WEB_Name = value; }
 48get { return WEB_Name; }
 49}
 50/**//// <summary>
 51/// 测试URL
 52/// </summary>
 53public string Url
 54{
 55set { WEB_URL = value; }
 56get { return WEB_URL; }
 57}
 58/**//// <summary>
 59/// 是否使用Meta
 60/// </summary>
 61public bool UseMeta
 62{
 63set { WEB_UseMeta = value; }
 64get { return WEB_UseMeta; }
 65}
 66/**//// <summary>
 67/// 测试Meta名
 68/// </summary>
 69public string MetaName
 70{
 71set { this.WEB_MetaName = value; }
 72get { return WEB_MetaName; }
 73}
 74/**//// <summary>
 75/// 测试页面部分值
 76/// </summary>
 77public string Val
 78{
 79set { WEB_Value = value; }
 80get { return WEB_Value; }
 81}
 82/**//// <summary>
 83/// 测试错误信息
 84/// </summary>
 85public string ErrorMsg
 86{
 87set { this.WEB_ErrorMsg = value; }
 88get { return WEB_ErrorMsg; }
 89}
 90/**//// <summary>
 91/// 结果发送列表
 92/// </summary>
 93public string SendList
 94{
 95set { WEB_List = value; }
 96get { return WEB_List; }
 97}
 98}
 99}

 日志记录类:

 1using System;
 2using System.Collections.Generic;
 3using System.Text;
 4using System.IO;
 5
 6namespace IDC_SECURITY
 7{
 8public class LOG
 9{
private static DateTime HappenTime;

private static void CheckFileExist(CheckResults Chk)
{
HappenTime = Chk.ChkTime;
string RootPath = MyConfig.GetLogPath();
if (!Directory.Exists(RootPath + HappenTime.Year.ToString()))
{
Directory.CreateDirectory(RootPath + HappenTime.Year.ToString());
Directory.CreateDirectory(RootPath + HappenTime.Year.ToString() + 
"/" + HappenTime.Month.ToString());
}
else
{
if (!Directory.Exists(RootPath + HappenTime.Year.ToString() + 
"/" + HappenTime.Month.ToString()))
{
Directory.CreateDirectory(RootPath + HappenTime.Year.ToString() + 
"/" + HappenTime.Month.ToString());
}
}

if (!File.Exists(RootPath + HappenTime.Year.ToString() + 
"/" + HappenTime.Month.ToString() + "/" + 
HappenTime.ToString("yyyyMMdd") + ".txt"))
{
FileStream FS = 
File.Create(RootPath + HappenTime.Year.ToString() + 
"/" + HappenTime.Month.ToString() + "/" + 
HappenTime.ToString("yyyyMMdd") + ".txt");
FS.Close();
}
}
/**//// <summary>
/// 写入检查结果
/// </summary>
/// <param name="Chk"></param>
public static void WriteCheckResult(CheckResults Chk)
{
CheckFileExist(Chk);
StreamWriter SWT = 
new StreamWriter(
MyConfig.GetLogPath() + 
Chk.ChkTime.Year.ToString() + 
"/" + Chk.ChkTime.Month.ToString() + 
"/" + Chk.ChkTime.ToString("yyyyMMdd") + 
".txt", true, Encoding.UTF8);

SWT.WriteLine("[检查]");
SWT.WriteLine("[时间:" + Chk.ChkTime.ToString("yyyy年MM月dd日 hh:mm:ss") + "]");
SWT.WriteLine("[类型:" + Chk.ChkType.ToString() + "]");
SWT.WriteLine("[名称:" + Chk.ChkName + "]");
SWT.WriteLine("[结果:" + Chk.ChkResult.ToString() + "]");
SWT.WriteLine("\r\n");
SWT.Close();
}
/**//// <summary>
/// 记录短信发送信息
/// </summary>
/// <param name="LogContent"></param>
public static void WriteSmsOpLog(string LogContent, string SendResult)
{
StreamWriter SWT = 
new StreamWriter(MyConfig.GetLogPath() + 
DateTime.Now.Year.ToString() + "/" + 
DateTime.Now.Month.ToString() + "/" + 
DateTime.Now.ToString("yyyyMMdd") + 
".txt", true, Encoding.UTF8);

SWT.WriteLine("[短信]");
SWT.WriteLine("[时间:" + 
System.DateTime.Now.ToString("yyyy年MM月dd日 hh:mm:ss" + "]"));
SWT.WriteLine("[内容:" + LogContent + "]");
SWT.WriteLine("[结果:" + SendResult + "]");
SWT.WriteLine("\r\n");
SWT.Close();
}
}
}

 短信发送类:(不同设备,程序不同)

  1using System;
  2using System.Collections;
  3using System.ComponentModel;
  4using System.Data;
  5using System.Runtime.InteropServices;
  6using System.Text;
  7using System.Configuration;
  8
  9namespace IDC_SECURITY
 10{
 11public class SMS_SEND
 12{
 13基本配置与设置#region 基本配置与设置
 14const int SMS_BUF_TOTAL = 50;
 15const int SMS_FORMAT_PDU = 0;
 16
 17bool bRet = false, bSndSucc = false;
 18int iErrCode = -255, iTmp = 0;
 19/**//// <summary>
 20/// 版本信息
 21/// </summary>
 22StringBuilder strVerInfo = new StringBuilder(1024);
 23/**//// <summary>
 24/// 错误信息
 25/// </summary>
 26StringBuilder strErrInfo = new StringBuilder(1024);
 27/**//// <summary>
 28/// 短信中心
 29/// </summary>
 30StringBuilder strSCA = new StringBuilder(30);
 31/**//// <summary>
 32/// 待发短信
 33/// </summary>
 34StringBuilder strNeedSndMsg = new StringBuilder(512);
 35/**//// <summary>
 36/// 剩余短信
 37/// </summary>
 38StringBuilder strNextMsg = new StringBuilder(512);
 39/**//// <summary>
 40/// 目标号码
 41/// </summary>
 42StringBuilder strSndPhNbr = new StringBuilder(16);
 43
 44string strTmp;
 45/**//// <summary>
 46/// PDU 方式收发短信(中国大陆使用)
 47/// </summary>
 48int iSMSFormat = 0;
 49/**//// <summary>
 50/// 串口句柄
 51/// </summary>
 52IntPtr hComm;
 53/**//// <summary>
 54/// 串口设备信息
 55/// </summary>
 56STRUCommInfo CommInfo = new STRUCommInfo();
 57
 58private const UInt32 INVALID_HANDLE_VALUE = 0xffffffff;
 59
 60/**//// <summary>
 61/// Text模式(拉丁语系短信模式)
 62/// </summary>
 63const int SMS_FORMAT_TEXT = 1;
 64
 65[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
 66public struct SM_PARAM
 67{
 68/**//// <summary>
 69/// 短消息服务中心号码(SMSC地址)
 70/// </summary>
 71[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
 72public char[] SCA;
 73/**//// <summary>
 74/// 目标号码或回复号码(TP-DA或TP-RA)
 75/// </summary>
 76[MarshalAs(UnmanagedType.ByValArray, SizeConst = 30)]
 77public char[] TPA;
 78/**//// <summary>
 79/// 用户信息协议标识(TP-PID)
 80/// </summary>
 81public char TP_PID;
 82/**//// <summary>
 83/// 用户信息编码方式(TP-DCS)
 84/// </summary>
 85public char TP_DCS;
 86/**//// <summary>
 87/// 服务时间戳字符串(TP_SCTS), 接收时用到
 88/// </summary>
 89[MarshalAs(UnmanagedType.ByValArray, SizeConst = 16)]
 90public char[] TP_SCTS;
 91/**//// <summary>
 92/// 原始用户信息(编码前或解码后的TP-UD)
 93/// </summary>
 94[MarshalAs(UnmanagedType.ByValArray, SizeConst = 161)]
 95public char[] TP_UD;
 96/**//// <summary>
 97/// 短消息序号，在读取时用到
 98/// </summary>
 99public char index;
};

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct SM_RCV_STRU
{
public int iSmsTotal;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 50)]
public SM_PARAM[] SMS;
};

public struct STRUCommInfo
{
public int iBaudRate;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 30)]
public char[] szSCA;
};

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct SM_CPLUS_DETAIL
{

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 30)]
public char[] A;

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 30)]
public char[] B;

};

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct SM_CPLUS_STRU
{
public int iSmsTotal;

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 30)]
public byte[] szTest;

[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
public SM_CPLUS_DETAIL[] Detail;
};

[DllImport("SMSCom.dll")]
public static extern int iTest(ref SM_CPLUS_STRU SMS, StringBuilder szErrInfo);

[DllImport("SMSCom.dll")]
static extern void GetVerInfo(StringBuilder szRetVer);
[DllImport("SMSCom.dll")]
static extern int iSetSerialNo(string szCorp, string szInputSN);

[DllImport("SMSCom.dll")]
static extern IntPtr hOpenComm(string szPort);
[DllImport("SMSCom.dll")]
static extern bool bCloseComm(IntPtr hComm);

[DllImport("SMSCom.dll")]
static extern bool bAutoInit(IntPtr hCommm, 
ref STRUCommInfo CommInfo, int iSMSFormat, StringBuilder szErrInfo);
[DllImport("SMSCom.dll")]
static extern bool bSendMsg(IntPtr hComm, 
StringBuilder szMsg, StringBuilder szPhNbr, 
StringBuilder szSCA, StringBuilder szNextMsg, int iSMSFormat, StringBuilder szErrInfo);
[DllImport("SMSCom.dll")]
static extern int iRecvMsg(IntPtr hCommm, 
ref SM_RCV_STRU RcvSMS, int iSMSFormat, StringBuilder szErrInfo);

[DllImport("SMSCom.dll")]
static extern bool bSendWapPush(IntPtr hComm, 
StringBuilder szPhNbr, StringBuilder szWapTitle, 
StringBuilder szWapUrl, StringBuilder szErrInfo);

[DllImport("SMSCom.dll")]
static extern bool bClrSIM(IntPtr hComm, StringBuilder szErrInfo);
#endregion

public SMS_SEND()
{
StringBuilder szNeedSndMsg = new StringBuilder(1024);
StringBuilder szSndPhNbr = new StringBuilder(30);
StringBuilder szNextMsg = new StringBuilder(1024);
StringBuilder szRcvPh = new StringBuilder(30);
StringBuilder szRcvMsg = new StringBuilder(300);
StringBuilder szRcvDateTime = new StringBuilder(30);
}
/**//// <summary>
/// 打开串口
/// </summary>
/// <param name="ComName">串口名称</param>
/// <returns></returns>
private bool OpenComm(string ComName)
{
//正版授权注册 iErrCode=1 校验正确  iErrCode=-100 错误
iErrCode = iSetSerialNo("www.etoneinfo.com", "dfyhJjDkF");
//串口名称
strTmp = ComName;
//打开串口
hComm = hOpenComm(strTmp);

if (!hComm.Equals(null) && (hComm.ToInt32() != 0) && 
((UInt32)hComm != INVALID_HANDLE_VALUE))
{
//自动初始
bRet = bAutoInit(hComm, ref CommInfo, iSMSFormat, strErrInfo);

strTmp = new String(CommInfo.szSCA);
iTmp = strTmp.IndexOf('\0');
strSCA = new StringBuilder(strTmp, iTmp);

//打开成功
return true;
}
else
{
//打开失败
return false;
}
}
/**//// <summary>
/// 关闭串口
/// </summary>
/// <param name="ComName">串口名称</param>
/// <returns></returns>
private bool CloseComm(string ComName)
{
bRet = bCloseComm(hComm);
if (bRet)
{
//关闭成功
hComm = IntPtr.Zero;
return true;
}
else
{
//关闭失败
return false;
}
}
/**//// <summary>
/// 清空SIM卡
/// </summary>
/// <returns></returns>
private bool CLearSIM()
{
bRet = bClrSIM(hComm, strErrInfo);
if (bRet)
{
//清空成功
return true;
}
else
{
//清空失败
return false;
}
}
/**//// <summary>
/// 发送短信
/// </summary>
/// <param name="MsgContent">短信内容</param>
/// <param name="NumToSend">目标号码</param>
/// <param name="ComName">发送串口</param>
/// <returns></returns>
public string SendMsg(string MsgContent, string NumToSend, string ComName)
{
strNextMsg = new StringBuilder(512);
iTmp = strNextMsg.Length;
strSndPhNbr = new System.Text.StringBuilder(NumToSend);
strNeedSndMsg = new System.Text.StringBuilder(MsgContent);
OpenComm(ComName);
if (hComm.Equals(null) || (hComm.ToInt32() == 0) 
|| ((UInt32)hComm == INVALID_HANDLE_VALUE))
{
//串口打开失败
return "串口打开失败";
}
string SndResult = "";
while (strNeedSndMsg.Length > 0)
{
bSndSucc = false;
bRet = bSendMsg(hComm, strNeedSndMsg, strSndPhNbr, 
strSCA, strNextMsg, SMS_FORMAT_PDU, strErrInfo);
if (bRet == false) //发送失败
{
bSndSucc = false;
SndResult = "发送失败";
break;
}
else
{
if (strNextMsg.Length <= 0) //超长部分的待发内容
{
bSndSucc = true; //发送成功  
SndResult = "发送成功";
}
strNeedSndMsg = strNextMsg;
strNextMsg = new StringBuilder(512);
}
}

if (bSndSucc)
{
//发送成功
CloseComm(ComName);
return SndResult;
}
else
{
//发送失败
CloseComm(ComName);
return SndResult;
}
}
}
}