/// <summary>
/// 复制目录内所有文件到目标目录
/// </summary>
/// <param name="sourceDir">源目录</param>
/// <param name="targetDir">目标目录</param>
/// <param name="deleteExistingFile">是否删除已存在文件</param>
/// <param name="overWrite">覆盖目标文件</param>
/// <param name="deleteSourceFile">是否删除源文件</param>
public static void CopyDirectory(string sourceDir, string targetDir, bool deleteExistingFile = true, bool overWrite = false, bool deleteSourceFile = true)
{
var folderName = sourceDir.Substring(sourceDir.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase) + 1);
var desfolderdir = targetDir + "\\" + folderName;
if (targetDir.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase) == (targetDir.Length - 1))
{
desfolderdir = targetDir + folderName;
}
var fileNames = Directory.GetFileSystemEntries(sourceDir);
foreach (var sourceFileName in fileNames) // 遍历所有的文件和目录
{
if (Directory.Exists(sourceFileName)) // 先当作目录处理如果存在这个目录就递归Copy该目录下面的文件
{
var currentdir = desfolderdir + "\\" + sourceFileName.Substring(sourceFileName.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase) + 1);
if (!Directory.Exists(currentdir))
{
Directory.CreateDirectory(currentdir);
}
CopyDirectory(sourceFileName, desfolderdir);
}
else // 否则直接copy文件
{
var destFileName = sourceFileName.Substring(sourceFileName.LastIndexOf("\\", StringComparison.OrdinalIgnoreCase) + 1);
destFileName = desfolderdir + "\\" + destFileName;
if (File.Exists(destFileName))
{
if (deleteExistingFile)
{
File.Delete(destFileName); //Delete Existing Files
}
}
if (!Directory.Exists(desfolderdir))
{
Directory.CreateDirectory(desfolderdir);
}
try
{
File.Copy(sourceFileName, destFileName, overWrite);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
//if any error return
return;
}
if (deleteSourceFile)
{
File.Delete(sourceFileName);
}
}
}
}
/// <summary>
/// 从字符串中截取指定两个字符之间的字符
/// </summary>
/// <param name="source">源字符串</param>
/// <param name="start">开始字符(串)</param>
/// <param name="end">结束字符(串)</param>
/// <returns></returns>
public static string CutString(string source, string start, string end)
{
var result = string.Empty;
if (!string.IsNullOrEmpty(source) && source.Contains(start) && source.Contains(end))
{
int startIndex, endIndex;
try
{
startIndex = source.IndexOf(start);
if (startIndex == -1)
{
return(result);
}
var tmpstr = source.Substring(startIndex + start.Length);
endIndex = tmpstr.IndexOf(end);
if (endIndex == -1)
{
return(result);
}
result = tmpstr.Remove(endIndex);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
return(result);
}
/// <summary>
/// WriteText
/// </summary>
/// <param name="logPath">日志路径</param>
/// <param name="logContent">日志内容</param>
private static void WriteText(string logPath, string logContent)
{
try
{
//不存在就创建
if (!File.Exists(logPath))
{
var directoryName = Path.GetDirectoryName(logPath);
if (!string.IsNullOrWhiteSpace(directoryName))
{
if (!Directory.Exists(directoryName))
{
Directory.CreateDirectory(directoryName);
}
}
using (var fs = new FileStream(logPath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite))
{
//转字节和字节数组有性能损耗
//byte[] buffer = Encoding.Default.GetBytes(DateTime.Now.ToString(BaseSystemInfo.DateTimeLongFormat) + " " + Thread.CurrentThread.ManagedThreadId + " " + logContent);
//fs.Write(buffer, 0, buffer.Length);
using (var sw = new StreamWriter(fs))
{
sw.WriteLine(DateTime.Now.ToString(BaseSystemInfo.DateTimeLongFormat) + " " + Thread.CurrentThread.ManagedThreadId + " " + logContent);
sw.Flush();
sw.Dispose();
}
fs.Dispose();
}
}
else
{
using (var fs = new FileStream(logPath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite))
{
//转字节和字节数组有性能损耗
//byte[] buffer = Encoding.Default.GetBytes(DateTime.Now.ToString(BaseSystemInfo.DateTimeLongFormat) + " " + Thread.CurrentThread.ManagedThreadId + " " + logContent);
//fs.Write(buffer, 0, buffer.Length);
using (var sw = new StreamWriter(fs))
{
sw.WriteLine(DateTime.Now.ToString(BaseSystemInfo.DateTimeLongFormat) + " " + Thread.CurrentThread.ManagedThreadId + " " + logContent);
sw.Flush();
sw.Dispose();
}
fs.Dispose();
}
//using (var sw = new StreamWriter(logPath, true, Encoding.Default))
//{
// sw.WriteLine(DateTime.Now.ToString(BaseSystemInfo.DateTimeLongFormat) + " " + Thread.CurrentThread.ManagedThreadId + " " + logContent);
// sw.Flush();
// sw.Dispose();
//}
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
LogUtil.WriteLog("logPath:" + logPath + "logContent:" + logContent, "Exception");
}
}
/// <summary>
/// 批量修改节点值
/// </summary>
/// <param name="filePath">路径</param>
/// <param name="parameters">节点,值</param>
/// <param name="nameSpace">命名空间</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.BatchUpdateNodeValue(path, parameters, nameSpace)
************************************************/
public static void BatchUpdateNodeValue(string filePath, List <KeyValuePair <string, string> > parameters, string nameSpace = "")
{
if (!string.IsNullOrEmpty(filePath))
{
if (!filePath.Contains(@":\") && filePath.Contains(@"/"))
{
filePath = System.Web.HttpContext.Current.Server.MapPath(filePath);
}
try
{
var doc = new XmlDocument();
doc.Load(filePath);
if (parameters != null && parameters.Count > 0)
{
foreach (var parameter in parameters)
{
if (!string.IsNullOrEmpty(parameter.Key) && !string.IsNullOrEmpty(parameter.Value))
{
var node = parameter.Key;
var value = parameter.Value;
var xn = doc.SelectSingleNode(node);
if (!string.IsNullOrEmpty(nameSpace))
{
var xmlnam = new XmlNamespaceManager(doc.NameTable);
xmlnam.AddNamespace("a", nameSpace);
node = node.Replace("/", "/a:");
xn = doc.SelectSingleNode(node, xmlnam);
}
var xe = (XmlElement)xn;
if (xe != null)
{
xe.InnerText = value;
}
}
}
}
//最后一次性保存
//doc.Save(filePath);//空白标签会产生多余换行符
var settings = new XmlWriterSettings();
settings.Indent = true;
settings.ConformanceLevel = ConformanceLevel.Auto;
settings.IndentChars = "\t";
settings.OmitXmlDeclaration = false;
settings.Encoding = Encoding.UTF8;
using (var xmlWriter = XmlWriter.Create(filePath, settings))
{
doc.Save(xmlWriter);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
}
/// <summary>
/// 向sheet插入图片
/// </summary>
/// <param name="workbook">工作簿</param>
/// <param name="sheet">工作表</param>
/// <param name="filePath">文件路径</param>
/// <param name="row">第几行</param>
/// <param name="col">第几列</param>
/// <param name="suffix">后缀</param>
private static void AddPicture(XSSFWorkbook workbook, ISheet sheet, string filePath, int row, int col, string suffix)
{
try
{
if (!string.IsNullOrEmpty(filePath))
{
//转为本地路径
filePath = HttpContext.Current.Server.MapPath(filePath);
if (File.Exists(filePath))
{
var bytes = File.ReadAllBytes(filePath);
if (bytes.Length > 0)
{
var imagedId = 0;
var pictureType = new PictureType();
if (suffix.Equals("png", StringComparison.OrdinalIgnoreCase))
{
pictureType = PictureType.PNG;
}
else if (suffix.Equals("jpg", StringComparison.OrdinalIgnoreCase))
{
pictureType = PictureType.JPEG;
}
else
{
pictureType = PictureType.JPEG;
}
var patriarch = sheet.CreateDrawingPatriarch();
imagedId = workbook.AddPicture(bytes, pictureType);
//处理照片位置，【图片左上角为（col, row）第row+1行col+1列，右下角为（ col +1, row +1）第 col +1+1行row +1+1列，第三个参数为宽，第四个参数为高
var anchor = new XSSFClientAnchor(0, 0, 0, 0, col, row, col + 1, row + 1);
//dx1:图片左边相对excel格的位置(x偏移) 范围值为:0~1023;即输100 偏移的位置大概是相对于整个单元格的宽度的100除以1023大概是10分之一
//dy1:图片上方相对excel格的位置(y偏移) 范围值为:0~256 原理同上。
//dx2:图片右边相对excel格的位置(x偏移) 范围值为:0~1023; 原理同上。
//dy2:图片下方相对excel格的位置(y偏移) 范围值为:0~256 原理同上。
anchor.AnchorType = AnchorType.MoveDontResize;
//anchor.AnchorType = 3;
//load the picture and get the picture index in the workbook
var picture = (XSSFPicture)patriarch.CreatePicture(anchor, imagedId);
//Reset the image to the original size.
//picture.Resize(); //Note: Resize will reset client anchor you set. 这句话一定不要，这是用图片原始大小来显示
//picture.Resize(0.5);
picture.LineStyle = LineStyle.DashDotGel;
}
}
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
//此处采用跳过的方式
//throw ex;
}
}
/// <summary>
/// 缓存处理 Redis
/// </summary>
/// <param name="cacheKey">缓存的Key</param>
/// <param name="proc">处理函数</param>
/// <param name="isFromCache">是否从缓存读取</param>
/// <param name="refreshCache">是否强制刷新</param>
/// <param name="cacheTime"></param>
/// <returns></returns>
private static T RedisCache <T>(string cacheKey, Func <T> proc, bool isFromCache = true, bool refreshCache = false, TimeSpan cacheTime = default(TimeSpan))
{
if (cacheTime == default(TimeSpan))
{
cacheTime = TimeSpan.FromMilliseconds(30 * 1000);//设置默认缓存30秒
}
T result;
if (isFromCache)
{
//缓存
if (RedisUtil.Get <T>(cacheKey) != null) //判断是否有缓存
{
//已经缓存
if (refreshCache)//是否强制刷新缓存
{
//强制刷新
result = proc();
if (result != null)
{
RedisUtil.Set(cacheKey, result, cacheTime);
}
}
else
{
//不强制刷新
try
{
result = (T)RedisUtil.Get <T>(cacheKey);
}
catch (Exception ex)
{
result = proc();
LogUtil.WriteException(ex);
}
}
}
else
{
//未缓存
result = proc();
if (result != null)
{
RedisUtil.Set(cacheKey, result, cacheTime);
}
}
}
else
{
result = proc();
}
return(result);
}
/// <summary>
/// 移除缓存
/// </summary>
/// <param name="cacheKey"></param>
public static bool Remove(string cacheKey)
{
try
{
Cache.Remove(cacheKey);
return(true);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
return(false);
}
}
/// <summary>
/// JSON文本转对象,泛型方法
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="jsonText">JSON文本</param>
/// <returns>指定类型的对象</returns>
public static T JsonToObject <T>(string jsonText)
{
try
{
return(JsonConvert.DeserializeObject <T>(jsonText));
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
return(default(T));
//throw new Exception("jsonUtil.JsonToObject(): " + ex.Message);
}
}
/// <summary>
/// 修改数据
/// </summary>
/// <param name="filePath">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时修改该节点属性值，否则修改节点值</param>
/// <param name="value">值</param>
/// <param name="nameSpace">命名空间</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Insert(path, "/Node", "", "Value")
* XmlHelper.Insert(path, "/Node", "Attribute", "Value")
************************************************/
public static void Update(string filePath, string node, string attribute, string value, string nameSpace = "")
{
if (!string.IsNullOrEmpty(filePath))
{
if (!filePath.Contains(@":\") && filePath.Contains(@"/"))
{
filePath = System.Web.HttpContext.Current.Server.MapPath(filePath);
}
try
{
var doc = new XmlDocument();
doc.Load(filePath);
var xn = doc.SelectSingleNode(node);
if (!string.IsNullOrEmpty(nameSpace))
{
var xmlnam = new XmlNamespaceManager(doc.NameTable);
xmlnam.AddNamespace("a", nameSpace);
node = node.Replace("/", "/a:");
xn = doc.SelectSingleNode(node, xmlnam);
}
var xe = (XmlElement)xn;
if (xe != null)
{
if (string.IsNullOrEmpty(attribute))
{
xe.InnerText = value;
}
else
{
xe.SetAttribute(attribute, value);
}
//doc.Save(filePath);//空白标签会产生多余换行符
var settings = new XmlWriterSettings();
settings.Indent = true;
settings.ConformanceLevel = ConformanceLevel.Auto;
settings.IndentChars = "\t";
settings.OmitXmlDeclaration = false;
using (var xmlWriter = XmlWriter.Create(filePath, settings))
{
doc.Save(xmlWriter);
}
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
}
/// <summary>
/// 对象转JSON
/// </summary>
/// <param name="obj">对象</param>
/// <returns>JSON格式的字符串</returns>
public static string ObjectToJson(object obj)
{
try
{
var b = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(obj));
return(Encoding.UTF8.GetString(b));
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
return(string.Empty);
//throw new Exception("JsonUtil.ObjectToJson(): " + ex.Message);
}
}
/// <summary>
/// 内存缓存处理 微软
/// </summary>
/// <param name="cacheKey">缓存的Key</param>
/// <param name="proc">处理函数</param>
/// <param name="isFromCache">是否从缓存读取</param>
/// <param name="refreshCache">是否强制刷新</param>
/// <param name="cacheTime"></param>
/// <returns></returns>
private static T MemoryCache <T>(string cacheKey, Func <T> proc, bool isFromCache = true, bool refreshCache = false, TimeSpan cacheTime = default(TimeSpan))
{
T result;
if (isFromCache)
{
//缓存
if (MemoryUtil.Get(cacheKey) != null) //判断是否有缓存
{
//已经缓存
if (refreshCache)//是否强制刷新缓存
{
//强制刷新
result = proc();
if (result != null)
{
MemoryUtil.Set(cacheKey, result, cacheTime);
}
}
else
{
//不强制刷新
try
{
result = (T)MemoryUtil.Get(cacheKey);
}
catch (Exception ex)
{
result = proc();
LogUtil.WriteException(ex);
}
}
}
else
{
//未缓存
result = proc();
if (result != null)
{
MemoryUtil.Set(cacheKey, result, cacheTime);
}
}
}
else
{
result = proc();
}
return(result);
}
/// <summary>
/// 从Excel2003取数据并记录到List集合里
/// </summary>
/// <param name="cellHeader">单元头的Key和Value：{ { "UserName", "姓名" }, { "Age", "年龄" } };</param>
/// <param name="filePath">保存文件绝对路径</param>
/// <param name="errorMsg">错误信息</param>
/// <param name="startIndex">开始行索引（默认1）</param>
/// <returns>转换好的List对象集合</returns>
private static List <T> Excel2003ToEntityList <T>(Dictionary <string, string> cellHeader, string filePath, out StringBuilder errorMsg, int startIndex = 1) where T : new()
{
if (cellHeader is null)
{
throw new ArgumentNullException(nameof(cellHeader));
}
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentException($"'{nameof(filePath)}' cannot be null or empty.", nameof(filePath));
}
errorMsg = Pool.StringBuilder.Get(); // 错误信息,Excel转换到实体对象时，会有格式的错误信息
var ls = new List <T>(); // 转换后的集合
try
{
using (var fs = File.OpenRead(filePath))
{
var workbook = new HSSFWorkbook(fs);
var sheet = (HSSFSheet)workbook.GetSheetAt(0); // 获取此文件第一个Sheet页
for (var rowIndex = startIndex; rowIndex <= sheet.LastRowNum; rowIndex++)
{
// 1.判断当前行是否空行，若空行就不在进行读取下一行操作，结束Excel读取操作
var row = sheet.GetRow(rowIndex);
if (row == null)
{
break;
}
// 2.每一个Excel row转换为一个实体对象
var e = new T();
ExcelRowToEntity <T>(cellHeader, row, rowIndex, e, ref errorMsg);
ls.Add(e);
}
}
return(ls);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
throw ex;
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <param name="filePath">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时删除该节点属性值，否则删除节点值</param>
/// <param name="nameSpace">命名空间</param>
/// <returns></returns>
/**************************************************
* 使用示列:
* XmlHelper.Delete(path, "/Node", "")
* XmlHelper.Delete(path, "/Node", "Attribute")
************************************************/
public static void Delete(string filePath, string node, string attribute, string nameSpace = "")
{
if (!string.IsNullOrEmpty(filePath))
{
if (!filePath.Contains(@":\") && filePath.Contains(@"/"))
{
filePath = System.Web.HttpContext.Current.Server.MapPath(filePath);
}
try
{
var doc = new XmlDocument();
doc.Load(filePath);
var xn = doc.SelectSingleNode(node);
if (!string.IsNullOrEmpty(nameSpace))
{
var xmlnam = new XmlNamespaceManager(doc.NameTable);
xmlnam.AddNamespace("a", nameSpace);
node = node.Replace("/", "/a:");
xn = doc.SelectSingleNode(node, xmlnam);
}
var xe = (XmlElement)xn;
if (xn != null)
{
if (string.IsNullOrEmpty(attribute))
{
if (xn.ParentNode != null)
{
xn.ParentNode.RemoveChild(xn);
}
}
else
{
xe.RemoveAttribute(attribute);
}
doc.Save(filePath);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
}
/// <summary>
/// 获取域用户信息
/// </summary>
/// <param name="domainUserName"></param>
/// <returns></returns>
public static DomainUserInfo GetDomainUserInfo(string domainUserName)
{
try
{
if (string.IsNullOrEmpty(domainUserName))
{
return(null);
}
var userArr = domainUserName.Split('\\');
var domain = userArr[0];
var loginName = userArr[1];
var entry = new DirectoryEntry(string.Concat("LDAP://", domain));
var search = new DirectorySearcher(entry);
search.Filter = string.Format("(SAMAccountName={0})", loginName);
search.PropertiesToLoad.Add("SAMAccountName");
search.PropertiesToLoad.Add("givenName");
search.PropertiesToLoad.Add("cn");
search.PropertiesToLoad.Add("mail");
var result = search.FindOne();
if (result != null)
{
var info = new DomainUserInfo
{
SamAccountName = result.Properties["SAMAccountName"][0].ToString(),
GivenName = result.Properties["givenName"][0].ToString(),
Cn = result.Properties["cn"][0].ToString(),
Email = result.Properties["mail"][0].ToString()
};
return(info);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
return(null);
}
/// <summary>
/// 下载图片
/// </summary>
/// <param name="pictureUrl">图片Http地址</param>
/// <param name="filePath">保存路径</param>
/// <param name="folder">目录(前后不带/)</param>
/// <param name="fileName"></param>
/// <param name="fileExtension">文件后缀(以.开头)</param>
/// <param name="timeOut">Request最大请求时间，如果为-1则无限制</param>
/// <returns></returns>
public static bool DownloadPicture(string pictureUrl, out string filePath, string folder = "WeChat", string fileName = null, string fileExtension = ".png", int timeOut = -1)
{
if (string.IsNullOrEmpty(fileName))
{
fileName = DateTime.Now.ToString("yyyyMMddHHmmssffff");
}
filePath = AppDomain.CurrentDomain.BaseDirectory + "\\" + folder + "\\" + fileName + fileExtension;
//是否存在文件夹,没存在则创建
if (!Directory.Exists(AppDomain.CurrentDomain.BaseDirectory + "\\" + folder + "\\"))
{
Directory.CreateDirectory(AppDomain.CurrentDomain.BaseDirectory + "\\" + folder + "\\");
}
bool result = false;
WebResponse response = null;
Stream stream = null;
try
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(pictureUrl);
if (timeOut != -1)
{
request.Timeout = timeOut;
}
response = request.GetResponse();
stream = response.GetResponseStream();
if (!response.ContentType.ToLower().StartsWith("text/"))
{
result = SaveBinaryFile(response, filePath);
}
}
catch (Exception e)
{
LogUtil.WriteException(e);
}
finally
{
stream?.Close();
response?.Close();
}
return(result);
}
/// <summary>
/// 异步发送邮件 独立线程
/// </summary>
/// <param name="to">邮件接收人</param>
/// <param name="title">邮件标题</param>
/// <param name="body">邮件内容</param>
/// <param name="port">端口号</param>
/// <returns></returns>
public static void SendByThread(string to, string title, string body, int port = 25)
{
new Thread(new ThreadStart(delegate()
{
try
{
var smtp = new SmtpClient();
//邮箱的smtp地址
smtp.Host = BaseSystemInfo.MailServer;
//端口号
smtp.Port = port;
//构建发件人的身份凭据类
smtp.Credentials = new NetworkCredential(BaseSystemInfo.MailUserName, BaseSystemInfo.MailPassword);
//构建消息类
var objMailMessage = new MailMessage();
//设置优先级
objMailMessage.Priority = MailPriority.High;
//消息发送人
objMailMessage.From = new MailAddress(BaseSystemInfo.MailUserName, "登录提醒", Encoding.UTF8);
//收件人
objMailMessage.To.Add(to);
//标题
objMailMessage.Subject = title.Trim();
//标题字符编码
objMailMessage.SubjectEncoding = Encoding.UTF8;
//正文
objMailMessage.Body = body.Trim();
objMailMessage.IsBodyHtml = true;
//内容字符编码
objMailMessage.BodyEncoding = Encoding.UTF8;
//发送
smtp.Send(objMailMessage);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
})).Start();
}
/// <summary>
/// 从Excel取数据并记录到List集合里
/// </summary>
/// <param name="cellHeader">单元头的值和名称：{ { "UserName", "姓名" }, { "Age", "年龄" } };</param>
/// <param name="filePath">保存文件绝对路径</param>
/// <param name="errorMsg">错误信息</param>
/// <param name="startIndex">数据行开始序列，默认为1（即第二列，从0开始）</param>
/// <returns>转换后的List对象集合</returns>
public static List <T> ExcelToEntityList <T>(Dictionary <string, string> cellHeader, string filePath, out StringBuilder errorMsg, int startIndex = 1) where T : new()
{
var enlist = new List <T>();
errorMsg = Pool.StringBuilder.Get();
try
{
if (Regex.IsMatch(filePath, ".xls$")) // 2003
{
enlist = Excel2003ToEntityList <T>(cellHeader, filePath, out errorMsg, startIndex);
}
else if (Regex.IsMatch(filePath, ".xlsx$")) // 2007
{
enlist = Excel2007ToEntityList <T>(cellHeader, filePath, out errorMsg, startIndex);
}
return(enlist);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
throw ex;
}
}
/// <summary>
/// 读取数据
/// </summary>
/// <param name="filePath">路径</param>
/// <param name="node">节点</param>
/// <param name="attribute">属性名，非空时返回该属性值，否则返回串联值</param>
/// <param name="nameSpace">命名空间</param>
/// <returns>string</returns>
/**************************************************
* 使用示列:
* XmlHelper.Read(path, "/Node", "")
* XmlHelper.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
************************************************/
public static string Read(string filePath, string node, string attribute, string nameSpace = "", IFileProvider fileProvider)
{
var value = string.Empty;
if (!string.IsNullOrEmpty(filePath))
{
if (!filePath.Contains(@":\") && filePath.Contains(@"/"))
{
filePath = System.Web.HttpContext.Current.Server.MapPath(filePath);
}
try
{
var doc = new XmlDocument();
doc.Load(filePath);
var xn = doc.SelectSingleNode(node);
if (!string.IsNullOrEmpty(nameSpace))
{
var xmlnam = new XmlNamespaceManager(doc.NameTable);
xmlnam.AddNamespace("a", nameSpace);
node = node.Replace("/", "/a:");
xn = doc.SelectSingleNode(node, xmlnam);
}
if (xn != null)
{
if (xn.Attributes != null)
{
value = (string.IsNullOrEmpty(attribute) ? xn.InnerText : xn.Attributes[attribute].Value);
}
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
return(value);
}
/// <summary>
/// DES数据解密
/// 20140219 吉日嘎拉 就是出错了，也不能让程序崩溃
/// </summary>
/// <param name="targetValue"></param>
/// <param name="key"></param>
/// <returns></returns>
public static string DesDecrypt(string targetValue, string key)
{
if (string.IsNullOrEmpty(targetValue))
{
return(string.Empty);
}
// 定义DES加密对象
try
{
var des = new DESCryptoServiceProvider();
var len = targetValue.Length / 2;
var inputByteArray = new byte[len];
int x, i;
for (x = 0; x < len; x++)
{
i = Convert.ToInt32(targetValue.Substring(x * 2, 2), 16);
inputByteArray[x] = (byte)i;
}
// 通过两次哈希密码设置对称算法的初始化向量
des.Key = Encoding.ASCII.GetBytes(Sha1(Md5(key).Substring(0, 8)).Substring(0, 8));
// 通过两次哈希密码设置算法的机密密钥
des.IV = Encoding.ASCII.GetBytes(Sha1(Md5(key).Substring(0, 8)).Substring(0, 8));
// 定义内存流
var ms = new MemoryStream();
// 定义加密流
var cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
return(Encoding.Default.GetString(ms.ToArray()));
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
return(string.Empty);
}
/// <summary>
/// 执行查询
/// </summary>
/// <param name="commandText">sql查询</param>
/// <param name="dbParameters">参数集</param>
/// <param name="commandType">命令分类</param>
/// <returns>Object</returns>
public virtual object ExecuteScalar(string commandText, IDbDataParameter[] dbParameters, CommandType commandType)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
// 自动打开
MustCloseConnection = true;
if (DbConnection == null)
{
Open();
}
object result = null;
if (DbConnection.State == ConnectionState.Closed)
{
DbConnection.Open();
}
else if (DbConnection.State == ConnectionState.Broken)
{
DbConnection.Close();
DbConnection.Open();
}
using (DbCommand = DbConnection.CreateCommand())
{
try
{
#if (DEBUG)
Trace.WriteLine(DateTime.Now + " :DbConnection Start: " + DbConnection.Database + " ,ThreadId: " + Thread.CurrentThread.ManagedThreadId);
#endif
DbCommand.Connection = DbConnection;
DbCommand.CommandTimeout = DbConnection.ConnectionTimeout;
DbCommand.CommandText = commandText;
if (CurrentDbType == CurrentDbType.Oracle)
{
// 针对Oracle，全局替换换行符，避免报错或不执行
// 仅当前系统的换行符
DbCommand.CommandText = commandText.Replace(Environment.NewLine, " ");
// 各种平台的换行符
//_dbCommand.CommandText = commandText.Replace("r\n", " ").Replace('\n', ' ').Replace('\r', ' ');
}
DbCommand.CommandType = commandType;
if (_dbTransaction != null)
{
DbCommand.Transaction = _dbTransaction;
}
if (dbParameters != null)
{
DbCommand.Parameters.Clear();
for (var i = 0; i < dbParameters.Length; i++)
{
if (dbParameters[i] != null)
{
DbCommand.Parameters.Add(((ICloneable)dbParameters[i]).Clone());
// dbCommand.Parameters.Add(dbParameters[i]);
}
}
}
//写入日志
SqlUtil.WriteLog(commandText, commandType.ToString(), dbParameters);
if (DbConnection.State != ConnectionState.Open)
{
DbConnection.Open();
}
result = DbCommand.ExecuteScalar();
// 这里进行输出参数的处理
if (CurrentDbType == CurrentDbType.SqlServer)
{
SetBackParamValue(dbParameters);
}
}
catch (Exception e)
{
var sb = Pool.StringBuilder.Get();
sb.Append(commandText);
sb.Append(" ");
sb.Append(commandType.ToString());
if (dbParameters != null)
{
sb.Append(" dbParameters: ");
foreach (var parameter in dbParameters)
{
sb.Append(parameter.ParameterName + "=" + parameter.Value + " ");
}
}
LogUtil.WriteException(e, sb.Put());
}
finally
{
//自动关闭
if (MustCloseConnection)
{
Close();
}
else
{
DbCommand.Parameters.Clear();
}
}
stopwatch.Stop();
var statisticsText = $"Elapsed time: {stopwatch.Elapsed.TotalMilliseconds}ms";
SqlUtil.WriteLog(commandText, commandType.ToString(), dbParameters, statisticsText);
if (stopwatch.Elapsed.TotalMilliseconds >= BaseSystemInfo.SlowQueryMilliseconds)
{
var sb = Pool.StringBuilder.Get();
sb.Append(commandText);
sb.Append(" ");
sb.Append(commandType.ToString());
if (dbParameters != null)
{
sb.Append(" dbParameters: ");
foreach (var parameter in dbParameters)
{
sb.Append(parameter.ParameterName + "=" + parameter.Value + " ");
}
}
else
{
sb.Append(" ");
}
sb.Append(statisticsText);
LogUtil.WriteLog(sb.Put(), "Slow.DbHelper.ExecuteScalar");
}
}
return(result);
}
/// <summary>
/// 利用Net SqlBulkCopy 批量导入数据库,速度超快
/// </summary>
/// <param name="dt">源内存数据表（先通过SELECT TOP 0获取空白DataTable）</param>
/// <param name="destinationTableName">目标表名称</param>
/// <param name="bulkCopyTimeout">超时限制（毫秒）</param>
/// <param name="batchSize">批大小（默认0，即一次性导入）</param>
public override bool SqlBulkCopyData(DataTable dt, string destinationTableName, int bulkCopyTimeout = 1000, int batchSize = 0)
{
var result = false;
var stopwatch = new Stopwatch();
stopwatch.Start();
if (string.IsNullOrEmpty(destinationTableName))
{
destinationTableName = dt.TableName;
}
// SQL 数据连接
SqlConnection sqlConnection = null;
// 打开数据库
Open();
// 获取连接
sqlConnection = (SqlConnection)GetDbConnection();
using (var tran = sqlConnection.BeginTransaction())
{
// 批量保存数据，只能用于Sql
var sqlBulkCopy = new SqlBulkCopy(sqlConnection, SqlBulkCopyOptions.Default, tran);
sqlBulkCopy.BatchSize = batchSize;
// 设置目标表名称
sqlBulkCopy.DestinationTableName = destinationTableName;
// 设置超时限制
sqlBulkCopy.BulkCopyTimeout = bulkCopyTimeout;
foreach (DataColumn dtColumn in dt.Columns)
{
sqlBulkCopy.ColumnMappings.Add(dtColumn.ColumnName, dtColumn.ColumnName);
}
try
{
// 写入
sqlBulkCopy.WriteToServer(dt);
// 提交事务
tran.Commit();
result = true;
}
catch (Exception ex)
{
tran.Rollback();
sqlBulkCopy.Close();
LogUtil.WriteException(ex);
}
finally
{
sqlBulkCopy.Close();
Close();
}
}
stopwatch.Stop();
var statisticsText = $"Elapsed time: {stopwatch.Elapsed.TotalMilliseconds}ms";
SqlUtil.WriteLog(destinationTableName, "SqlBulkCopy", null, statisticsText);
if (stopwatch.Elapsed.TotalMilliseconds >= BaseSystemInfo.SlowQueryMilliseconds)
{
var sb = Pool.StringBuilder.Get();
sb.Append("SqlBulkCopy to Table " + destinationTableName + " , " + statisticsText);
LogUtil.WriteLog(sb.Put(), "Slow.DbHelper.SqlBulkCopy");
}
return(result);
}
/// <summary>
/// 导出高版本Excel格式文件(NPOI组件方式)
/// </summary>
/// <param name="dt">数据表</param>
/// <param name="fieldList">数据表字段名-说明对应列表</param>
/// <param name="fileName">文件名</param>
/// <param name="exportPicture">是否导出图片</param>
public static void ExportXlsxByNpoi(DataTable dt, Dictionary <string, string> fieldList, string fileName, bool exportPicture = false)
{
var fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
var ms = new MemoryStream();
//创建工作簿
var workbook = new XSSFWorkbook();
//创建表
var sheet = workbook.CreateSheet("Sheet1");
//创建表头
var headerRow = sheet.CreateRow(0);
// 写出表头
if (fieldList == null)
{
for (var i = 0; i < dt.Columns.Count; i++)
{
//增加了try Catch，解决字典fieldList中没有table列中项时，会出错。
//此处采用跳过的方式,表现方式是此列的表头没值
try
{
headerRow.CreateCell(i).SetCellValue(dt.Columns[i].ColumnName);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
continue;
}
}
}
else
{
var j = 0;
foreach (var field in fieldList)
{
try
{
headerRow.CreateCell(j).SetCellValue(field.Value);
j++;
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
continue;
}
}
}
// 行索引号
var rowIndex = 1;
var hasPicture = false;
// 写出数据
foreach (DataRow dtRow in dt.Rows)
{
var dataRow = sheet.CreateRow(rowIndex);
if (fieldList == null)
{
for (var i = 0; i < dt.Columns.Count; i++)
{
try
{
switch (dt.Columns[i].DataType.ToString())
{
case "System.String":
default:
//获取后缀名
var filePath = Convert.ToString(Convert.IsDBNull(dtRow[i]) ? "" : dtRow[i]);
var suffix = filePath.Substring(
filePath.LastIndexOf('.') + 1,
filePath.Length - filePath.LastIndexOf('.') - 1
);
hasPicture = false;
if (exportPicture &&
(suffix.Equals("jpg", StringComparison.OrdinalIgnoreCase) || suffix.Equals("bmp", StringComparison.OrdinalIgnoreCase) || suffix.Equals("jpeg", StringComparison.OrdinalIgnoreCase) || suffix.Equals("gif", StringComparison.OrdinalIgnoreCase) ||
suffix.Equals("png", StringComparison.OrdinalIgnoreCase)))
{
hasPicture = true;
//正方形的例子50*20 x 10*256
dataRow.Height = 100 * 20;
sheet.SetColumnWidth(i, 20 * 256);
AddPicture(workbook, sheet, filePath, rowIndex, i, suffix);
}
else
{
dataRow.CreateCell(i).SetCellValue(
Convert.ToString(Convert.IsDBNull(dtRow[i]) ? "" : dtRow[i])
);
}
break;
case "System.DateTime":
dataRow.CreateCell(i).SetCellValue(
Convert.ToString(Convert.IsDBNull(dtRow[i])
? ""
: DateTime.Parse(dtRow[i].ToString())
.ToString(BaseSystemInfo.DateTimeFormat)));
break;
case "System.Int16":
case "System.Int32":
case "System.Int64":
case "System.Decimal":
case "System.Double":
dataRow.CreateCell(i).SetCellValue(
Convert.ToDouble(Convert.IsDBNull(dtRow[i]) ? 0 : dtRow[i])
);
break;
}
//列宽自适应会造成导出图片出问题
if (exportPicture && hasPicture && sheet.GetColumnWidth(i) != 20 * 256)
{
sheet.AutoSizeColumn(i);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
continue;
}
}
}
else
{
var i = 0;
foreach (var field in fieldList)
//for (int i = 0; i < dt.Columns.Count; i++)
{
try
{
switch (dt.Columns[field.Key].DataType.ToString())
{
case "System.String":
default:
//获取后缀名
var filePath = Convert.ToString(Convert.IsDBNull(dtRow[field.Key]) ? "" : dtRow[field.Key]);
var suffix = filePath.Substring(
filePath.LastIndexOf('.') + 1,
filePath.Length - filePath.LastIndexOf('.') - 1
);
hasPicture = false;
if (exportPicture && (suffix.Equals("jpg", StringComparison.OrdinalIgnoreCase) || suffix.Equals("bmp", StringComparison.OrdinalIgnoreCase) || suffix.Equals("jpeg", StringComparison.OrdinalIgnoreCase) || suffix.Equals("gif", StringComparison.OrdinalIgnoreCase) || suffix.Equals("png", StringComparison.OrdinalIgnoreCase)))
{
hasPicture = true;
//正方形的例子50*20 x 10*256
dataRow.Height = 100 * 20;
sheet.SetColumnWidth(i, 20 * 256);
AddPicture(workbook, sheet, filePath, rowIndex, i, suffix);
//sheet.GetColumnWidth(i);
}
else
{
dataRow.CreateCell(i).SetCellValue(
Convert.ToString(Convert.IsDBNull(dtRow[field.Key]) ? "" : dtRow[field.Key])
);
}
break;
case "System.DateTime":
dataRow.CreateCell(i).SetCellValue(
Convert.ToString(Convert.IsDBNull(dtRow[field.Key]) ? "" : DateTime.Parse(dtRow[field.Key].ToString()).ToString(BaseSystemInfo.DateTimeFormat)));
break;
case "System.Int16":
case "System.Int32":
case "System.Int64":
case "System.Decimal":
case "System.Double":
dataRow.CreateCell(i).SetCellValue(
Convert.ToDouble(Convert.IsDBNull(dtRow[field.Key]) ? 0 : dtRow[field.Key])
);
break;
}
//列宽自适应会造成导出图片出问题
if (exportPicture && hasPicture && sheet.GetColumnWidth(i) != 20 * 256)
{
sheet.AutoSizeColumn(i);
}
i++;
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
continue;
}
}
}
rowIndex++;
}
workbook.Write(ms);
var data = ms.ToArray();
ms.Flush();
ms.Close();
fs.Write(data, 0, data.Length);
fs.Flush();
fs.Close();
}
/// <summary>
/// Excel row转换为实体对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="cellHeader">单元头的Key和Value：{ { "UserName", "姓名" }, { "Age", "年龄" } };</param>
/// <param name="row">Excel row</param>
/// <param name="rowIndex">row index</param>
/// <param name="t">实体</param>
/// <param name="errorMsg">错误信息</param>
private static void ExcelRowToEntity <T>(Dictionary <string, string> cellHeader, IRow row, int rowIndex, T t, ref StringBuilder errorMsg)
{
var keys = cellHeader.Keys.ToList(); // 要赋值的实体对象属性名称
var errStr = ""; // 当前行转换时，是否有错误信息，格式为：第1行数据转换异常：XXX列；
for (var i = 0; i < keys.Count; i++)
{
// 1.若属性头的名称包含'.',就表示是子类里的属性，那么就要遍历子类，eg：UserEn.TrueName
if (keys[i].IndexOf(".", StringComparison.Ordinal) >= 0)
{
// 1)解析子类属性
var propertyArray = keys[i].Split(new string[] { "." }, StringSplitOptions.RemoveEmptyEntries);
var subClassName = propertyArray[0]; // '.'前面的为子类的名称
var subClassPropertyName = propertyArray[1]; // '.'后面的为子类的属性名称
var subClassInfo = t.GetType().GetProperty(subClassName); // 获取子类的类型
if (subClassInfo != null)
{
// 2)获取子类的实例
var subClassEn = t.GetType().GetProperty(subClassName)?.GetValue(t, null);
// 3)根据属性名称获取子类里的属性信息
var propertyInfo = subClassInfo.PropertyType.GetProperty(subClassPropertyName);
if (propertyInfo != null)
{
try
{
// Excel单元格的值转换为对象属性的值，若类型不对，记录出错信息
propertyInfo.SetValue(subClassEn, GetExcelCellToProperty(propertyInfo.PropertyType, row.GetCell(i)), null);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
if (errStr.Length == 0)
{
errStr = "第" + rowIndex + "行数据转换异常：";
}
errStr += cellHeader[keys[i]] + "列；";
}
}
}
}
else
{
// 2.给指定的属性赋值
var propertyInfo = t.GetType().GetProperty(keys[i]);
if (propertyInfo != null)
{
try
{
// Excel单元格的值转换为对象属性的值，若类型不对，记录出错信息
propertyInfo.SetValue(t, GetExcelCellToProperty(propertyInfo.PropertyType, row.GetCell(i)), null);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
if (errStr.Length == 0)
{
errStr = "第" + rowIndex + "行数据转换异常：";
}
errStr += cellHeader[keys[i]] + "列；";
}
}
}
}
// 若有错误信息，就添加到错误信息里
if (errStr.Length > 0)
{
errorMsg.AppendLine(errStr);
}
}
/// <summary>
/// 通过DataTable获得CSV格式数据
/// </summary>
/// <param name="dt">数据表</param>
/// <param name="fieldList">字段列表字典(字段,描述)</param>
/// <param name="separator">分隔符</param>
/// <returns>CSV字符串数据</returns>
private static StringBuilder GetCsvFormatData(DataTable dt, Dictionary <string, string> fieldList = null, string separator = ",")
{
var sb = Pool.StringBuilder.Get();
#region 检查字段列表
if (dt != null && fieldList != null)
{
var keys = fieldList.Keys.ToArray();
for (var i = 0; i < keys.Length; i++)
{
var hasColumnName = false;
foreach (DataColumn dc in dt.Columns)
{
if (dc.ColumnName.Equals(keys[i], StringComparison.OrdinalIgnoreCase))
{
hasColumnName = true;
break;
}
}
if (!hasColumnName)
{
//表内不存在此字段，就不要输出这个列了
fieldList.Remove(keys[i]);
}
}
}
#endregion
#region 生成dt新表
if (dt != null && fieldList != null && fieldList.Count > 0)
{
//对DataTable筛选指定字段，并保存为新表
//这些列名，确保DataTable中存在，否则会报错误
var dtNew = dt.DefaultView.ToTable(false, fieldList.Keys.ToArray());
dt = new DataTable();
dt = dtNew.Copy();
}
#endregion
#region 写出表头
if (dt != null)
{
foreach (DataColumn dc in dt.Columns)
{
if (sb.Length > 0 && (fieldList == null || (fieldList != null && fieldList.ContainsKey(dc.ColumnName))))
{
sb.Append(separator);
}
if (fieldList == null || fieldList?.Count == 0)
{
WriteSpecialCharacter(dc.ColumnName, sb, separator);
}
else
{
if (fieldList.ContainsKey(dc.ColumnName))
{
WriteSpecialCharacter(dc.ColumnName, sb, separator);
}
}
}
if (dt.Rows.Count > 0)
{
sb.Append("\n");
}
}
#endregion
#region 写出数据
if (dt != null && dt.Rows.Count > 0)
{
var c = 1;
foreach (DataRowView drv in dt.DefaultView)
{
var i = 1;
//var j = 1;
try
{
foreach (DataColumn dc in dt.Columns)
{
//j++;
if (fieldList == null || fieldList?.Count == 0)
{
WriteSpecialCharacter(drv[dc.ColumnName]?.ToString(), sb, separator);
if (i < dt.Columns.Count)
{
sb.Append(separator);
}
i++;
//LogUtil.WriteLog(j + "," + i + "," + dt.Columns.Count + "," + fieldList?.Count + "," + dc.ColumnName + ":" + drv[dc.ColumnName]?.ToString());
}
else
{
if (fieldList.ContainsKey(dc.ColumnName))
{
i++;
WriteSpecialCharacter(drv[dc.ColumnName]?.ToString(), sb, separator);
if (i < fieldList.Count)
{
sb.Append(separator);
}
}
//LogUtil.WriteLog(j + "," + i + "," + dt.Columns.Count + "," + fieldList?.Count + ":" + drv[dc.ColumnName]?.ToString());
}
}
//最后一行不需要输出换行符
if (c < dt.Rows.Count)
{
sb.Append("\n");
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
continue;
}
finally
{
c++;
}
}
}
#endregion
return(sb);
}
/// <summary>
/// 同步发送邮件
/// </summary>
/// <param name="to">收件人邮箱地址（多个用英文,或;分割）</param>
/// <param name="subject">主题</param>
/// <param name="body">内容</param>
/// <param name="attachmentPaths">附件路径</param>
/// <param name="encoding">编码</param>
/// <param name="isBodyHtml">是否Html</param>
/// <returns>是否成功</returns>
public static bool Send(string to, string subject, string body, string attachmentPaths = null, string encoding = "UTF-8", bool isBodyHtml = true)
{
var result = false;
if (!string.IsNullOrEmpty(to))
{
try
{
if (BaseSystemInfo.MailServerSslEnabled && BaseSystemInfo.MailServerPort == 465)
{
#if NET40_OR_GREATER
var message = new System.Web.Mail.MailMessage();
//接收人邮箱地址
message.To = to;
if (!string.IsNullOrEmpty(BaseSystemInfo.MailBcc))
{
message.Bcc = BaseSystemInfo.MailBcc;
}
if (!string.IsNullOrEmpty(BaseSystemInfo.MailFrom))
{
message.From = BaseSystemInfo.MailFrom;
}
//在有附件的情况下添加附件
if (!string.IsNullOrEmpty(attachmentPaths))
{
message.Attachments.Clear();
try
{
string[] attachPath = attachmentPaths.Split(';');
System.Web.Mail.MailAttachment attachFile = null;
foreach (string path in attachPath)
{
//string extName = Path.GetExtension(path).ToLower(); //获取扩展名
//FileStream fs = new FileStream(HostingEnvironment.MapPath("/") + pathFileName, FileMode.Open, FileAccess.Read);
////将附件添加到mailmessage对象
//attachment = new Attachment(fs, dictionary[i]);
attachFile = new System.Web.Mail.MailAttachment(path);
message.Attachments.Add(attachFile);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
message.BodyEncoding = Encoding.GetEncoding(encoding);
message.Body = body;
message.Subject = subject;
if (isBodyHtml)
{
message.BodyFormat = System.Web.Mail.MailFormat.Html;
}
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpauthenticate", "1");
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendusername", BaseSystemInfo.MailUserName);
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/sendpassword", BaseSystemInfo.MailPassword);
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpserverport", BaseSystemInfo.MailServerPort);//端口
message.Fields.Add("http://schemas.microsoft.com/cdo/configuration/smtpusessl", BaseSystemInfo.MailServerSslEnabled);
System.Web.Mail.SmtpMail.SmtpServer = BaseSystemInfo.MailServer;
System.Web.Mail.SmtpMail.Send(message);
#endif
}
else
{
var message = new MailMessage();
//接收人邮箱地址
if (!to.Contains(",") && !to.Contains(";"))
{
message.To.Add(new MailAddress(to));
}
else if (!string.IsNullOrWhiteSpace(to))
{
string[] tos = null;
if (to.Contains(","))
{
tos = to.Split(",".ToCharArray());
}
else if (to.Contains(";"))
{
tos = to.Split(";".ToCharArray());
}
foreach (var t in tos)
{
message.To.Add(new MailAddress(t));
}
}
if (!string.IsNullOrEmpty(BaseSystemInfo.MailBcc))
{
message.Bcc.Add(new MailAddress(BaseSystemInfo.MailBcc));
}
if (!string.IsNullOrEmpty(BaseSystemInfo.MailFrom))
{
message.From = new MailAddress(BaseSystemInfo.MailFrom);
}
//在有附件的情况下添加附件
if (!string.IsNullOrEmpty(attachmentPaths))
{
message.Attachments.Clear();
try
{
string[] attachPath = attachmentPaths.Split(';');
Attachment attachFile = null;
foreach (string path in attachPath)
{
//string extName = Path.GetExtension(path).ToLower(); //获取扩展名
//FileStream fs = new FileStream(HostingEnvironment.MapPath("/") + pathFileName, FileMode.Open, FileAccess.Read);
////将附件添加到mailmessage对象
//attachment = new Attachment(fs, dictionary[i]);
attachFile = new Attachment(path);
message.Attachments.Add(attachFile);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
message.BodyEncoding = Encoding.GetEncoding(encoding);
message.Body = body;
message.SubjectEncoding = Encoding.GetEncoding(encoding);
message.Subject = subject;
message.IsBodyHtml = isBodyHtml;
var smtpClient = new SmtpClient(BaseSystemInfo.MailServer, BaseSystemInfo.MailServerPort)
{
Credentials = new NetworkCredential(BaseSystemInfo.MailUserName, BaseSystemInfo.MailPassword),
//SSL设置
EnableSsl = BaseSystemInfo.MailServerSslEnabled
};
smtpClient.Send(message);
}
result = true;
}
#if NET40_OR_GREATER
catch (System.Web.HttpException ex)
{
LogUtil.WriteException(ex);
}
#endif
catch (SmtpException ex)
{
LogUtil.WriteException(ex);
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
}
return(result);
}
/// <summary>
/// 保存接口返回二进制流为文件方法
/// </summary>
/// <param name="requestUri">接口地址</param>
/// <param name="jsonString">json数据对象</param>
/// <returns></returns>
public static string DownloadBufferImage(string requestUri, string jsonString)
{
var result = string.Empty;
try
{
HttpContent httpContent = new StringContent(jsonString);
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
//注意大量并发的时候不能释放资源的问题
using (var httpClient = new HttpClient())
{
//停止使用using，使用HttpClientFactory
//var httpClient = HttpClientFactory2.GetHttpClient();
httpClient.PostAsync(requestUri, httpContent).ContinueWith(
(requestTask) =>
{
var response = requestTask.Result;
response.EnsureSuccessStatusCode();
var contentType = response.Content.Headers.ContentType;
if (string.IsNullOrEmpty(contentType.CharSet))
{
contentType.CharSet = "utf-8";
}
LogUtil.WriteLog(response.Content.ReadAsByteArrayAsync().Result.LongLength.ToString(), "QRCode");
var data = response.Content.ReadAsByteArrayAsync().Result;
var fileName = string.Empty;
//会出现113个字节的内容，所以放大十倍
if (data.Length > 1130)
{
fileName = Guid.NewGuid().ToString("D") + ".jpg";
var filePath = string.Format(@"{0}\QRCode\" + fileName, AppDomain.CurrentDomain.BaseDirectory);
var folder = Path.GetDirectoryName(filePath);
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
using (var fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
{
fs.Write(data, 0, data.Length);
fs.Flush();
fs.Close();
}
result = "/QRCode/" + fileName;
}
else
{
LogUtil.WriteLog(Encoding.Default.GetString(data), "QRCode");
}
}).Wait(5000);
}
}
catch (Exception ex)
{
LogUtil.WriteException(ex);
}
return(result);
}
/// <summary>
/// 填充数据权限
/// </summary>
/// <param name="dataSet">数据权限</param>
/// <param name="commandType">命令分类</param>
/// <param name="commandText">sql查询</param>
/// <param name="tableName">填充表</param>
/// <param name="dbParameters">参数集</param>
/// <returns>数据权限</returns>
public virtual DataSet Fill(DataSet dataSet, string commandText, string tableName, IDbDataParameter[] dbParameters, CommandType commandType)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
// 自动打开
MustCloseConnection = true;
if (DbConnection == null)
{
Open();
}
if (DbConnection.State == ConnectionState.Closed)
{
DbConnection.Open();
}
else if (DbConnection.State == ConnectionState.Broken)
{
DbConnection.Close();
DbConnection.Open();
}
using (DbCommand = DbConnection.CreateCommand())
{
try
{
#if (DEBUG)
Trace.WriteLine(DateTime.Now + " :DbConnection Start: " + DbConnection.Database + " ,ThreadId: " + Thread.CurrentThread.ManagedThreadId);
#endif
//dbCommand.Parameters.Clear();
//if ((dbParameters != null) && (dbParameters.Length > 0))
//{
// for (int i = 0; i < dbParameters.Length; i++)
// {
// if (dbParameters[i] != null)
// {
// dbDataAdapter.SelectCommand.Parameters.Add(dbParameters[i]);
// }
// }
//}
DbCommand.Connection = DbConnection;
DbCommand.CommandTimeout = DbConnection.ConnectionTimeout;
DbCommand.CommandText = commandText;
if (CurrentDbType == CurrentDbType.Oracle)
{
// 针对Oracle，全局替换换行符，避免报错或不执行
// 仅当前系统的换行符
DbCommand.CommandText = commandText.Replace(Environment.NewLine, " ");
// 各种平台的换行符
//_dbCommand.CommandText = commandText.Replace("r\n", " ").Replace('\n', ' ').Replace('\r', ' ');
}
DbCommand.CommandType = commandType;
if (_dbTransaction != null)
{
DbCommand.Transaction = _dbTransaction;
}
DbCommand.Parameters.Clear();
if ((dbParameters != null) && (dbParameters.Length > 0))
{
for (var i = 0; i < dbParameters.Length; i++)
{
if (dbParameters[i] != null)
{
DbCommand.Parameters.Add(((ICloneable)dbParameters[i]).Clone());
}
}
// dbCommand.Parameters.AddRange(dbParameters);
}
//记录日志
SqlUtil.WriteLog(commandText, commandType.ToString(), dbParameters);
DbDataAdapter = GetInstance().CreateDataAdapter();
DbDataAdapter.SelectCommand = DbCommand;
if (DbConnection.State != ConnectionState.Open)
{
DbConnection.Open();
}
DbDataAdapter.Fill(dataSet, tableName);
SetBackParamValue(dbParameters);
}
catch (Exception e)
{
//Troy.Cui 2020.05.13
dataSet = null;
//记录异常
var sb = Pool.StringBuilder.Get();
sb.Append(commandText);
sb.Append(" ");
sb.Append(tableName);
sb.Append(" ");
sb.Append(commandType.ToString());
if (dbParameters != null)
{
sb.Append(" dbParameters: ");
foreach (var parameter in dbParameters)
{
sb.Append(parameter.ParameterName + "=" + parameter.Value + " ");
}
}
LogUtil.WriteException(e, sb.Put());
}
finally
{
if (MustCloseConnection)
{
Close();
}
else
{
DbDataAdapter?.SelectCommand.Parameters.Clear();
}
}
stopwatch.Stop();
var statisticsText = $"Elapsed time: {stopwatch.Elapsed.TotalMilliseconds}ms";
SqlUtil.WriteLog(commandText, commandType.ToString(), dbParameters, statisticsText);
if (stopwatch.Elapsed.TotalMilliseconds >= BaseSystemInfo.SlowQueryMilliseconds)
{
var sb = Pool.StringBuilder.Get();
sb.Append(commandText);
sb.Append(" ");
sb.Append(tableName);
sb.Append(" ");
sb.Append(commandType.ToString());
if (dbParameters != null)
{
sb.Append(" dbParameters: ");
foreach (var parameter in dbParameters)
{
sb.Append(parameter.ParameterName + "=" + parameter.Value + " ");
}
}
else
{
sb.Append(" ");
}
sb.Append(statisticsText);
LogUtil.WriteLog(sb.Put(), "Slow.DbHelper.Fill");
}
}
return(dataSet);
}
/// <summary>
/// 执行查询
/// </summary>
/// <param name="commandText">sql查询</param>
/// <param name="dbParameters">参数集</param>
/// <param name="commandType">命令分类</param>
/// <returns>结果集流</returns>
public virtual IDataReader ExecuteReader(string commandText, IDbDataParameter[] dbParameters, CommandType commandType)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
//自动打开
MustCloseConnection = false;
if (DbConnection == null)
{
Open();
}
DbDataReader dbDataReader = null;
if (DbConnection.State == ConnectionState.Closed)
{
DbConnection.Open();
}
else if (DbConnection.State == ConnectionState.Broken)
{
DbConnection.Close();
DbConnection.Open();
}
using (DbCommand = DbConnection.CreateCommand())
{
try
{
#if (DEBUG)
Trace.WriteLine(DateTime.Now + " :DbConnection Start: " + DbConnection.Database + " ,ThreadId: " + Thread.CurrentThread.ManagedThreadId);
#endif
DbCommand.Connection = DbConnection;
DbCommand.CommandTimeout = DbConnection.ConnectionTimeout;
DbCommand.CommandText = commandText;
if (CurrentDbType == CurrentDbType.Oracle)
{
// 针对Oracle，全局替换换行符，避免报错或不执行
// 仅当前系统的换行符
DbCommand.CommandText = commandText.Replace(Environment.NewLine, " ");
// 各种平台的换行符
//_dbCommand.CommandText = commandText.Replace("r\n", " ").Replace('\n', ' ').Replace('\r', ' ');
}
DbCommand.CommandType = commandType;
if (_dbTransaction != null)
{
DbCommand.Transaction = _dbTransaction;
}
if (dbParameters != null)
{
DbCommand.Parameters.Clear();
foreach (var t in dbParameters)
{
if (t != null)
{
DbCommand.Parameters.Add(((ICloneable)t).Clone());
}
}
}
// 写入日志
SqlUtil.WriteLog(commandText, commandType.ToString(), dbParameters);
if (DbConnection.State != ConnectionState.Open)
{
DbConnection.Open();
}
dbDataReader = DbCommand.ExecuteReader(CommandBehavior.CloseConnection);
}
catch (Exception e)
{
var sb = Pool.StringBuilder.Get();
sb.Append(commandText);
sb.Append(" ");
sb.Append(commandType.ToString());
if (dbParameters != null)
{
sb.Append(" dbParameters: ");
foreach (var parameter in dbParameters)
{
sb.Append(parameter.ParameterName + "=" + parameter.Value + " ");
}
}
LogUtil.WriteException(e, sb.Put());
}
finally
{
//因为使用了CommandBehavior.CloseConnection，不需要关闭连接
//一定不要自动关闭连接，但需要在dataReader.Read()之后手动执行dataReader.Close()
//if (MustCloseConnection)
//{
// Close();
//}
if (DbCommand != null)
{
DbCommand.Parameters.Clear();
}
}
stopwatch.Stop();
var statisticsText = $"Elapsed time: {stopwatch.Elapsed.TotalMilliseconds}ms";
SqlUtil.WriteLog(commandText, commandType.ToString(), dbParameters, statisticsText);
if (stopwatch.Elapsed.TotalMilliseconds >= BaseSystemInfo.SlowQueryMilliseconds)
{
var sb = Pool.StringBuilder.Get();
sb.Append(commandText);
sb.Append(" ");
sb.Append(commandType.ToString());
if (dbParameters != null)
{
sb.Append(" dbParameters: ");
foreach (var parameter in dbParameters)
{
sb.Append(parameter.ParameterName + "=" + parameter.Value + " ");
}
}
else
{
sb.Append(" ");
}
sb.Append(statisticsText);
LogUtil.WriteLog(sb.Put(), "Slow.DbHelper.ExecuteReader");
}
}
return(dbDataReader);
}
