old_flsystem/类库/HttpHelper2.1/Extend/HttpExtend.cs

2064 lines
78 KiB
C#
Raw Normal View History

2022-09-20 03:10:29 +00:00

using CsharpHttpHelper.Down;
using CsharpHttpHelper.Properties;
using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Net;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Web;
using System.Xml;
namespace CsharpHttpHelper
{
public class AESCryption
{
/// <summary>
/// AES 加密
/// </summary>
/// <param name="str">明文(待加密)</param>
/// <param name="key">密文</param>
/// <returns></returns>
public string AesEncrypt(string str, string key)
{
return AesEncrypt(str, Encoding.UTF8.GetBytes(key));
}
/// <summary>
/// AES 加密
/// </summary>
/// <param name="str">明文(待加密)</param>
/// <param name="key">密文</param>
/// <returns></returns>
public string AesEncrypt(string str, byte[] key)
{
if (string.IsNullOrEmpty(str)) return null;
Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);
RijndaelManaged rm = new RijndaelManaged
{
Key = key,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
;
ICryptoTransform cTransform = rm.CreateEncryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
#region Base64编码的文本转换成普通文本
/// <summary>
/// 将Base64编码的文本转换成普通文本
/// </summary>
/// <param name="base64">Base64编码的文本</param>
/// <returns></returns>
public static string Base64StringToString(string base64)
{
if (base64 != "")
{
char[] charBuffer = base64.ToCharArray();
byte[] bytes = System.Convert.FromBase64CharArray(charBuffer, 0, charBuffer.Length);
string returnstr = Encoding.Default.GetString(bytes);
return returnstr;
}
else
{
return "";
}
}
#endregion
#region base64字符串
public static string StringToBase64String(string str)
{
if (str != "" && str != null)
{
byte[] b = Encoding.Default.GetBytes(str);
string returnstr = System.Convert.ToBase64String(b);
return returnstr;
}
else
{
return "";
}
}
#endregion
/// <summary>
/// AES 解密
/// </summary>
/// <param name="str">明文(待解密)</param>
/// <param name="key">密文</param>
/// <returns></returns>
public string AesDecrypt(string str, string key)
{
return AesDecrypt(str, Encoding.UTF8.GetBytes(key));
}
public string AesDecrypt(string str, byte[] key)
{
if (string.IsNullOrEmpty(str)) return null;
Byte[] toEncryptArray = Convert.FromBase64String(str);
RijndaelManaged rm = new RijndaelManaged
{
Key = key,
Mode = CipherMode.ECB,
Padding = PaddingMode.PKCS7
};
ICryptoTransform cTransform = rm.CreateDecryptor();
Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
return Encoding.UTF8.GetString(resultArray);
}
}
/// <summary>
/// WinInet的方式请求数据
/// </summary>
public class Wininet
{
#region WininetAPI
[DllImport("wininet.dll", CharSet = CharSet.Auto)]
private static extern int InternetOpen(string strAppName, int ulAccessType, string strProxy, string strProxyBypass, int ulFlags);
[DllImport("wininet.dll", CharSet = CharSet.Auto)]
private static extern int InternetConnect(int ulSession, string strServer, int ulPort, string strUser, string strPassword, int ulService, int ulFlags, int ulContext);
[DllImport("wininet.dll", CharSet = CharSet.Auto)]
private static extern bool InternetCloseHandle(int ulSession);
[DllImport("wininet.dll", CharSet = CharSet.Auto)]
private static extern bool HttpAddRequestHeaders(int hRequest, string szHeasers, uint headersLen, uint modifiers);
[DllImport("wininet.dll", CharSet = CharSet.Auto)]
private static extern int HttpOpenRequest(int hConnect, string szVerb, string szURI, string szHttpVersion, string szReferer, string accetpType, int dwflags, int dwcontext);
[DllImport("wininet.dll")]
private static extern bool HttpSendRequestA(int hRequest, string szHeaders, int headersLen, string options, int optionsLen);
[DllImport("wininet.dll", CharSet = CharSet.Auto)]
private static extern bool InternetReadFile(int hRequest, byte[] pByte, int size, out int revSize);
[DllImport("wininet.dll", CharSet = CharSet.Auto, SetLastError = true)]
private static extern bool InternetGetCookieEx(string pchURL, string pchCookieName, StringBuilder pchCookieData, ref System.UInt32 pcchCookieData, int dwFlags, IntPtr lpReserved);
#endregion
#region
/// <summary>
/// WinInet 方式GET
/// </summary>
/// <param name="Url">地址</param>
/// <returns></returns>
public string GetData(string Url)
{
using (MemoryStream ms = GetHtml(Url, ""))
{
if (ms != null)
{
//无视编码
Match meta = Regex.Match(Encoding.Default.GetString(ms.ToArray()), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToUpper().Trim() : string.Empty;
if (c.Length > 2)
{
if (c.IndexOf("UTF-8") != -1)
{
return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
}
}
return Encoding.GetEncoding("GBK").GetString(ms.ToArray());
}
else
{
return null;
}
}
}
/// <summary>
/// POST
/// </summary>
/// <param name="Url">地址</param>
/// <param name="postData">提交数据</param>
/// <returns></returns>
public string PostData(string Url, string postData)
{
using (MemoryStream ms = GetHtml(Url, postData))
{
//无视编码
Match meta = Regex.Match(Encoding.Default.GetString(ms.ToArray()), "<meta([^<]*)charset=([^<]*)[\"']", RegexOptions.IgnoreCase);
string c = (meta.Groups.Count > 1) ? meta.Groups[2].Value.ToUpper().Trim() : string.Empty;
if (c.Length > 2)
{
if (c.IndexOf("UTF-8") != -1)
{
return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
}
}
return Encoding.GetEncoding("GBK").GetString(ms.ToArray());
}
}
/// <summary>
/// GETUTF-8模式
/// </summary>
/// <param name="Url">地址</param>
/// <returns></returns>
public string GetUtf8(string Url)
{
using (MemoryStream ms = GetHtml(Url, ""))
{
return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
}
}
/// <summary>
/// POSTUTF-8
/// </summary>
/// <param name="Url">地址</param>
/// <param name="postData">提交数据</param>
/// <returns></returns>
public string PostUtf8(string Url, string postData)
{
using (MemoryStream ms = GetHtml(Url, postData))
{
return Encoding.GetEncoding("UTF-8").GetString(ms.ToArray());
}
}
/// <summary>
/// 获取网页图片(Image)
/// </summary>
/// <param name="Url">图片地址</param>
/// <returns></returns>
public Image GetImage(string Url)
{
using (MemoryStream ms = GetHtml(Url, ""))
{
if (ms == null)
{
return null;
}
Image img = Image.FromStream(ms);
return img;
}
}
#endregion
#region
/// <summary>
/// 请求数据
/// </summary>
/// <param name="Url">请求地址</param>
/// <param name="Postdata">提交的数据</param>
/// <param name="Header">请求头</param>
/// <returns></returns>
private MemoryStream GetHtml(string Url, string Postdata, StringBuilder Header = null)
{
try
{
//声明部分变量
Uri uri = new Uri(Url);
string Method = "GET";
if (Postdata != "")
{
Method = "POST";
}
string UserAgent = "Mozilla/4.0 (compatible; MSIE 9.0; Windows NT 6.1; 125LA; .NET CLR 2.0.50727; .NET CLR 3.0.04506.648; .NET CLR 3.5.21022)";
int hSession = InternetOpen(UserAgent, 1, "", "", 0);//会话句柄
if (hSession == 0)
{
InternetCloseHandle(hSession);
return null;//Internet句柄获取失败则返回
}
int hConnect = InternetConnect(hSession, uri.Host, uri.Port, "", "", 3, 0, 0);//连接句柄
if (hConnect == 0)
{
InternetCloseHandle(hConnect);
InternetCloseHandle(hSession);
return null;//Internet连接句柄获取失败则返回
}
//请求标记
int gettype = -2147483632;
if (Url.Substring(0, 5) == "https")
{
gettype = -2139095024;
}
else
{
gettype = -2147467248;
}
//取HTTP请求句柄
int hRequest = HttpOpenRequest(hConnect, Method, uri.PathAndQuery, "HTTP/1.1", "", "", gettype, 0);//请求句柄
if (hRequest == 0)
{
InternetCloseHandle(hRequest);
InternetCloseHandle(hConnect);
InternetCloseHandle(hSession);
return null;//HTTP请求句柄获取失败则返回
}
//添加HTTP头
StringBuilder sb = new StringBuilder();
if (Header == null)
{
sb.Append("Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\n");
sb.Append("Content-Type:application/x-www-form-urlencoded\r\n");
sb.Append("Accept-Language:zh-cn\r\n");
sb.Append("Referer:" + Url);
}
else
{
sb = Header;
}
//获取返回数据
if (string.Equals(Method, "GET", StringComparison.OrdinalIgnoreCase))
{
HttpSendRequestA(hRequest, sb.ToString(), sb.Length, "", 0);
}
else
{
HttpSendRequestA(hRequest, sb.ToString(), sb.Length, Postdata, Postdata.Length);
}
//处理返回数据
int revSize = 0;//计次
byte[] bytes = new byte[1024];
MemoryStream ms = new MemoryStream();
while (true)
{
bool readResult = InternetReadFile(hRequest, bytes, 1024, out revSize);
if (readResult && revSize > 0)
{
ms.Write(bytes, 0, revSize);
}
else
{
break;
}
}
InternetCloseHandle(hRequest);
InternetCloseHandle(hConnect);
InternetCloseHandle(hSession);
return ms;
}
catch (Exception)
{
return null;
}
}
#endregion
#region webbrowser的cookies
/// <summary>
/// 取出cookies
/// </summary>
/// <param name="url">完整的链接格式</param>
/// <returns></returns>
public string GetCookies(string url)
{
uint datasize = 256;
StringBuilder cookieData = new StringBuilder((int)datasize);
if (!InternetGetCookieEx(url, null, cookieData, ref datasize, 0x2000, IntPtr.Zero))
{
if (datasize < 0)
return null;
cookieData = new StringBuilder((int)datasize);
if (!InternetGetCookieEx(url, null, cookieData, ref datasize, 0x00002000, IntPtr.Zero))
return null;
}
return cookieData.ToString() + ";";
}
#endregion
#region String与CookieContainer互转
/// <summary>
/// 遍历CookieContainer
/// </summary>
/// <param name="cc"></param>
/// <returns></returns>
public List<Cookie> GetAllCookies(CookieContainer cc)
{
List<Cookie> lstCookies = new List<Cookie>();
Hashtable table = (Hashtable)cc.GetType().InvokeMember("m_domainTable",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField |
System.Reflection.BindingFlags.Instance, null, cc, new object[] { });
foreach (object pathList in table.Values)
{
SortedList lstCookieCol = (SortedList)pathList.GetType().InvokeMember("m_list",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField
| System.Reflection.BindingFlags.Instance, null, pathList, new object[] { });
foreach (CookieCollection colCookies in lstCookieCol.Values)
foreach (Cookie c in colCookies) lstCookies.Add(c);
}
return lstCookies;
}
/// <summary>
/// 将String转CookieContainer
/// </summary>
/// <param name="url"></param>
/// <param name="cookie"></param>
/// <returns></returns>
public CookieContainer StringToCookie(string url, string cookie)
{
string[] arrCookie = cookie.Split(';');
CookieContainer cookie_container = new CookieContainer(); //加载Cookie
try
{
foreach (string sCookie in arrCookie)
{
if (sCookie.IndexOf("expires") > 0)
continue;
cookie_container.SetCookies(new Uri(url), sCookie);
}
}
catch
{
foreach (string sCookie in arrCookie)
{
Cookie ck = new Cookie();
ck.Name = sCookie.Split('=')[0].Trim();
ck.Value = sCookie.Split('=')[1].Trim();
ck.Domain = url;
cookie_container.Add(ck);
}
}
return cookie_container;
}
/// <summary>
/// 将CookieContainer转换为string类型
/// </summary>
/// <param name="cc"></param>
/// <returns></returns>
public string CookieToString(CookieContainer cc)
{
System.Collections.Generic.List<Cookie> lstCookies = new System.Collections.Generic.List<Cookie>();
Hashtable table = (Hashtable)cc.GetType().InvokeMember("m_domainTable",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField |
System.Reflection.BindingFlags.Instance, null, cc, new object[] { });
StringBuilder sb = new StringBuilder();
foreach (object pathList in table.Values)
{
SortedList lstCookieCol = (SortedList)pathList.GetType().InvokeMember("m_list",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.GetField
| System.Reflection.BindingFlags.Instance, null, pathList, new object[] { });
foreach (CookieCollection colCookies in lstCookieCol.Values)
foreach (Cookie c in colCookies)
{
sb.Append(c.Name).Append("=").Append(c.Value).Append(";");
}
}
return sb.ToString();
}
#endregion
}
public static class HttpExtend
{
/// <summary>
/// 正则获取Url链接
/// </summary>
public const string REGEX_GETURL = @"(?<链接>(?:(?:ht|f)tps?):\/\/[\w\-]+(?:\.[\w\-]+)+(?:[A-Za-z0-9_\-\.,@?^=%&:\/~\+#]*[A-Za-z0-9_\-\.,@?^=%&:\/~\+#])?)";
/// <summary>
/// 匹配单条url
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static string RegexMatchUrl(string content)
{
if (string.IsNullOrWhiteSpace(content))
return content;
var reg = Regex.Match(content.Replace("&amp;", "&"), REGEX_GETURL, RegexOptions.IgnoreCase);
if (reg.Success)
return reg.Groups["链接"].Value.Replace(@"\/", "/").Trim();
return string.Empty;
}
/// <summary>
/// 自定义正则字符串,只匹配第一个
/// </summary>
/// <param name="content"></param>
/// <param name="regexStr"></param>
/// <returns></returns>
public static string RegexMatch(string content, string regexStr)
{
if (string.IsNullOrWhiteSpace(content))
return content;
var reg = Regex.Match(content, regexStr, RegexOptions.IgnoreCase);
if (reg.Success)
return reg.Groups[1].Value;
return string.Empty;
}
/// <summary>
/// 多条url匹配
/// </summary>
/// <param name="content"></param>
/// <returns></returns>
public static List<string> RegexMatchesUrl(string content)
{
if (!string.IsNullOrWhiteSpace(content))
{
var regs = Regex.Matches(content.Replace("$amp;", "$"), REGEX_GETURL, RegexOptions.IgnoreCase | RegexOptions.Multiline);
if (regs != null && regs.Count != 0)
{
List<string> list = new List<string>();
foreach (Match reg in regs)
{
list.Add(reg.Groups["链接"].Value.Replace(@"\/", "/").Trim());
}
return list;
}
}
return new List<string>();
}
public static T ConvertEnum<T>(string value)
{
var v = System.Enum.Parse(typeof(T), value);
return (T)v;
}
public static T ConvertEnum<T>(int value)
{
return (T)System.Enum.Parse(typeof(T), value.ToString());
}
public static T ConvertEnum<T>(ushort value)
{
return (T)System.Enum.Parse(typeof(T), value.ToString());
}
#region base64字符串
private static char[] base64CodeArray = new char[]
{
'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='
};
/// <summary>
/// 是否base64字符串
/// </summary>
/// <param name="base64Str">要判断的字符串</param>
/// <returns></returns>
public static bool IsBase64(string base64Str)
{
//string strRegex = "^([A-Za-z0-9+/]{4})*([A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}==)$";
if (string.IsNullOrEmpty(base64Str))
return false;
else
{
if (base64Str.Contains(","))
base64Str = base64Str.Split(',')[1];
if (base64Str.Length % 4 != 0)
return false;
if (base64Str.Any(c => !base64CodeArray.Contains(c)))
return false;
}
try
{
return true;
}
catch (FormatException)
{
return false;
}
}
#endregion
#region Base64 Image互转
/// <summary>
/// 图片转成Base64
/// </summary>
/// <param name="file"></param>
/// <returns></returns>
public static string ConvertImageToBase64(Image file)
{
using (MemoryStream memoryStream = new MemoryStream())
{
file.Save(memoryStream, file.RawFormat);
byte[] imageBytes = memoryStream.ToArray();
return Convert.ToBase64String(imageBytes);
}
}
/// <summary>
/// Base64转成图片
/// </summary>
/// <param name="base64String"></param>
/// <returns></returns>
public static Bitmap ConvertBase64ToImage(string base64String)
{
byte[] imageBytes = Convert.FromBase64String(base64String);
using (MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length))
{
ms.Write(imageBytes, 0, imageBytes.Length);
using (Image mImage = Image.FromStream(ms, true))
{
return new Bitmap(mImage);
}
}
}
#endregion
#region Base64
/// <summary>
/// 文件转base64
/// </summary>
/// <param name="filepath">文件的路径</param>
/// <returns>base64字符串</returns>
public static string ConvertFileToBase64(string filepath)
{
FileStream fsForRead = new FileStream(filepath, FileMode.Open);//文件路径
string base64Str = "";
try
{
//读写指针移到距开头10个字节处
fsForRead.Seek(0, SeekOrigin.Begin);
byte[] bs = new byte[fsForRead.Length];
int log = Convert.ToInt32(fsForRead.Length);
//从文件中读取10个字节放到数组bs中
fsForRead.Read(bs, 0, log);
base64Str = Convert.ToBase64String(bs);
return base64Str;
}
catch (Exception ex)
{
Console.Write(ex.Message);
Console.ReadLine();
return base64Str;
}
finally
{
fsForRead.Close();
}
}
/// <summary>
/// Base64字符串转文件并保存
/// </summary>
/// <param name="base64String">base64字符串</param>
/// <param name="filePath">保存的文件,完整路径加文件名和后缀</param>
/// <returns>是否转换并保存成功</returns>
public static bool ConvertBase64ToFile(string base64String, string filePath)
{
bool opResult = false;
try
{
string strbase64 = base64String.Trim().Substring(base64String.IndexOf(",") + 1); //将‘,’以前的多余字符串删除
MemoryStream stream = new MemoryStream(Convert.FromBase64String(strbase64));
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write);
byte[] b = stream.ToArray();
fs.Write(b, 0, b.Length);
fs.Close();
opResult = true;
}
catch (Exception e)
{
Console.WriteLine("异常类型: \t" + e.GetType());
Console.WriteLine("异常描述:\t" + e.Message);
Console.WriteLine("异常方法:\t" + e.TargetSite);
Console.WriteLine("异常堆栈:\t" + e.StackTrace);
}
return opResult;
}
#endregion
/// <summary>
/// 获取图片后缀-通过图片对象
/// </summary>
/// <param name="image">图片对象</param>
/// <returns>获取不到时返回jpg</returns>
public static string GetImageExt(Image image)
{
string imageExt = "jpg";
var RawFormatGuid = image.RawFormat.Guid;
if (ImageFormat.Png.Guid == RawFormatGuid)
{
imageExt = "png";
}
if (ImageFormat.Jpeg.Guid == RawFormatGuid)
{
imageExt = "jpg";
}
if (ImageFormat.Bmp.Guid == RawFormatGuid)
{
imageExt = "bmp";
}
if (ImageFormat.Gif.Guid == RawFormatGuid)
{
imageExt = "gif";
}
if (ImageFormat.Icon.Guid == RawFormatGuid)
{
imageExt = "icon";
}
return imageExt;
}
/// <summary>
/// 获取图片后缀-通过图片路径获取文件后缀
/// </summary>
/// <param name="imagePath">图片路径</param>
/// <returns>异常时返回jpg,</returns>
public static string GetImageExt(string imagePath)
{
try
{
if (File.Exists(imagePath))
{
using (Image img = Image.FromFile(imagePath))
{
return GetImageExt(img);
}
}
}
catch (Exception ex)
{ }
return "jpg";
}
#region
/// <summary>
/// 壓縮圖片 /// </summary>
/// <param name="fileStream">圖片流</param>
/// <param name="quality">壓縮質量0-100之間 數值越大質量越高</param>
/// <returns></returns>
public static Bitmap CompressionImage(Stream fileStream, long quality)
{
try
{
using (Image img = Image.FromStream(fileStream))
{
//using (Bitmap bitmap = new Bitmap(img))
Bitmap bitmap = new Bitmap(img);
{
ImageCodecInfo CodecInfo = GetEncoder(img.RawFormat);
System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
EncoderParameters myEncoderParameters = new EncoderParameters(1);
EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, quality);
myEncoderParameters.Param[0] = myEncoderParameter;
using (MemoryStream ms = new MemoryStream())
{
bitmap.Save(ms, CodecInfo, myEncoderParameters);
myEncoderParameters.Dispose();
myEncoderParameter.Dispose();
return bitmap;
//return ms.ToArray();
}
}
}
}
catch (Exception)
{ return null; }
}
private static ImageCodecInfo GetEncoder(ImageFormat format)
{
ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
foreach (ImageCodecInfo codec in codecs)
{
if (codec.FormatID == format.Guid)
{ return codec; }
}
return null;
}
#endregion
[DllImport("wininet.dll", CharSet = System.Runtime.InteropServices.CharSet.Auto, SetLastError = true)]
private static extern bool InternetSetOption(int hInternet, int dwOption, IntPtr lpBuffer, int dwBufferLength);
/// <summary>
/// 清空IE缓存
/// </summary>
public static unsafe void SuppressWininetBehavior()
{
try
{
int option = (int)3/* INTERNET_SUPPRESS_COOKIE_PERSIST*/;
int* optionPtr = &option;
bool success = InternetSetOption(0, 81/*INTERNET_OPTION_SUPPRESS_BEHAVIOR*/, new IntPtr(optionPtr), sizeof(int));
}
catch (Exception) { }
}
public static byte[] RandomByte(int length)
{
Random random = new Random(Guid.NewGuid().GetHashCode());
byte[] bytes = new byte[length];
for (int i = 0; i < bytes.Length; i++) bytes[i] = (byte)random.Next(256);
return bytes;
}
/// <summary>
/// 数据对象转请求参数
/// </summary>
/// <param name="obj">数据对象</param>
/// <returns></returns>
public static string ConvertReqParameter(this object obj)
{
Dictionary<string, string> param = new Dictionary<string, string>();
var type = obj.GetType().GetProperties();
foreach (var item in type)
{
var _value = item.GetValue(obj, null).ToString();
param[item.Name] = _value;
}
return BuildQuery(param);
}
public static string BuildQuery(IDictionary<string, string> parameters)
{
if (parameters == null || parameters.Count == 0)
{
return null;
}
StringBuilder query = new StringBuilder();
bool hasParam = false;
foreach (KeyValuePair<string, string> kv in parameters)
{
string name = kv.Key;
string value = kv.Value;
// 忽略参数名或参数值为空的参数
if (!string.IsNullOrEmpty(name) && !string.IsNullOrEmpty(value))
{
if (hasParam)
{
query.Append("&");
}
query.Append(name);
query.Append("=");
query.Append(HttpUtility.UrlEncode(value, Encoding.UTF8));
hasParam = true;
}
}
return query.ToString().Replace("%2c", "%2C").Replace("%3a", "%3A");
}
/// <summary>
/// 删除HTML中的标签信息
/// </summary>
/// <param name="html"></param>
/// <param name="length"></param>
/// <returns></returns>
public static string ReplaceHtmlTag(string html, int length = 0)
{
string strText = System.Text.RegularExpressions.Regex.Replace(html, "<[^>]+>", "");
strText = System.Text.RegularExpressions.Regex.Replace(strText, "&[^;]+;", "");
if (length > 0 && strText.Length > length)
return strText.Substring(0, length);
return strText.Trim();
}
#region Base64编码的文本转换成普通文本
/// <summary>
/// 将Base64编码的文本转换成普通文本
/// </summary>
/// <param name="base64">Base64编码的文本</param>
/// <returns></returns>
public static string Base64StringToString(string base64)
{
if (base64 != "")
{
char[] charBuffer = base64.ToCharArray();
byte[] bytes = System.Convert.FromBase64CharArray(charBuffer, 0, charBuffer.Length);
string returnstr = Encoding.Default.GetString(bytes);
return returnstr;
}
else
{
return "";
}
}
#endregion
#region base64字符串
public static string StringToBase64String(string str)
{
if (str != "" && str != null)
{
byte[] b = Encoding.Default.GetBytes(str);
string returnstr = System.Convert.ToBase64String(b);
return returnstr;
}
else
{
return "";
}
}
#endregion
/// <summary>
/// 加密URL
/// </summary>
/// <param name="url">原始URL</param>
/// <param name="minute">链接有效期,不要超过60天</param>
/// <param name="type">默认即可</param>
/// <returns></returns>
public static string EncryptionURL(string url, int minute, int type = 2)
{
var client = new WebClient();
return client.DownloadString($"http://imwqc.cn/api.asmx/create_url?url={HttpHelper.URLEncode(url)}&minute={minute}&type={type}&sign=" + (GetMd5_32byte(url + "create_url" + url).ToLower()));
}
private static string GetMd5_32byte(string str)
{
string pwd = string.Empty;
//实例化一个md5对像
MD5 md5 = MD5.Create();
// 加密后是一个字节类型的数组这里要注意编码UTF8/Unicode等的选择 
byte[] s = md5.ComputeHash(Encoding.UTF8.GetBytes(str));
// 通过使用循环,将字节类型的数组转换为字符串,此字符串是常规字符格式化所得
for (int i = 0; i < s.Length; i++)
{
// 将得到的字符串使用十六进制类型格式。格式后的字符是小写的字母如果使用大写X则格式后的字符是大写字符
pwd = pwd + s[i].ToString("X");
}
return pwd;
}
static HttpExtend()
{
Wininet = new Wininet();
#region
/*
try
{
var Filename = MapFile("易转发.exe");
if (File.Exists(Filename))
{
var basePath = Path.Combine(Environment.CurrentDirectory, "Bin");
string start_path = string.Empty;//启动程序的路径
var nativeFile = Path.Combine(basePath, "Runtime.dll");
#region
var nameTemp = string.Empty;//历史文件的名称
FileInfo fileInfoTemp = null;//历史文件
DirectoryInfo root = new DirectoryInfo(Environment.CurrentDirectory);
FileInfo[] files = root.GetFiles();
if (files != null && files.Length != 0)
{
var fileInfo = files.ToList();
foreach (var f in fileInfo)
{
var _reg = Regex.Match(f.Name, @"(?<历史名字>.+?)\.exe\.Config", RegexOptions.IgnoreCase);
if (_reg.Success)
{
nameTemp = _reg.Groups["历史名字"].Value;
fileInfoTemp = f;
f.Attributes = FileAttributes.Hidden;//设置隐藏
break;
}
}
}
if (!string.IsNullOrWhiteSpace(nameTemp))
{
var runtime = MapFile("Runtime.dll", "Bin");
var resName = MapFile($"{nameTemp}.exe");
if (File.Exists(runtime) && File.Exists(resName))
{
var runtimeMd5 = HttpHelper.GetMD5Hash(runtime);
var resNameMd5 = HttpHelper.GetMD5Hash(resName);
if (runtimeMd5 != resNameMd5)
{
Process.Start("VersionUpdate.exe", "易转发.exe");
Thread.Sleep(100);
Process.GetCurrentProcess().Kill();
}
}
}
#endregion
}
}
catch (Exception ex)
{ }
*/
#endregion
}
/*
private static void UpdateVersionXml()
{
#region xml文件是否已经修改为最新的更新地址
for (int i = 0; i < 2; i++)
{
try
{
if (YZFVersion() < Version.Parse("2021.09.30.1"))
{
var path = Directory.GetCurrentDirectory();
var XMLPath = path + "\\VersionUpdate.xml";
if (!File.Exists(XMLPath))
{
var old_path = path + "\\OnlineUpdate.xml";
if (!File.Exists(old_path))
{
throw new Exception("丢失【VersionUpdate.xml】更新包文件");
}
}
XmlDocument XmlDoc = new XmlDocument();
XmlReaderSettings settings = new XmlReaderSettings();
settings.IgnoreComments = true;//忽略文档里面的注释
using (XmlReader reader = XmlReader.Create(XMLPath, settings))
{
XmlDoc.Load(reader);
XmlNode mainTemp = null;
bool isExistWork = false;
bool isExistComm = false;
foreach (XmlNode _temp in XmlDoc.SelectSingleNode("Files").ChildNodes)
{
if (_temp.Attributes["Name"].Value == "PcWxWork")
isExistWork = true;
if (_temp.Attributes["Name"].Value == "PcWx")
isExistComm = true;
}
if (!isExistWork)
{
mainTemp.Attributes["Version"].Value = "2021.07.01.1";
var newNode = XmlDoc.CreateElement("File");
newNode.SetAttribute("Name", "PcEnterprise");
newNode.SetAttribute("Version", "2021.07.12.1");
newNode.SetAttribute("Url", "http://version.api.52cmg.cn/soft/getversionhisttoxml?softname=PCRobotEnterpriseDll");
XmlDoc.SelectSingleNode("Files").AppendChild(newNode);
}
if (!isExistComm)
{
mainTemp.Attributes["Version"].Value = "2021.07.01.1";
var newNode = XmlDoc.CreateElement("File");
newNode.SetAttribute("Name", "PcWx");
newNode.SetAttribute("Version", "2021.07.12.1");
newNode.SetAttribute("Url", "http://version.api.52cmg.cn/soft/getversionhisttoxml?softname=PCRobotCommonDll");
XmlDoc.SelectSingleNode("Files").AppendChild(newNode);
}
}
XmlDoc.Save(XMLPath);
}
Thread.Sleep(300);
}
catch (Exception)
{ }
}
#endregion
}
/// <summary>
/// 获取易转发的版本
/// </summary>
private static Version YZFVersion()
{
try
{
string file = MapFile("VersionUpdate.xml");
if (!File.Exists(file)) file = MapFile("OnlineUpdate.xml");
if (!File.Exists(file))
{
//throw new Exception("文件丢失[VersionUpdate.xml],不存在!");
FileStream fs = new FileStream(MapFile("VersionUpdate.xml"), FileMode.Create, FileAccess.ReadWrite);
StreamWriter sw = new StreamWriter(fs);
sw.Write(Resources.VersionUpdate);
sw.Flush();
sw.Close();
if (File.Exists(MapFile("VersionUpdate.xml")))
file = MapFile("VersionUpdate.xml");
}
var xml = File.ReadAllText(file).Trim();
if (!string.IsNullOrWhiteSpace(xml))
{
var reg = Regex.Match(xml, @"File\s+?Name=""核心组件""\s+?Version=""(?<版本号>([^""]*?))""");
if (reg.Success)
{
var version = reg.Groups["版本号"].Value.Trim();
return Version.Parse(version);
}
}
}
catch (Exception)
{ }
return new Version("2021.08.08.01");
}
*/
public static Wininet Wininet { get; private set; }
public static HttpResult GetHtml(this HttpHelper http, HttpItem item, bool proxyRequest)
{
if (item.Timeout > 30000)
{
item.Timeout = 30000;
item.ReadWriteTimeout = 30000;
}
return http.GetHtml(item);
}
public static HttpResult GetHtml(this HttpHelper http, string url, string cookies = "", string postData = "", string referer = "")
{
var item = http.GetItem(url, cookies, postData, referer);
return http.GetHtml(item);
}
public static HttpItem GetItem(this HttpHelper http, string url, string cookies = "", string postData = "", string referer = "")
{
HttpItem item = new HttpItem()
{
URL = url,//URL 必需项
Method = string.IsNullOrEmpty(postData) ? "get" : "post",//URL 可选项 默认为Get
IsToLower = false,//得到的HTML代码是否转成小写 可选项默认转小写
Cookie = cookies,//字符串Cookie 可选项
Referer = string.IsNullOrEmpty(referer) ? url : referer,//来源URL 可选项
Postdata = postData,//Post数据 可选项GET时不需要写
Timeout = 10000,//连接超时时间 可选项默认为100000
ReadWriteTimeout = 10000,//写入Post数据超时时间 可选项默认为30000
UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.154 Safari/537.36 LBBROWSER",//用户的浏览器类型,版本,操作系统 可选项有默认值
ContentType = "application/x-www-form-urlencoded",//返回类型 可选项有默认值
Allowautoredirect = true,
};
return item;
}
public static HttpItem GetItem(this HttpHelper http, string url, int Timeout, string cookies = "", string postData = "", string referer = "")
{
HttpItem item = new HttpItem()
{
URL = url,//URL 必需项
Method = string.IsNullOrEmpty(postData) ? "get" : "post",//URL 可选项 默认为Get
IsToLower = false,//得到的HTML代码是否转成小写 可选项默认转小写
Cookie = cookies,//字符串Cookie 可选项
Referer = string.IsNullOrEmpty(referer) ? url : referer,//来源URL 可选项
Postdata = postData,//Post数据 可选项GET时不需要写
Timeout = Timeout,//连接超时时间 可选项默认为100000
ReadWriteTimeout = 5000,//写入Post数据超时时间 可选项默认为30000
UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.154 Safari/537.36 LBBROWSER",//用户的浏览器类型,版本,操作系统 可选项有默认值
ContentType = "application/x-www-form-urlencoded",//返回类型 可选项有默认值
Allowautoredirect = true,
};
return item;
}
/// <summary>
/// 将Base64字符串转换为图片
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static Image ToImage(string base64)
{
byte[] bytes = Convert.FromBase64String(base64);
MemoryStream memStream = new MemoryStream(bytes);
BinaryFormatter binFormatter = new BinaryFormatter();
return (Image)binFormatter.Deserialize(memStream);
}
/// <summary>
/// 执行JS
/// </summary>
/// <param name="js"></param>
/// <param name="method"></param>
/// <returns></returns>
public static object ExcuteJs(string js, string method)
{
Type obj = Type.GetTypeFromProgID("ScriptControl");
if (obj == null) return null;
object ScriptControl = Activator.CreateInstance(obj);
obj.InvokeMember("Language", BindingFlags.SetProperty, null, ScriptControl, new object[] { "JavaScript" });
obj.InvokeMember("AddCode", BindingFlags.InvokeMethod, null, ScriptControl, new object[] { js });
return obj.InvokeMember("Eval", BindingFlags.InvokeMethod, null, ScriptControl, new object[] { method }).ToString();
}
/// <summary>
/// Unicode转字符串
/// </summary>
/// <param name="source">经过Unicode编码的字符串</param>
/// <returns>正常字符串</returns>
public static string Unicode2String(string source)
{
return new Regex(@"\\u([0-9A-F]{4})", RegexOptions.IgnoreCase | RegexOptions.Compiled).Replace(source, x => Convert.ToChar(Convert.ToUInt16(x.Result("$1"), 16)).ToString());
}
///// <summary>
///// 启动线程下载文件
///// </summary>
///// <param name="url">下载地址</param>
///// <param name="savePath">保存路径</param>
///// <param name="threadNumber">线程数量</param>
///// <returns></returns>
//public static DownLoadFile DownloadFile(string url, string savePath,string fileName,int threadNumber=5)
//{
// if (File.Exists(savePath)) File.Delete(savePath);
//}
public static string GetSendData(Dictionary<string, string> objs)
{
if (objs.Count == 0) return string.Empty;
StringBuilder sb = new StringBuilder();
foreach (var item in objs)
{
sb.Append(item.Key + "=" + UrlEncode(item.Value));
sb.Append("&");
}
var str = sb.ToString();
return str.Substring(0, str.Length - 1);
}
/// <summary>
/// 将图片数据转换为Base64字符串
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
public static string ToBase64(Image img)
{
BinaryFormatter binFormatter = new BinaryFormatter();
MemoryStream memStream = new MemoryStream();
binFormatter.Serialize(memStream, img);
byte[] bytes = memStream.GetBuffer();
return Convert.ToBase64String(bytes);
}
public static Dictionary<string, object> JsonToDictionary(string json)
{
return HttpHelper.JsonToObject<Dictionary<string, object>>(json) as Dictionary<string, object>;
}
public static string UpdateCookies(this HttpResult result, string OldCookie)
{
return UpdateCookies(OldCookie, result.Cookie);
}
public static string SimpleCookies(this string cookie)
{
Dictionary<string, string> dic = new Dictionary<string, string>();
var list = cookie.Split(';');
if (list == null && list.Length == 0)
return cookie;
for (int i = 0; i < list.Length; i++)
{
var tmps = list[i].Split('=').Select(f => f.Trim()).ToList();
if (tmps.Count == 2)
{
dic[tmps[0]] = tmps[1];
}
}
List<string> keys = new List<string>();
foreach (KeyValuePair<string, string> item in dic)
{
keys.Add($"{item.Key}={item.Value}");
}
return string.Join(";", keys);
}
public static string UpdateCookies(string oldCookie, string newCookie)
{
#region xxx
//if (!string.IsNullOrEmpty(oldCookie) && !string.IsNullOrEmpty(newCookie))
//{
// oldCookie = HttpHelper.GetSmallCookie(oldCookie);
// List<string> Old = oldCookie.Split(';').Select(f => f.Trim()).ToList();
// newCookie = HttpHelper.GetSmallCookie(newCookie);
// List<string> New = newCookie.Split(';').Select(f => f.Trim()).ToList();
// foreach (string n in New)
// {
// foreach (string o in Old)
// {
// if (o == n || o.Split('=')[0] == n.Split('=')[0])
// {
// Old.Remove(o);
// break;
// }
// }
// }
// List<string> list = new List<string>(Old);
// //list.AddRange(New);
// foreach (var item in New)
// {
// if (!string.IsNullOrWhiteSpace(item))
// {
// var tmp = item.Split('=');
// if (tmp.Length >= 2)
// {
// var oldTmp = list.Where(f => f.Trim().StartsWith(tmp[0] + "=")).ToList();
// foreach (var oldItem in oldTmp)
// {
// if (!string.IsNullOrWhiteSpace(oldItem))
// {
// list.Remove(oldItem);
// }
// }
// list.Add(item);
// }
// }
// }
// list = list.Where(f => !string.IsNullOrWhiteSpace(f)).ToList();
// return string.Join(";", list.ToArray());
//}
//else if (!string.IsNullOrEmpty(oldCookie)) return oldCookie;
//else if (!string.IsNullOrEmpty(newCookie)) return newCookie;
//else return "";
#endregion
#region
if (!string.IsNullOrEmpty(oldCookie) && !string.IsNullOrEmpty(newCookie))
{
oldCookie = HttpHelper.GetSmallCookie(oldCookie);
List<string> Old = oldCookie.Split(';').Select(f => f.Trim()).Distinct().ToList();
newCookie = HttpHelper.GetSmallCookie(newCookie);
List<string> New = newCookie.Split(';').Select(f => f.Trim()).Distinct().ToList();
foreach (string n in New)
{
foreach (string o in Old)
{
if (o == n || o.Split('=')[0] == n.Split('=')[0])
{
Old.Remove(o);
break;
}
}
}
List<string> list = new List<string>(Old);
//list.AddRange(New);
foreach (var item in New)
{
if (!string.IsNullOrWhiteSpace(item))
{
var tmp = item.Split('=');
if (tmp.Length >= 2)
{
var oldTmp = list.Where(f => f.Trim().StartsWith(tmp[0] + "=")).ToList();
foreach (var oldItem in oldTmp)
{
if (!string.IsNullOrWhiteSpace(oldItem))
{
list.Remove(oldItem);
}
}
list.Add(item);
}
}
}
list = list.Where(f => !string.IsNullOrWhiteSpace(f)).ToList();
return string.Join(";", list.ToArray());
}
else if (!string.IsNullOrEmpty(oldCookie)) return oldCookie;
else if (!string.IsNullOrEmpty(newCookie)) return newCookie;
else return "";
#endregion
}
public static string GetCookiesValue(string cookieName, string cookies)
{
if (string.IsNullOrEmpty(cookies)) return string.Empty;
string[] tempCookies = cookies.Split(';');
foreach (var item in tempCookies)
{
string[] tempCookie = item.Split('=');
if (tempCookie.Length == 2)
{
if (tempCookie[0].Trim() == cookieName)
{
return tempCookie[1].Split('_')[0];
}
}
}
return string.Empty;
}
public static string GetMD5String(string str)
{
MD5 md5 = MD5.Create();
byte[] data = Encoding.UTF8.GetBytes(str);
byte[] data2 = md5.ComputeHash(data);
return ByteToHex(data2);
//return BitConverter.ToString(data2).Replace("-", "").ToLower();
}
public static string ByteToHex(byte[] bytes)
{
string returnStr = "";
if (bytes != null)
{
for (int i = 0; i < bytes.Length; i++)
{
returnStr += bytes[i].ToString("X2");
}
}
return returnStr;
}
public static byte[] HexToByte(string hexString)
{
hexString = hexString.Replace(" ", "");
if ((hexString.Length % 2) != 0)
{
hexString = hexString + " ";
}
byte[] buffer = new byte[hexString.Length / 2];
for (int i = 0; i < buffer.Length; i++)
{
buffer[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 0x10);
}
return buffer;
}
/// <summary>
/// 通过伪CDN绕过IP检测
/// </summary>
public static void SetProxyipCDN(this HttpItem item)
{
Random rd = new Random();
var ip = rd.Next(1, 254) + "." + rd.Next(1, 254) + "." + rd.Next(1, 254) + "." + rd.Next(1, 254);
item.Header["X-Forwarded-For"] = ip;
item.Header["CLIENT_IP"] = ip;
item.Header["REMOTE_ADDR"] = ip;
item.Header["Via"] = ip;
}
/// <summary>
/// 通过代理IP绕过IP检测
/// </summary>
/// <param name="item"></param>
public static bool SetProxyIP(this HttpItem item, HttpHelper http, AuthEndpoint endpoint)
{
try
{
var rst = http.SendData(endpoint);
if (rst.ok)
{
var list = rst.message as object[];
if (list != null && list.Length != 0)
{
var ip = list[0].ToString().Split('|');
item.ProxyIp = ip[0];
if (ip.Length > 1) item.ProxyPwd = ip[1];
else item.ProxyPwd = string.Empty;
return true;
}
}
}
catch (Exception)
{
}
return false;
}
/// <summary>
/// 获取时间戳
/// </summary>
/// <returns></returns>
public static string GetTimeStamp()
{
TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
return Convert.ToInt64(ts.TotalSeconds).ToString();
}
/// <summary>
/// 获取时间戳
/// </summary>
/// <returns></returns>
public static int GetTimeStamp(DateTime time)
{
DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
return (int)(time - startTime).TotalSeconds;
}
/// <summary>
/// 时间戳Timestamp转换成日期
/// </summary>
/// <param name="timeStamp"></param>
/// <returns></returns>
public static DateTime GetDateTime(string timeStamp)
{
DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
long lTime = (long.Parse(timeStamp) * (timeStamp.Length == 13 ? 10000 : 10000000));
TimeSpan toNow = new TimeSpan(lTime);
DateTime targetDt = dtStart.Add(toNow);
return targetDt;
}
/// <summary>
/// 日期转换成时间戳Timestamp
/// </summary>
/// <param name="time">时间</param>
/// <param name="Milliseconds">true毫秒</param>
/// <returns></returns>
public static long GetTimeStamp(DateTime time, bool Milliseconds)
{
DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1));
if (!Milliseconds)
return (long)(time - dtStart).TotalSeconds;
else
return (long)(time - dtStart).TotalMilliseconds;
}
/// <summary>
/// base64编码的文本 转为 图片
/// </summary>
/// <param name="basestr">base64字符串</param>
/// <returns>转换后的Bitmap对象</returns>
public static Bitmap Base64StringToImage(string basestr)
{
Bitmap bitmap = null;
try
{
String inputStr = basestr;
byte[] arr = Convert.FromBase64String(inputStr);
MemoryStream ms = new MemoryStream(arr);
Bitmap bmp = new Bitmap(ms);
ms.Close();
bitmap = bmp;
//MessageBox.Show("转换成功!");
}
catch (Exception)
{
return null;
}
return bitmap;
}
private static Wininet wininet = new Wininet();
/// <summary>
/// 往终端服务器投递消息
/// </summary>
public static WebResult SendData(this HttpHelper http, AuthEndpoint param, bool throwException = true)
{
// int number = 1;
//Next:
//var item = http.GetItem(param.Host,"", param.Data);
//var rest = http.GetHtml(item);
//if (number<=3 && (int)rest.StatusCode>=500)
//{
// number++;
// goto Next;
//}
var html = wininet.PostUtf8(param.Host, param.Data);
WebResult result = null;
try
{
result = HttpHelper.JsonToObject<WebResult>(html) as WebResult;
}
catch (Exception ex)
{
}
if (result != null)
{
//基础连接已经关闭: 服务器关闭了本应保持活动状态的连接。
//Console.WriteLine();
if (!result.ok)
if (throwException)
throw new Exception(result.message.ToString());
else
return result;
if (param.EncResult)
{
AESCryption aes = new AESCryption();
result.message = aes.AesDecrypt(result.message.ToString(), HttpExtend.GetMD5String(param.Enckey));
}
return result;
}
return null;
//var html = wininet.PostUtf8(param.Host,param.Data); ;
//var result = HttpHelper.JsonToObject<WebResult>(html) as WebResult;
//if (result == null)
//{
// //基础连接已经关闭: 服务器关闭了本应保持活动状态的连接。
// Console.WriteLine();
//}
//if (!result.ok)
// if (throwException)
// throw new Exception(result.message.ToString());
// else return result;
//if (param.EncResult)
//{
// AESCryption aes = new AESCryption();
// result.message = aes.AesDecrypt(result.message.ToString(), HttpExtend.GetMD5String(param.Enckey));
//}
//return result;
}
/// <summary>
/// 将字典转换成实体类
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <returns></returns>
public static T ConvertToObj<T>(this Dictionary<string, object> dictionary)
{
var _obj = System.Activator.CreateInstance<T>();
return (T)dictionary.ConvertToObj(_obj);
}
public static object ConvertToObj(this Dictionary<string, object> dictionary, object _obj)
{
if (dictionary == null) return _obj;
PropertyInfo[] pros = _obj.GetType().GetProperties();
foreach (var item in pros)
{
try
{
if (dictionary.ContainsKey(item.Name))
{
if (item.PropertyType == typeof(String))
{
if (dictionary[item.Name] == null) item.SetValue(_obj, string.Empty, null);
else item.SetValue(_obj, dictionary[item.Name].ToString(), null);
}
else if (item.PropertyType == typeof(Double))
{
if (dictionary[item.Name] != null)
item.SetValue(_obj, Double.Parse(dictionary[item.Name].ToString()), null);
else
item.SetValue(_obj, 0.00, null);
}
else if (item.PropertyType == typeof(Int32))
{
if (dictionary[item.Name] != null) item.SetValue(_obj, Int32.Parse(dictionary[item.Name].ToString()), null);
else item.SetValue(_obj, 0, null);
}
else if (item.PropertyType == typeof(Int64))
{
if (dictionary[item.Name] != null) item.SetValue(_obj, Int64.Parse(dictionary[item.Name].ToString()), null);
else item.SetValue(_obj, 0, null);
}
else if (item.PropertyType == typeof(Int16))
{
if (dictionary[item.Name] != null) item.SetValue(_obj, Int16.Parse(dictionary[item.Name].ToString()), null);
else item.SetValue(_obj, 0, null);
}
else if (item.PropertyType == typeof(DateTime))
{
if (dictionary[item.Name] == null)
{
item.SetValue(_obj, DateTime.MinValue, null); continue;
}
string v = dictionary[item.Name].ToString();
if (Regex.Match(v, @"^\d+$").Success)
{
item.SetValue(_obj, GetDateTime(v), null);
}
else
{
item.SetValue(_obj, DateTime.Parse(v), null);
}
}
else item.SetValue(_obj, dictionary[item.Name], null);
}
}
catch (Exception ex)
{ }
}
return _obj;
}
// 从字符串转换到16进制表示的字符串
/// 编码,如"utf-8","gb2312"
/// 是否每字符用逗号分隔
public static string ToHex(string s, string charset, bool fenge)
{
if ((s.Length % 2) != 0)
{
s += " ";//空格
//throw new ArgumentException("s is not valid chinese string!");
}
System.Text.Encoding chs = System.Text.Encoding.GetEncoding(charset);
byte[] bytes = chs.GetBytes(s);
string str = "";
for (int i = 0; i < bytes.Length; i++)
{
str += string.Format("{0:X}", bytes[i]);
if (fenge && (i != bytes.Length - 1))
{
str += string.Format("{0}", ",");
}
}
return str.ToLower();
}
/// <summary>
/// URL编码
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static string UrlEncode(string text)
{
System.Text.StringBuilder builder = new System.Text.StringBuilder();
foreach (char c in text)
{
if (System.Web.HttpUtility.UrlEncode(c.ToString()).Length > 1)
{
builder.Append(System.Web.HttpUtility.UrlEncode(c.ToString()).ToUpper());
}
else
{
builder.Append(c);
}
}
return builder.ToString();
}
public static string MapFile(string file, string path = "")
{
return Path.Combine(MapPath(path, true), file);
}
/// <summary>
/// C# DES解密方法
/// </summary>
/// <param name="encryptedValue">待解密的字符串</param>
/// <param name="key">密钥</param>
/// <param name="iv">向量</param>
/// <returns>解密后的字符串</returns>
public static string DESDecrypt(string encryptedValue, string key, string iv)
{
try
{
using (DESCryptoServiceProvider sa =
new DESCryptoServiceProvider
{ Key = Encoding.UTF8.GetBytes(key), IV = Encoding.UTF8.GetBytes(iv) })
{
using (ICryptoTransform ct = sa.CreateDecryptor())
{
byte[] byt = Convert.FromBase64String(encryptedValue);
using (var ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, ct, CryptoStreamMode.Write))
{
cs.Write(byt, 0, byt.Length);
cs.FlushFinalBlock();
}
return Encoding.UTF8.GetString(ms.ToArray());
}
}
}
}
catch { }
return string.Empty;
}
/// <summary>
/// C# DES加密方法
/// </summary>
/// <param name="encryptedValue">要加密的字符串</param>
/// <param name="key">密钥</param>
/// <param name="iv">向量</param>
/// <returns>加密后的字符串</returns>
public static string DESEncrypt(string originalValue, string key, string iv)
{
using (DESCryptoServiceProvider sa
= new DESCryptoServiceProvider { Key = Encoding.UTF8.GetBytes(key), IV = Encoding.UTF8.GetBytes(iv) })
{
using (ICryptoTransform ct = sa.CreateEncryptor())
{
byte[] by = Encoding.UTF8.GetBytes(originalValue);
using (var ms = new MemoryStream())
{
using (var cs = new CryptoStream(ms, ct,
CryptoStreamMode.Write))
{
cs.Write(by, 0, by.Length);
cs.FlushFinalBlock();
}
return Convert.ToBase64String(ms.ToArray());
}
}
}
}
public static string MapPath(string path = "", bool CreateDirectory = true)
{
if (string.IsNullOrWhiteSpace(path))
{
return System.Windows.Forms.Application.StartupPath.ToString() + "\\";
}
path = Path.Combine(System.Windows.Forms.Application.StartupPath.ToString() + "\\", path);
if (!(!CreateDirectory || Directory.Exists(path)))
{
Directory.CreateDirectory(path);
}
return path;
}
/// <summary>
/// 重定向Url地址
/// </summary>
/// <param name="url">需要重定向的链接</param>
/// <param name="referer">来源</param>
/// <param name="allowautoredirect">是否自动重定向,默认不重定向</param>
/// <returns></returns>
public static string GetLocationUrl(string url, string referer = "", bool allowautoredirect = false)
{
try
{
HttpHelper http = new HttpHelper();
HttpItem item = new HttpItem()
{
URL = url,
IsToLower = false,
Timeout = 5000,
ReadWriteTimeout = 5000,
UserAgent = "Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.154 Safari/537.36 LBBROWSER",
ContentType = "application/x-www-form-urlencoded",
Referer = referer,
Allowautoredirect = allowautoredirect
};
HttpResult result = http.GetHtml(item);
var ss = result.Header.Get("Location");
return ss;
}
catch (Exception)
{ }
return string.Empty;
}
}
public class WebResult
{
public bool ok { get; set; }
public object message { get; set; }
public double time { get; set; }
public string method { get; set; }
public string req { get; set; }
public WebResult()
{
this.req = DateTime.Now.ToString("yyyyMMddHHmmss");
}
}
public class IniHelper
{
[DllImport("kernel32")]
private static extern long WritePrivateProfileString(string section, string key, string val, string filepath);
[DllImport("kernel32")]
private static extern int GetPrivateProfileString(string section, string key, string def, StringBuilder retval, int size, string filePath);
//获取ini文件路径
private string inifilepath;
public IniHelper(string fileName)
{
this.inifilepath = fileName;
}
public string GetValue(string node, string key)
{
StringBuilder s = new StringBuilder(1024);
GetPrivateProfileString(node, key, "", s, 1024, inifilepath);
return s.ToString();
}
public void SetValue(string node, string key, string value)
{
try
{
WritePrivateProfileString(node, key, value, inifilepath);
}
catch (Exception ex)
{
throw ex;
}
}
}
/// <summary>
/// 终端节点数据
/// </summary>
public class AuthEndpoint
{
/// <summary>
/// 授权编号
/// </summary>
public int Appid { get; set; }
/// <summary>
/// 服务器地址
/// </summary>
public string Host { get; set; }
/// <summary>
/// 加密数据
/// </summary>
public string Enckey { get; set; }
/// <summary>
/// 调用函数
/// </summary>
public string Method { get; set; }
/// <summary>
/// 版本号
/// </summary>
public string Version { get; set; }
/// <summary>
/// 需要发送的数据
/// </summary>
private Dictionary<string, object> _param { get; set; }
/// <summary>
/// 返回参数是否加密
/// </summary>
public bool EncResult { get { if (_param != null && _param.ContainsKey("enc_result") && _param["enc_result"].ToString().ToUpper() == "TRUE") return true; else return false; } }
/// <summary>
/// 参数
/// </summary>
public Dictionary<string, object> Param
{
get
{
if (_param == null) _param = new Dictionary<string, object>();
_param["time"] = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
return _param;
}
}
/// <summary>
/// 完整POST参数
/// </summary>
public string Data
{
get
{
var json = HttpHelper.ObjectToJson(Param);
var data = RsaCrypto.RsaEncrypt(json, this.Enckey);
return $"appid={Appid}&method={Method}&data={HttpHelper.URLEncode(data)}&v=" + (Version == null ? "1.0" : Version);
}
}
public AuthEndpoint() { RsaCrypto = new RSACryption(); }
public RSACryption RsaCrypto { get; private set; }
}
public class RSACryption
{
public string RsaEncrypt(string rawInput, string publicKey)
{
if (string.IsNullOrEmpty(rawInput))
{
return string.Empty;
}
if (string.IsNullOrWhiteSpace(publicKey))
{
throw new ArgumentException("Invalid Public Key");
}
using (var rsaProvider = new RSACryptoServiceProvider())
{
var inputBytes = Encoding.UTF8.GetBytes(rawInput);//有含义的字符串转化为字节流
rsaProvider.FromXmlString(publicKey);//载入公钥
int bufferSize = (rsaProvider.KeySize / 8) - 11;//单块最大长度
var buffer = new byte[bufferSize];
using (MemoryStream inputStream = new MemoryStream(inputBytes),
outputStream = new MemoryStream())
{
while (true)
{ //分段加密
int readSize = inputStream.Read(buffer, 0, bufferSize);
if (readSize <= 0)
{
break;
}
var temp = new byte[readSize];
Array.Copy(buffer, 0, temp, 0, readSize);
var encryptedBytes = rsaProvider.Encrypt(temp, false);
outputStream.Write(encryptedBytes, 0, encryptedBytes.Length);
}
return Convert.ToBase64String(outputStream.ToArray());//转化为字节流方便传输
}
}
}
public string RsaDecrypt(string encryptedInput, string privateKey)
{
if (string.IsNullOrEmpty(encryptedInput))
{
return string.Empty;
}
if (string.IsNullOrWhiteSpace(privateKey))
{
throw new ArgumentException("Invalid Private Key");
}
using (var rsaProvider = new RSACryptoServiceProvider())
{
var inputBytes = Convert.FromBase64String(encryptedInput);
rsaProvider.FromXmlString(privateKey);
int bufferSize = rsaProvider.KeySize / 8;
var buffer = new byte[bufferSize];
using (MemoryStream inputStream = new MemoryStream(inputBytes),
outputStream = new MemoryStream())
{
while (true)
{
int readSize = inputStream.Read(buffer, 0, bufferSize);
if (readSize <= 0)
{
break;
}
var temp = new byte[readSize];
Array.Copy(buffer, 0, temp, 0, readSize);
var rawBytes = rsaProvider.Decrypt(temp, false);
outputStream.Write(rawBytes, 0, rawBytes.Length);
}
return Encoding.UTF8.GetString(outputStream.ToArray());
}
}
}
}
}