各种Helper代码

1、读取XML文件

 /// <summary>
     /// 读取XML配置文件类
     /// </summary>
     public class XmlHelper
     {
         private string strXmlPath = "";   //Xml文档路径
         private XmlDocument xmlDoc;   //XML文档

         /// <summary>
         /// 初始化ReadXml类
         /// </summary>
         /// <param name="XMLPath">XML文件路径</param>
         public XmlHelper(string XMLPath)
         {
             if (!System.IO.File.Exists(XMLPath))
             {

                 throw new Exception("没有找到指定的路径：" + XMLPath + "的XML文档");
             }

             strXmlPath = XMLPath;
             xmlDoc = new XmlDocument();
             xmlDoc.Load(XMLPath);
         }

         /// <summary>
         /// 读取XML文件指定键值的value值
         /// </summary>
         /// <param name="XMLNodePath">键值的路径,格式为(根节点/节点/子节点)</param>
         /// <param name="valueName">指定键值的属性名称</param>
         /// <returns>value值</returns>
         public string ReadXmlValue(string XMLNodePath,string valueName)
         {
            try
             {
                 XmlElement xml = (XmlElement)xmlDoc.SelectSingleNode(XMLNodePath);
                 return xml.GetAttribute(valueName);
             }
             catch (Exception ex)
             {
                throw new Exception(ex.Message);
             }
         }

         /// <summary>
         /// 写XML指定节点的
         /// </summary>
         /// <param name="XmlNodePath">键值路径，格式为((根节点/节点/子节点))</param>
         /// <param name="valueName">属性名称</param>
         /// <param name="Value">属性</param>
         /// <returns></returns>
         public bool WriteXmlValue(string XmlNodePath,string valueName, string Value)
         {
             try
             {
                 XmlElement xml = (XmlElement)xmlDoc.SelectSingleNode(XmlNodePath);
                 xml.SetAttribute(valueName, Value);   //设置
                 xmlDoc.Save(strXmlPath);     //保存
                 return true;
             }
             catch (Exception ex)
             {
                 throw new Exception(ex.Message);
             }
         }

         /// <summary>
         /// 读取XML键值
                 /// </summary>
         /// <param name="XmlNodePath">键值路径，格式为((根节点/节点/子节点))</param>
         /// <returns></returns>
         public string ReadXmlKey(string XmlNodePath)
         {
             try
             {
                 XmlElement xml = (XmlElement)xmlDoc.SelectSingleNode(XmlNodePath);
                 return xml.InnerText;
             }
             catch (Exception ex)
             {
                 throw new Exception(ex.Message);
             }
         }

         /// <summary>
         /// 写XML键值
                 /// </summary>
         /// <param name="XmlNodePath">键值路径，格式为((根节点/节点/子节点))</param>
         /// <param name="Value">值</param>
         /// <returns></returns>
         public bool WriteXmlKey(string XmlNodePath, string Value)
         {
             try
             {
                 XmlElement xml = (XmlElement)xmlDoc.SelectSingleNode(XmlNodePath);
                 xml.InnerText=Value;
                 xmlDoc.Save(strXmlPath);
                 return true;
             }
             catch (Exception ex)
             {
                 throw new Exception(ex.Message);
             }
         }
     }

  public static class XmlToEgg<T> where T : class
     {
         private static string path;
         private static T target;

         static XmlToEgg()
         {
         }
         /// <summary>
         /// Sets the xml path.
         /// </summary>
         public static void SetXmlPath(string p)
         {
             path = p;
         }
         /// <summary>
         /// Loads the XML Files.
         /// </summary>
         private static XElement LoadXML()
         {
             if(path == null)
                 return null;
             XElement xml = XElement.Load(path);
             return xml;
         }
         /// <summary>
         /// Creates the class initiate.
         /// </summary>
         private static void CreateInitiate()
         {
             Type t = typeof(T);
             ConstructorInfo ct = t.GetConstructor(System.Type.EmptyTypes);
             target = (T)ct.Invoke(null);
         }
         /// <summary>
         /// attribute assignment,
         /// 由于反射中设置字段值的方法会涉及到赋值的目标类型和当前类型的转化，
         /// 所以需要使用Convert.ChangeType进行类型转化
         /// </summary>
         public static T ToEgg()
         {
             if(target != null)
             {
                 target = null;
             }
             CreateInitiate();
             XElement xml = LoadXML();
             Type t = target.GetType();
             FieldInfo[] fields = t.GetFields();
             string fieldName = string.Empty;
             foreach(FieldInfo f in fields)
             {
                 fieldName = f.Name;
                 if(xml.Element(fieldName) != null)
                 {
                     f.SetValue(target, Convert.ChangeType(xml.Element(fieldName).Value, f.FieldType));
                 }
             }
             return target;
         }
     }

