/// <summary>
/// 解压缩7-ZIP文件(加密)
/// </summary>
/// <param name="strZipPath">ZIP压缩文件保存位置</param>
/// <param name="strDeCompressionPath">需要解压到的指定位置</param>
/// <param name="strPassword">压缩文件密码</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool DeCompression7Zip(string strZipPath, string strDeCompressionPath, string strPassword)
{
try
{
if (string.IsNullOrEmpty(strZipPath) || !File.Exists(strZipPath))
{
return(false);
}
//动态链接7ZIP类库
SetLibraryPath7z();
//创建目录
if (!Directory.Exists(strDeCompressionPath))
{
Directory.CreateDirectory(strDeCompressionPath);
}
//解压数据
SevenZipExtractor sevenZipExtractor = new SevenZipExtractor(strZipPath, strPassword);
foreach (ArchiveFileInfo itemArchiveFileInfo in sevenZipExtractor.ArchiveFileData)
{
sevenZipExtractor.ExtractFiles(strDeCompressionPath, itemArchiveFileInfo.Index);
}
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(false);
}
}
/// <summary>
/// DataTable分页查询
/// </summary>
/// <param name="dtDataSource">源数据(DataTable)</param>
/// <param name="iPageNo">页码</param>
/// <param name="iPageSize">每页条数</param>
/// <returns>指定页码的DataTable数据</returns>
public static DataTable PagingQuery(DataTable dtDataSource, int iPageNo, int iPageSize)
{
try
{
int iDataSourceCount = dtDataSource.Rows.Count;
int iNumberPages = (iDataSourceCount / iPageSize) + (iDataSourceCount % iPageSize > 0 ? 1 : 0);
iPageNo = iPageNo <= 0 ? 1 : iPageNo;
//填充数据
DataTable dtPageData = dtDataSource.Clone();
for (int iRows = (iPageNo - 1) * iPageSize; iRows < iPageNo * iPageSize && iRows < dtDataSource.Rows.Count; iRows++)
{
var newRow = dtPageData.NewRow();
var oldRow = dtDataSource.Rows[iRows];
foreach (DataColumn dataColumn in dtDataSource.Columns)
{
newRow[dataColumn.ColumnName] = oldRow[dataColumn.ColumnName];
}
dtPageData.Rows.Add(newRow);
}
return(dtPageData);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
}
return(null);
}
/// <summary>
/// 生成二维码
/// </summary>
/// <param name="strContent">二维码文本</param>
/// <param name="iWidth">二维码宽度</param>
/// <param name="iHeigth">二维码高度</param>
/// <returns>二维码位图</returns>
public static Bitmap GetQRCode(string strContent, int iWidth, int iHeigth)
{
try
{
//构造二维码写码器
MultiFormatWriter writer = new MultiFormatWriter();
Dictionary <EncodeHintType, object> hint = new Dictionary <EncodeHintType, object>();
hint.Add(EncodeHintType.CHARACTER_SET, "UTF-8");
hint.Add(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);
hint.Add(EncodeHintType.MARGIN, 1);
//生成二维码
BitMatrix bitMatrix = writer.encode(strContent, BarcodeFormat.QR_CODE, iWidth, iHeigth, hint);
BarcodeWriter barcodeWriter = new BarcodeWriter();
Bitmap bitmapQRCode = barcodeWriter.Write(bitMatrix);
//获取二维码实际尺寸(去掉二维码两边空白后的实际尺寸)
int[] rectangle = bitMatrix.getEnclosingRectangle();
//将img转换成bmp格式，否则后面无法创建Graphics对象
Bitmap bitmapQRCodeBMP = new Bitmap(bitmapQRCode.Width, bitmapQRCode.Height, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
using (Graphics g = Graphics.FromImage(bitmapQRCodeBMP))
{
g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
g.DrawImage(bitmapQRCode, 0, 0);
}
return(bitmapQRCodeBMP);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 删除 URL Protocol 协议
/// </summary>
/// <param name="strName">键值名称</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool DeleteURLProtocol(string strName)
{
try
{
if (string.IsNullOrEmpty(strName))
{
return(false);
}
RegistryKey registryKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(strName, true);
if (registryKey == null)
{
return(false);
}
else
{
registryKey = Microsoft.Win32.Registry.ClassesRoot;
registryKey.DeleteSubKeyTree(strName);
}
registryKey.Close();
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(false);
}
}
/// <summary>
/// 读取网卡MAC地址
/// </summary>
/// <returns>成功返回网卡MAC地址,失败返回NULL</returns>
public static List <string> MAC()
{
try
{
// 虚拟网卡标识
List <string> listFictitious = new List <string>
{
"vmnetadapter",
"ppoe",
"bthpan",
"tapvpn",
"ndisip",
"sinforvnic"
};
// 获取并过滤网卡Mac信息
List <string> listMAC = new List <string>();
foreach (ManagementObject mo in new ManagementClass("Win32_NetworkAdapterConfiguration").GetInstances())
{
if ((bool)mo["IPEnabled"] && !listFictitious.Contains(mo["ServiceName"].ToString().ToLower()))
{
listMAC.Add(mo["MacAddress"].ToString());
}
}
return(listMAC);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 文件DES加密
/// </summary>
/// <param name="strFilePath">文件路径</param>
/// <param name="strSaveFilePath">加密文件目录</param>
/// <param name="strKey">秘钥(8位)</param>
/// <param name="strIV">向量(8位)</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool FileDESEncrypt(string strFilePath, string strSaveFilePath, string strKey, string strIV)
{
try
{
DESCryptoServiceProvider desCrypto = new DESCryptoServiceProvider();
desCrypto.Key = UTF8Encoding.Default.GetBytes(strKey);
desCrypto.IV = UTF8Encoding.UTF8.GetBytes(strIV);
FileStream fileStream = File.OpenRead(strFilePath);
byte[] byteFileStream = new byte[fileStream.Length];
fileStream.Read(byteFileStream, 0, (int)fileStream.Length);
fileStream.Close();
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, desCrypto.CreateEncryptor(), CryptoStreamMode.Write))
{
cryptoStream.Write(byteFileStream, 0, byteFileStream.Length);
cryptoStream.FlushFinalBlock();
fileStream = File.OpenWrite(strSaveFilePath);
foreach (byte byteMemoryStream in memoryStream.ToArray())
{
fileStream.WriteByte(byteMemoryStream);
}
fileStream.Close();
cryptoStream.Close();
memoryStream.Close();
return(true);
}
}
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(false);
}
}
/// <summary>
/// 获得指定路径下文件的路径和文件名(限定后缀名)
/// </summary>
/// <param name="strPath">文件夹路径</param>
/// <param name="strSuffixName">限定后缀名,如:"*.txt"、"*.xml"</param>
/// <returns>成功返回文件全路径或文件名,失败返回NULL</returns>
public static List <string> GetSpecifiedDirectoryFiles(string strPath, string strSuffixName)
{
try
{
List <string> listAllFiles = new List <string>();
DirectoryInfo TheFolder = new DirectoryInfo(strPath);
FileInfo[] TheFile;
if (string.IsNullOrEmpty(strSuffixName))
{
TheFile = TheFolder.GetFiles();
}
else
{
TheFile = TheFolder.GetFiles(strSuffixName);
}
foreach (FileInfo NextFile in TheFile)
{
listAllFiles.Add(NextFile.FullName);
}
return(listAllFiles);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 创建Get请求
/// </summary>
/// <param name="url">Api访问地址</param>
/// <param name="requestUrl">详细方法路径</param>
/// <param name="parameters">请求参数</param>
/// <returns>Api返回值</returns>
public static string CreateGetHttpClient(string url, string requestUrl, IDictionary <string, string> parameters)
{
try
{
StringBuilder builder = new StringBuilder();
builder.Append(url);
builder.Append(requestUrl);
if (parameters != null && parameters.Count >= 1)
{
builder.Append("?");
int i = 0;
foreach (var item in parameters)
{
if (i > 0)
{
builder.Append("&");
}
builder.AppendFormat("{0}={1}", item.Key, item.Value);
i++;
}
}
HttpClient httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(url);
var result = httpClient.GetAsync(builder.ToString()).Result;
return(result.Content.ReadAsStringAsync().Result);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return("");
}
}
/// <summary>
/// 获得EntityList类型数据
/// </summary>
/// <typeparam name="T">数据模型</typeparam>
/// <param name="strTableName">表名</param>
/// <param name="strWhere">过滤条件</param>
/// <returns>成功返回ListT,失败返回null</returns>
public static List <T> GetEntityList <T>(string strTableName, string strWhere) where T : class, new()
{
try
{
List <T> listT = new List <T>();
SQLiteHelper sqlHelper = new SQLiteHelper();
sqlHelper.SQLiteConnectionString(strSQLiteConn);
sqlHelper.Open();
if (string.IsNullOrEmpty(strWhere))
{
listT = DataProcessing.ConvertToList <T>(sqlHelper.GetDataTable(string.Format("SELECT * FROM {0}", strTableName)));
}
else
{
listT = DataProcessing.ConvertToList <T>(sqlHelper.GetDataTable(string.Format("SELECT * FROM {0} WHERE {1}", strTableName, strWhere)));
}
sqlHelper.Close();
return(listT);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 匹配替换标签
/// </summary>
/// <param name="strText">需要匹配的文本</param>
/// <param name="strStartSymbol">起始符号</param>
/// <param name="strStopSymbol">终止符号</param>
/// <returns>匹配成功的标签(带标签,不带标签)</returns>
public static Dictionary <string, string> MatchingReplaceLabel(string strText, string strStartSymbol, string strStopSymbol)
{
try
{
if (string.IsNullOrEmpty(strText))
{
return(null);
}
Dictionary <string, string> dicMatchingLabel = new Dictionary <string, string>();
string strRegularExpression = string.Format(@"[^{0}]+(?=\{1})", strStartSymbol, strStopSymbol);
foreach (Match matchText in Regex.Matches(strText, strRegularExpression))
{
if (!dicMatchingLabel.ContainsKey(matchText.Value))
{
dicMatchingLabel.Add(string.Format("{0}{1}{2}", strStartSymbol, matchText.Value, strStopSymbol), string.Format("{0}", matchText.Value));
}
}
return(dicMatchingLabel);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 获取文件CRC32值(8位小写)
/// </summary>
/// <param name="strFilePath">文件路径</param>
/// <returns>文件CRC32值(8位小写)</returns>
public static string FileCRC32Encrypt_8Lower(string strFilePath)
{
try
{
String hashCRC32 = String.Empty;
//检查文件是否存在,如果文件存在则进行计算,否则返回空值
if (System.IO.File.Exists(strFilePath))
{
using (System.IO.FileStream fileStream = new System.IO.FileStream(strFilePath, System.IO.FileMode.Open, System.IO.FileAccess.Read))
{
//计算文件的CSC32值
Crc32 calculator = new Crc32();
Byte[] buffer = calculator.ComputeHash(fileStream);
calculator.Clear();
//将字节数组转换成十六进制的字符串形式
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < buffer.Length; i++)
{
stringBuilder.Append(buffer[i].ToString("x2"));
}
hashCRC32 = stringBuilder.ToString();
}
}
return(hashCRC32);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(string.Empty);
}
}
/// <summary>
/// 获得Word文档中所有替换标签('{标签}','#标签#')
/// </summary>
/// <param name="strDataSourcePath">Word文件路径</param>
/// <returns>替换标签Dictionary(带标签,不带标签)</returns>
public static Dictionary <string, string> GetWordAllLable(string strDataSourcePath)
{
try
{
if (string.IsNullOrEmpty(strDataSourcePath) || !File.Exists(strDataSourcePath))
{
return(null);
}
Dictionary <string, string> dicAllLabel = new Dictionary <string, string>();
List <string> listAllText = GetWordAllText(strDataSourcePath);
foreach (string strAllText in listAllText)
{
Dictionary <string, string> dicMatchingLabelK = MatchingReplaceLabel(strAllText, "{", "}");
Dictionary <string, string> dicMatchingLabelS = MatchingReplaceLabel(strAllText, "#", "#");
if (dicMatchingLabelK != null && dicMatchingLabelK.Count >= 1)
{
dicAllLabel = dicAllLabel.Union(dicMatchingLabelK).ToDictionary(k => k.Key, v => v.Value);
}
if (dicMatchingLabelS != null && dicMatchingLabelS.Count >= 1)
{
dicAllLabel = dicAllLabel.Union(dicMatchingLabelS).ToDictionary(k => k.Key, v => v.Value);
}
}
return(dicAllLabel);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 获得Word文档中所有文本
/// </summary>
/// <param name="strDataSourcePath">Word文件路径</param>
/// <returns>所有文本List</returns>
public static List <string> GetWordAllText(string strDataSourcePath)
{
try
{
if (string.IsNullOrEmpty(strDataSourcePath) || !File.Exists(strDataSourcePath))
{
return(null);
}
List <string> listAllText = new List <string>();
List <string> listParagraphText = GetWordParagraphText(strDataSourcePath);
List <string> listTableText = GetWordTableText(strDataSourcePath);
if (listParagraphText != null && listParagraphText.Count >= 1)
{
listAllText = listAllText.Union(listParagraphText).ToList <string>();
}
if (listTableText != null && listTableText.Count >= 1)
{
listAllText = listAllText.Union(listTableText).ToList <string>();
}
return(listAllText);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 获得Word文档中所有表格
/// </summary>
/// <param name="strDataSourcePath">Word文件路径</param>
/// <returns>段落标签List</returns>
public static List <string> GetWordTableText(string strDataSourcePath)
{
try
{
if (string.IsNullOrEmpty(strDataSourcePath) || !File.Exists(strDataSourcePath))
{
return(null);
}
List <string> listTableText = new List <string>();
FileStream fileStream = new FileStream(strDataSourcePath, FileMode.Open, FileAccess.Read);
XWPFDocument wordDocument = new XWPFDocument(fileStream);
foreach (XWPFTable wordTable in wordDocument.Tables)
{
foreach (XWPFTableRow wordTableRow in wordTable.Rows)
{
foreach (XWPFTableCell wordTableCell in wordTableRow.GetTableCells())
{
foreach (XWPFParagraph wordParagraph in wordTableCell.Paragraphs)
{
listTableText.Add(wordParagraph.ParagraphText);
}
}
}
}
return(listTableText);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// DataSet转换为Json
/// </summary>
/// <param name="dsSourceData">DataTable数据</param>
/// <param name="diclistFieldNameType">数据库表字段名和字段类型</param>
/// <returns>对象的JSON字符串表示形式</returns>
public static string DataSetConversionJson(DataSet dsSourceData, Dictionary <string, Dictionary <string, string> > diclistFieldNameType)
{
try
{
if (dsSourceData == null || dsSourceData.Tables.Count < 1)
{
//dtSourceData是基础数据,名称和字段类型可以为空
return(string.Empty);
}
List <DataTableModel> listDataTableModel = new List <DataTableModel>();
foreach (DataTable dtSourceData in dsSourceData.Tables)
{
DataTableModel dtmValue = new DataTableModel();
dtmValue.TableName = dtSourceData.TableName;
dtmValue.dicFieldNameType = diclistFieldNameType[dtSourceData.TableName];
dtmValue.dtSourceData = dtSourceData;
listDataTableModel.Add(dtmValue);
}
return(JsonConvert.SerializeObject(listDataTableModel));
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(string.Empty);
}
}
/// <summary>
/// 解压缩GZIP数据
/// </summary>
/// <param name="bytesSourceData">源数据</param>
/// <returns>解压缩数据</returns>
public static byte[] DeCompressionGZIP(byte[] bytesSourceData)
{
try
{
MemoryStream memoryStream = new MemoryStream(bytesSourceData);
GZipStream compressedzipStream = new GZipStream(memoryStream, CompressionMode.Decompress);
MemoryStream outBuffer = new MemoryStream();
byte[] block = new byte[1024];
while (true)
{
int bytesRead = compressedzipStream.Read(block, 0, block.Length);
if (bytesRead <= 0)
{
break;
}
else
{
outBuffer.Write(block, 0, bytesRead);
}
}
compressedzipStream.Close();
return(outBuffer.ToArray());
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// DES解密
/// </summary>
/// <param name="strCiphertext">DES密文</param>
/// <param name="strKey">秘钥(8位)</param>
/// <param name="strIV">向量(8位)</param>
/// <returns>明文</returns>
public static string DESDecrypt(string strCiphertext, string strKey, string strIV)
{
try
{
DESCryptoServiceProvider desCrypto = new DESCryptoServiceProvider();
desCrypto.Key = UTF8Encoding.Default.GetBytes(strKey);
desCrypto.IV = UTF8Encoding.UTF8.GetBytes(strIV);
using (ICryptoTransform cryptoTransform = desCrypto.CreateDecryptor())
{
byte[] byteBase64 = Convert.FromBase64String(strCiphertext);
using (var memoryStream = new MemoryStream())
{
using (var cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write))
{
cryptoStream.Write(byteBase64, 0, byteBase64.Length);
cryptoStream.FlushFinalBlock();
}
return(Encoding.UTF8.GetString(memoryStream.ToArray()));
}
}
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(string.Empty);
}
}
/// <summary>
/// 获得指定路径下所有文件的路径和文件名
/// </summary>
/// <param name="strPath">文件夹路径</param>
/// <returns>成功返回文件全路径或文件名,失败返回NULL</returns>
public static List <string> GetSpecifiedDirectoryAllFiles(string strPath)
{
try
{
List <string> listAllFiles = new List <string>();
DirectoryInfo TheFolder = new DirectoryInfo(strPath);
foreach (FileInfo NextFile in TheFolder.GetFiles())
{
listAllFiles.Add(NextFile.FullName);
}
foreach (DirectoryInfo NextFolder in TheFolder.GetDirectories())
{
foreach (string strLayer in GetSpecifiedDirectoryAllFiles(NextFolder.FullName))
{
listAllFiles.Add(strLayer);
}
}
return(listAllFiles);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 通过二进制文件保存文件到指定路径
/// </summary>
/// <param name="BinaryData">二进制文件</param>
/// <param name="strFilePath">文件路径</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool GetFilePathFromBinaryData(Byte[] BinaryData, string strFilePath)
{
try
{
if (BinaryData.Length < 1 || string.IsNullOrEmpty(strFilePath))
{
return(false);
}
if (!Directory.Exists(System.IO.Path.GetDirectoryName(strFilePath)))
{
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(strFilePath));
}
FileStream fileStream = new FileStream(strFilePath, FileMode.Create);
BinaryWriter pBinaryWriter = new BinaryWriter(fileStream);
pBinaryWriter.Write(BinaryData, 0, BinaryData.Length);
pBinaryWriter.Close();
fileStream.Close();
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(false);
}
}
/// <summary>
/// 全屏幕截图
/// </summary>
/// <returns>截图Bitmap</returns>
public static Bitmap ScreenshotFullScreen()
{
try
{
//得到屏幕工作区域宽度
//double x = SystemParameters.WorkArea.Width;
//得到屏幕工作区域高度
//double y = SystemParameters.WorkArea.Height;
//得到屏幕整体宽度
double dPrimaryScreenWidth = SystemParameters.PrimaryScreenWidth;
//得到屏幕整体高度
double dPrimaryScreenHeight = SystemParameters.PrimaryScreenHeight;
//初始化使用指定的大小(屏幕大小)的 System.Drawing.Bitmap 类的新实例.
Bitmap bitmapScreenshot = new Bitmap((int)dPrimaryScreenWidth, (int)dPrimaryScreenHeight);
//从指定的载入原创建新的 System.Drawing.Graphics.
Graphics graphicsScreenshot = Graphics.FromImage(bitmapScreenshot);
//获取或设置绘制到此 System.Drawing.Graphics 的渲染质量:高质量 低速度合成.
graphicsScreenshot.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
//截取电脑屏幕:从屏幕到 System.Drawing.Graphics 的绘图图面.
graphicsScreenshot.CopyFromScreen((int)0, (int)0, (int)0, (int)0, new System.Drawing.Size((int)dPrimaryScreenWidth, (int)dPrimaryScreenHeight));
return(bitmapScreenshot);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 执行CMD命令
/// </summary>
/// <param name="cmd">cmd命令</param>
/// <returns>cmd窗口的输出信息</returns>
private static string ImplementationCMD(string cmd)
{
try
{
//使用cmd命令对文件共享进行操作
System.Diagnostics.Process p = new System.Diagnostics.Process();
p.StartInfo.FileName = "cmd.exe";
//是否使用操作系统shell启动
p.StartInfo.UseShellExecute = false;
//接受来自调用程序的输入信息
p.StartInfo.RedirectStandardInput = true;
//由调用程序获取输出信息
p.StartInfo.RedirectStandardOutput = true;
//重定向标准错误输出
p.StartInfo.RedirectStandardError = true;
//不显示程序窗口
p.StartInfo.CreateNoWindow = true;
//启动程序
p.Start();
//执行CMD命令
p.StandardInput.WriteLine(cmd);
p.StandardInput.AutoFlush = true;
p.StandardInput.WriteLine("exit");
//获取cmd窗口的输出信息
string strOutput = p.StandardOutput.ReadToEnd();
p.WaitForExit();//等待程序执行完退出进程
p.Close();
return(strOutput);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 保存二进制文件到数据库中
/// </summary>
/// <param name="strTableName">表名</param>
/// <param name="strSaveField">保存列名</param>
/// <param name="strSaveFilePath">文件路径</param>
/// <param name="strWhere">查询Where条件</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool SaveByteArray(string strTableName, string strSaveField, string strSaveFilePath, string strWhere)
{
try
{
//读取文件为Byte[]
FileStream fileStream = new FileStream(strSaveFilePath, FileMode.Open);
byte[] byteFile = new byte[(int)fileStream.Length];
fileStream.Read(byteFile, 0, byteFile.Length);
fileStream.Close();
//保存到数据库
SQLiteConnection SQLConnection = new SQLiteConnection(strSQLiteConn);
SQLConnection.Open();
string strSQL = string.Format("UPDATE {0} SET {1} = @file where {2}", strTableName, strSaveField, strWhere);
SQLiteCommand SQLCommand = new SQLiteCommand(strSQL, SQLConnection);
SQLCommand.Parameters.Add("@file", DbType.Binary, byteFile.Length);
SQLCommand.Parameters["@file"].Value = byteFile;
SQLCommand.ExecuteNonQuery();
SQLConnection.Close();
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(false);
}
}
/// <summary>
/// 读取BIOS序列号
/// </summary>
/// <returns>成功返回BIOS序列号,失败返回NULL</returns>
public static List <string> BIOS()
{
try
{
List <string> listBIOS = new List <string>();
string strMac = "";
ManagementClass mc = new ManagementClass("Win32_BIOS");
ManagementObjectCollection moc = mc.GetInstances();
foreach (ManagementObject mo in moc)
{
//Manufacturer = BIOS制造商名称
//SerialNumber = BIOS序列号
//ReleaseDate = 出厂日期
//Version = 版本号
strMac = mo["SerialNumber"].ToString();
listBIOS.Add(strMac);
}
return(listBIOS);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// DataTable转换为XML(同步保存字段类型)
/// </summary>
/// <param name="strSource">XML文件路径</param>
/// <param name="dtSourceData">DataTable数据</param>
/// <param name="dicFieldNameType">数据库表字段名和字段类型</param>
/// <returns>成功返回true,失败返回false</returns>
public static bool DataTableConversionXML(string strSource, DataTable dtSourceData, Dictionary <string, string> dicFieldNameType)
{
try
{
if (string.IsNullOrEmpty(strSource) || dtSourceData.Rows.Count < 1)
{
return(false);
}
//创建并保存数据
XmlDocument Document = new XmlDocument();
XmlNode Node = Document.CreateXmlDeclaration("1.0", "utf-8", "");
Document.AppendChild(Node);
//整体XML是一个DataSet
XmlNode nodeDataSet = Document.CreateElement("DataSet");
Document.AppendChild(nodeDataSet);
//DataSet中包含若干个DataTable
XmlNode nodeDataTablet = Document.CreateElement("DataTable");
nodeDataSet.AppendChild(nodeDataTablet);
//DataTable中包含DataTableName、DataTableField、DataTable
XmlNode nodeDataTableName = Document.CreateNode(XmlNodeType.Element, "DataTableName", null);
nodeDataTableName.InnerText = dtSourceData.TableName;
nodeDataTablet.AppendChild(nodeDataTableName);
XmlNode nodeDataTableField = Document.CreateNode(XmlNodeType.Element, "DataTableField", null);
nodeDataTablet.AppendChild(nodeDataTableField);
foreach (var item in dtSourceData.Columns)
{
//DataTableField中包含Field
XmlNode nodeField = Document.CreateNode(XmlNodeType.Element, "Field", null);
nodeDataTableField.AppendChild(nodeField);
//Field中包含FieldName、FieldType
XmlNode nodeFieldName = Document.CreateNode(XmlNodeType.Element, "FieldName", null);
nodeFieldName.InnerText = item.ToString();
nodeField.AppendChild(nodeFieldName);
XmlNode nodeFieldType = Document.CreateNode(XmlNodeType.Element, "FieldType", null);
nodeFieldType.InnerText = dicFieldNameType != null && dicFieldNameType.ContainsKey(item.ToString()) ? dicFieldNameType[item.ToString()].ToString() : "";
nodeField.AppendChild(nodeFieldType);
}
XmlNode nodeDataTableData = Document.CreateNode(XmlNodeType.Element, "DataTableData", null);
nodeDataTablet.AppendChild(nodeDataTableData);
foreach (DataRow drSourceData in dtSourceData.Rows)
{
//DataTableData中包含DataRow
XmlNode nodeDataRow = Document.CreateNode(XmlNodeType.Element, "DataRow", null);
nodeDataTableData.AppendChild(nodeDataRow);
foreach (var item in dtSourceData.Columns)
{
XmlNode nodeData = Document.CreateNode(XmlNodeType.Element, item.ToString(), null);
nodeData.InnerText = drSourceData[item.ToString()].ToString();
nodeDataRow.AppendChild(nodeData);
}
}
Document.Save(strSource);
return(true);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(false);
}
}
/// <summary>
/// List转换为DataTable
/// </summary>
/// <param name="listDataSource">源数据</param>
/// <returns>成功返回DataTable,失败返回null</returns>
public static DataTable ConvertDataTable(IList listDataSource)
{
try
{
DataTable dataTable = new DataTable();
if (listDataSource.Count > 0)
{
PropertyInfo[] propertyInfos = listDataSource[0].GetType().GetProperties();
foreach (PropertyInfo propertyInfo in propertyInfos)
{
dataTable.Columns.Add(propertyInfo.Name, propertyInfo.PropertyType);
}
foreach (var vDataSource in listDataSource)
{
ArrayList arrayList = new ArrayList();
foreach (PropertyInfo propertyInfo in propertyInfos)
{
arrayList.Add(propertyInfo.GetValue(vDataSource, null));
}
dataTable.LoadDataRow(arrayList.ToArray(), true);
}
}
return(dataTable);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
}
return(null);
}
/// <summary>
/// AES解密
/// </summary>
/// <param name="strCiphertext">AES密文</param>
/// <param name="strKey">秘钥</param>
/// <returns>明文</returns>
public static string AESDecrypt(string strCiphertext, string strKey)
{
try
{
if (string.IsNullOrEmpty(strCiphertext))
{
return(string.Empty);
}
strKey = strKey.Length < 32 ? strKey.PadRight(32, '0') : strKey.Substring(0, 32);
Byte[] toEncryptArray = Convert.FromBase64String(strCiphertext);
RijndaelManaged rijndaelManaged = new RijndaelManaged
{
Key = Encoding.UTF8.GetBytes(strKey),
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform pCryptoTransform = rijndaelManaged.CreateDecryptor();
Byte[] resultArray = pCryptoTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return(Encoding.UTF8.GetString(resultArray));
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(string.Empty);
}
}
/// <summary>
/// 删除DataTable中的空行
/// 弱引用,可直接修改参数
/// </summary>
/// <param name="dtDataSource">源数据(DataTable)</param>
/// <returns>删除空行后的DataTable</returns>
public static DataTable RemoveEmpty(DataTable dtDataSource)
{
try
{
List <DataRow> listRemove = new List <DataRow>();
for (int i = 0; i < dtDataSource.Rows.Count; i++)
{
bool IsNull = true;
for (int j = 0; j < dtDataSource.Columns.Count; j++)
{
if (!string.IsNullOrEmpty(dtDataSource.Rows[i][j].ToString().Trim()))
{
IsNull = false;
}
}
if (IsNull)
{
listRemove.Add(dtDataSource.Rows[i]);
}
}
for (int i = 0; i < listRemove.Count; i++)
{
dtDataSource.Rows.Remove(listRemove[i]);
}
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
}
return(dtDataSource);
}
/// <summary>
/// Json转换为DataSet
/// </summary>
/// <param name="strJson">反序列化对象</param>
/// <param name="diclistFieldNameType">返回Json的数据库表字段名和字段类型</param>
/// <returns>成功返回Json的DataSet,失败返回NULL</returns>
public static DataSet JsonConversionDataSet(string strJson, out Dictionary <string, Dictionary <string, string> > diclistFieldNameType)
{
diclistFieldNameType = new Dictionary <string, Dictionary <string, string> >();
try
{
if (string.IsNullOrEmpty(strJson))
{
return(null);
}
List <DataTableModel> listDtmValue = JsonConvert.DeserializeObject <List <DataTableModel> >(strJson);
DataSet dsSourceData = new DataSet();
foreach (DataTableModel dtmValue in listDtmValue)
{
DataTable dtSourceData = dtmValue.dtSourceData;
dtSourceData.TableName = dtmValue.TableName;
dsSourceData.Tables.Add(dtSourceData);
diclistFieldNameType.Add(dtmValue.TableName, dtmValue.dicFieldNameType);
}
return(dsSourceData);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
/// <summary>
/// 创建Get请求
/// </summary>
/// <param name="url">Api访问地址</param>
/// <param name="requestUrl">详细方法路径</param>
/// <param name="parameters">请求参数</param>
/// <param name="encoding">字符编码</param>
/// <param name="timout ">请求超时前等待的毫秒数,默认值是 100,000 毫秒（100 秒）</param>
/// <returns>Api返回值</returns>
public static string CreateGetHttpWebRequest(string url, string requestUrl, IDictionary <string, string> parameters, Encoding encoding, int timout)
{
try
{
StringBuilder builder = new StringBuilder();
builder.Append(url);
builder.Append(requestUrl);
if (parameters != null && parameters.Count >= 1)
{
builder.Append("?");
int i = 0;
foreach (var item in parameters)
{
if (i > 0)
{
builder.Append("&");
}
builder.AppendFormat("{0}={1}", item.Key, item.Value);
i++;
}
}
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(builder.ToString());
request.Method = "GET";
request.ContentType = "application/x-www-form-urlencoded";
request.Timeout = timout;
StreamReader reader = new StreamReader(request.GetResponse().GetResponseStream(), encoding);
return(reader.ReadToEnd());
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return("");
}
}
/// <summary>
/// 获得URL路径下文件列表
/// </summary>
/// <returns>文件列表List</returns>
public List <string> GetFilesDetailList()
{
try
{
List <string> listAllFiles = new List <string>();
Request = (FtpWebRequest)FtpWebRequest.Create(new Uri(strFTPServerURL));
Request.Credentials = new NetworkCredential(strFTPServerUserID, strFTPServerPassword);
Request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
WebResponse Response = Request.GetResponse();
StreamReader Reader = new StreamReader(Response.GetResponseStream());
string strLine = Reader.ReadLine();
while (strLine != null)
{
if (AnalysisLISTCommand(strLine).FileType == "-")
{
listAllFiles.Add(AnalysisLISTCommand(strLine).FileName);
}
strLine = Reader.ReadLine();
}
Reader.Close();
Response.Close();
return(listAllFiles);
}
catch (Exception ex)
{
TXTHelper.Logs(ex.ToString());
return(null);
}
}