2、发送邮件

 public class EmailHelper
     {
         public MailMessage mailMessage(string fromAddress,string desemailuser, string toAddress, string emailSubject, string emailText)  //邮件的发送收者，支持群发，多个地址之间用 半角逗号 分开
         {
             MailMessage mm = new MailMessage();
             mm.To.Add("abc@qq.com");
             //mm.To.Add(toAddress);//暂时屏蔽
             ////抄送
               mm.CC.Add(new MailAddress("11@qq.com", "张三", Encoding.GetEncoding()));
             mm.CC.Add(new MailAddress("22@qq.com", "李四", Encoding.GetEncoding()));
             mm.CC.Add(new MailAddress("33@126.com", "王五", Encoding.GetEncoding()));
           //mm.Bcc.Add("44@qq.com,44@qq.com");

             mm.From = new MailAddress(fromAddress, desemailuser.Length>?desemailuser:fromAddress, Encoding.GetEncoding());
             mm.SubjectEncoding = Encoding.GetEncoding();//这里非常重要，如果你的邮件标题包含中文，这里一定要指定，否则对方收到的极有可能是乱码。
               mm.Subject = emailSubject; //邮件标题
               mm.IsBodyHtml = true; //邮件正文是否是HTML格式

               mm.BodyEncoding = Encoding.GetEncoding(); //邮件正文的编码， 设置不正确， 接收者会收到乱码
             //-------------------------------------------------------------------------
             emailText += "这是要正确发送的邮箱:" + toAddress;
             mm.Body = emailText;//邮件正文
               mm.Priority = MailPriority.High; //邮件的优先级，分为 Low, Normal, High，通常用 Normal即可
             //mm.Attachments.Add(new Attachment(@"d:a.doc",System.Net.Mime.MediaTypeNames.Application.Rtf));
             ////第二个参数，表示附件的文件类型，可以不用指定
             return mm;
         }

         public bool sendEmail(string fromemailaddress, string toemailaddress,string emailtitle,string emailcontent,string host,string port,string fromemailuser,string desemailuser,string fromemailpass)
         {
             bool b=false;
 string message=string.Empty;
             MailMessage mailessage =this.mailMessage(fromemailaddress,desemailuser,toemailaddress,emailtitle,emailcontent);
             SmtpClient smtp = new SmtpClient(); //实例化一个SmtpClient
             smtp.DeliveryMethod = SmtpDeliveryMethod.Network; //将smtp的出站方式设为 Network
             smtp.EnableSsl = false;//smtp服务器是否启用SSL加密
               smtp.Host = host; //指定 smtp 服务器地址
               smtp.Port = int.Parse(port);             //指定 smtp 服务器的端口，默认是25
             smtp.Credentials = new NetworkCredential(fromemailuser, fromemailpass);//认证
             try
             {
                 smtp.Send(mailessage);
                 b = True;
                 message= "发送成功!";
             }
             catch (System.Net.Mail.SmtpException ex)
             {
                 b = False;
                 message= "发送失败!";
             }
             return b;
         }

     }

3、数据库读取

oracle

 public class OraclHelper
     {

         public OleDbTransaction MyTransaction;
         public OleDbConnection MyConnection;
         public OleDbCommand MyCommand;
         //数据库连接关键字
         public readonly string strOledbCon;
         public OraclHelper()
         {
             //public static readonly string connString = ConfigurationManager.ConnectionStrings["Connection"].ConnectionString;
             //System.Configuration.ConfigurationManager.AppSettings["EmailFrom"]
             strOledbCon = System.Configuration.ConfigurationManager.AppSettings["DBConnectionString"];
             MyConnection = new OleDbConnection(strOledbCon);
         }
         public OraclHelper(string as_ConnectString)
         {
             strOledbCon = System.Configuration.ConfigurationManager.AppSettings[as_ConnectString];
             MyConnection = new OleDbConnection(strOledbCon);
         }

         /// <summary>
         /// 读取数据表
         /// </summary>
         /// <param name="as_sqlstr">sql语句</param>
         /// <returns></returns>
         public OleDbDataReader GetDR(string as_sqlstr)
         {
             as_sqlstr = ChangeSQLStatement(as_sqlstr);

             MyCommand = new OleDbCommand(as_sqlstr, MyConnection);

             MyCommand.CommandTimeout = ;

             MyConnection.Open();
             OleDbDataReader dr = MyCommand.ExecuteReader();
             return dr;
         }

         /// <summary>
         /// 获取数据视图
         /// </summary>
         /// <param name="as_sqlstr"></param>
         /// <returns></returns>
         public DataView GetDV(string as_sqlstr)
         {
             as_sqlstr = ChangeSQLStatement(as_sqlstr);

             OleDbDataAdapter MyDA = new OleDbDataAdapter(as_sqlstr, MyConnection);

             MyDA.SelectCommand.CommandTimeout = ;

             DataSet ds = new DataSet();
             MyDA.Fill(ds, "Result");
             DataView dv = ds.Tables["Result"].DefaultView;

             MyDA.SelectCommand.Connection.Close();

             return dv;
         }

         /// <summary>
         /// 获取数据表
         /// </summary>
         /// <param name="as_sqlstr"></param>
         /// <returns></returns>
         public DataTable GetDT(string as_sqlstr)
         {
             as_sqlstr = ChangeSQLStatement(as_sqlstr);

             OleDbDataAdapter MyDA = new OleDbDataAdapter(as_sqlstr, MyConnection);

             MyDA.SelectCommand.CommandTimeout = ;

             DataSet ds = new DataSet();
             MyDA.Fill(ds, "Result");
             DataTable dv = ds.Tables["Result"];

             MyDA.SelectCommand.Connection.Close();

             return dv;
         }

         /// <summary>
         /// 获取数据表集
         /// </summary>
         /// <param name="as_sqlstr"></param>
         /// <returns></returns>
         public DataSet GetDT(string as_sqlstr)
         {
             as_sqlstr = ChangeSQLStatement(as_sqlstr);

             OleDbDataAdapter MyDA = new OleDbDataAdapter(as_sqlstr, MyConnection);

             MyDA.SelectCommand.CommandTimeout = ;

             DataSet ds = new DataSet();
             MyDA.Fill(ds, "Result");

             MyDA.SelectCommand.Connection.Close();
             return ds;
         }

         /// <summary>
         /// 执行存储过程
         /// </summary>
         /// <param name="as_StoreProcedureName">存储过程名称</param>
         /// <param name="param">参数</param>
         /// <returns></returns>
         public bool ExecStoreProcedure(string as_StoreProcedureName, ref OleDbParameter[] param)
         {
             bool lbl_rtn;

             try
             {
                 MyCommand = new OleDbCommand(as_StoreProcedureName, MyConnection);
                 MyCommand.CommandType = CommandType.StoredProcedure;

                 if (param != null)
                 {
                     for (int i = ; i < param.Length; i++)
                     {
                         MyCommand.Parameters.Add(param[i]);
                     }
                 }

                 MyConnection.Open();

                 MyCommand.ExecuteNonQuery();

                 MyConnection.Close();

                 lbl_rtn = true;

             }
             catch (Exception ex)
             {
                 MyConnection.Close();
                 lbl_rtn = false;
             }

             return lbl_rtn;
         }

         /// <summary>
         /// 获得存储过程返回结果集
         /// </summary>
         /// <param name="as_StoreProcedureName">存储过程名称</param>
         /// <param name="inParam">参数</param>
         /// <returns></returns>
         public DataTable GetDTFromStoreProcedure(string as_StoreProcedureName, OleDbParameter[] inParam)
         {
             DataTable dt = new DataTable();

             try
             {
                 MyCommand = new OleDbCommand(as_StoreProcedureName, MyConnection);
                 MyCommand.CommandType = CommandType.StoredProcedure;

                 if (inParam != null)
                 {
                     for (int i = ; i < inParam.Length; i++)
                     {
                         MyCommand.Parameters.Add(inParam[i]);
                     }
                 }

                 OleDbDataAdapter MyDA = new OleDbDataAdapter(MyCommand);
                 MyDA.Fill(dt);
             }
             catch (Exception)
             {

             }

             return dt;
         }

         /// <summary>
         /// 事务
         /// </summary>
         /// <param name="as_sqlstr"></param>
         /// <param name="as_ErrMsg"></param>
         /// <returns></returns>
         public bool UpdateData(string as_sqlstr, ref string as_ErrMsg)
         {

             bool lbl_rtn;

             as_ErrMsg = "";

             as_sqlstr = ChangeSQLStatement(as_sqlstr);

             MyCommand = new OleDbCommand();
             MyCommand.Connection = MyConnection;
             MyCommand.Transaction = MyTransaction;

             try
             {
                 MyCommand.CommandText = as_sqlstr;
                 MyCommand.ExecuteNonQuery();
                 CommitData();
                 lbl_rtn = true;
             }
             catch (Exception ex)
             {
                 RollbackData();
                 lbl_rtn = false;
                 as_ErrMsg = ex.Message;

             }
             finally
             {
                 MyCommand.Dispose();
             }

             return lbl_rtn;
         }

         /// <summary>
         /// 关闭连接
         /// </summary>
         /// <param name="dr"></param
         public void CloseDR(OleDbDataReader dr)
         {
             dr.Close();
             MyConnection.Close();
         }

         public void OpenConnection()
         {
             MyConnection.Open();
         }

         public void StartTransaction()
         {
             MyTransaction = MyConnection.BeginTransaction(IsolationLevel.ReadCommitted);
         }

         /// <summary>
         /// 事务提交
         /// </summary>
         public void CommitData()
         {
             MyTransaction.Commit();
             MyConnection.Close();
         }

         /// <summary>
         /// 回滚数据
         /// </summary>
         public void RollbackData()
         {
             MyTransaction.Rollback();
             MyConnection.Close();
         }
         /// <summary>
         /// 字符替换
         /// </summary>
         /// <param name="as_sqlstr"></param>
         /// <returns></returns>
         public string ChangeSQLStatement(string as_sqlstr)
         {
             string ls_newSqlStr;

             ls_newSqlStr = as_sqlstr;

             if (strOledbCon.ToUpper().IndexOf("SQLOLEDB") >= )
             {
                 ls_newSqlStr = ls_newSqlStr.Replace("sysdate", "getdate()");
                 ls_newSqlStr = ls_newSqlStr.Replace("nvl(", "isnull(");
                 ls_newSqlStr = ls_newSqlStr.Replace("to_char(", "convert(varchar,");
                 ls_newSqlStr = ls_newSqlStr.Replace("to_date(", "convert(date,");
                 ls_newSqlStr = ls_newSqlStr.Replace("to_number(", "convert(numeric,");
                 ls_newSqlStr = ls_newSqlStr.Replace("substr(", "substring(");
                 ls_newSqlStr = ls_newSqlStr.Replace("||", "+");
                 ls_newSqlStr = ls_newSqlStr.Replace("length(", "len(");
                 ls_newSqlStr = ls_newSqlStr.Replace("rownum", "row_number() over(order by getdate())");
                 ls_newSqlStr = ls_newSqlStr.Replace(", 'yyyy-MM-dd'", "");
                 ls_newSqlStr = ls_newSqlStr.Replace(", 'yyyy-mm-dd'", "");
                 ls_newSqlStr = ls_newSqlStr.Replace(",'yyyy-MM-dd'", "");
                 ls_newSqlStr = ls_newSqlStr.Replace(",'yyyy-mm-dd'", "");
                 ls_newSqlStr = ls_newSqlStr.Replace("'HH24:mm:SS'", "");
                 ls_newSqlStr = ls_newSqlStr.Replace("lineno,", "\"lineno\",");
                 ls_newSqlStr = ls_newSqlStr.Replace("lineno=", "\"lineno\"=");
                 ls_newSqlStr = ls_newSqlStr.Replace(" lineno ", " \"lineno\" ");
             }

             return ls_newSqlStr;
         }
         /// <summary>
         /// 获得用户名
         /// </summary>
         /// <param name="as_staffcode"></param>
         /// <returns></returns>

         public string GetStaffName(string vip_id)
         {
             string ls_StaffName = "";

             OleDbDataReader dr = GetDR("Select staffname from staff where staffcode = '" + vip_id + "'");

             if (dr.Read())
             {
                 ls_StaffName = dr[].ToString();

                 CloseDR(dr);
                 return ls_StaffName;

             }
             else
             {
                 CloseDR(dr);
                 return ls_StaffName;
             }
         }
     }

4、缓存帮助类

 /// <summary>
     /// 服务器缓存帮助类
     /// </summary>
     public class CacheHelper
     {
         /// <summary>
         /// 创建缓存项的文件依赖
         /// </summary>
         /// <param name="key">缓存Key</param>
         /// <param name="obj">object对象</param>
         /// <param name="fileName">文件绝对路径</param>
         public static void InsertFile(string key, object obj, string fileName)
         {
             //创建缓存依赖项
             CacheDependency dep = new CacheDependency(fileName);
             //创建缓存
             HttpRuntime.Cache.Insert(key, obj, dep);
         }

         /// <summary>
         /// 创建缓存项过期
         /// </summary>
         /// <param name="key">缓存Key</param>
         /// <param name="obj">object对象</param>
         public static void Insert(string key, object obj)
         {
             if (obj != null)
             {
                 if (IsExist(key))
                 {
                     HttpRuntime.Cache[key] = obj;
                 }
                 else
                 {
                     int expires = ConvertHelper.ToInt(ConfigHelper.GetAppSettings("TimeCache"));
                     HttpRuntime.Cache.Insert(key, obj, null, System.Web.Caching.Cache.NoAbsoluteExpiration, new TimeSpan(, expires, ));
                 }

             }
         }
         /// <summary>
         /// 判断缓存对象是否存在
         /// </summary>
         /// <param name="strKey">缓存键值名称</param>
         /// <returns>是否存在true 、false</returns>
         public static bool IsExist(string strKey)
         {
             return HttpRuntime.Cache[strKey] != null;
         }
         /// <summary>
         /// 获取缓存对象
         /// </summary>
         /// <param name="key">缓存Key</param>
         /// <returns>object对象</returns>
         public static object GetCache(string key)
         {
             if (string.IsNullOrEmpty(key))
                 return null;
             if (ConfigHelper.GetAppSettings("IsCache") == "false")
             {
                 return null;
             }

             return HttpRuntime.Cache.Get(key);
         }

         /// <summary>
         /// 获取缓存对象
         /// </summary>
         /// <typeparam name="T">T对象</typeparam>
         /// <param name="key">缓存Key</param>
         /// <returns></returns>
         public static T Get<T>(string key)
         {
             object obj = GetCache(key);
             return obj == null ? default(T) : (T)obj;
         }

         /// <summary>
         /// 移除指定数据缓存
         /// </summary>
         public static void RemoveCache(string CacheKey)
         {
             System.Web.Caching.Cache _cache = HttpRuntime.Cache;
             _cache.Remove(CacheKey);
         }

         /// <summary>
         /// 移除全部缓存
         /// </summary>
         public static void RemoveAllCache()
         {
             System.Web.Caching.Cache _cache = HttpRuntime.Cache;
             IDictionaryEnumerator CacheEnum = _cache.GetEnumerator();
             while (CacheEnum.MoveNext())
             {
                 _cache.Remove(CacheEnum.Key.ToString());
             }
         }
     }