435 lines
14 KiB
C#
435 lines
14 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Web;
|
|
using Newtonsoft.Json;
|
|
using Newtonsoft.Json.Linq;
|
|
using static ProtoBuf.Serializer;
|
|
|
|
namespace BarrageGrab
|
|
{
|
|
/// <summary>
|
|
/// 扩展类
|
|
/// </summary>
|
|
public static class ObjectExtension
|
|
{
|
|
/// <summary>
|
|
/// 判断字符串是否为空或空白
|
|
/// </summary>
|
|
public static bool IsNullOrWhiteSpace(this string str) => string.IsNullOrWhiteSpace(str);
|
|
|
|
/// <summary>
|
|
/// 判断字符串是否为空
|
|
/// </summary>
|
|
public static bool IsNullOrEmpty(this string str) => string.IsNullOrEmpty(str);
|
|
|
|
/// <summary>
|
|
/// 转为Json
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
/// <returns></returns>
|
|
public static string ToJson(this object obj,bool format = false)
|
|
{
|
|
if (obj is string)
|
|
{
|
|
return obj.ToString();
|
|
}
|
|
return JsonConvert.SerializeObject(obj, format?Formatting.Indented:Formatting.None);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 转为对象
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="json"></param>
|
|
/// <returns></returns>
|
|
public static T AsObject<T>(this string json)
|
|
{
|
|
return JsonConvert.DeserializeObject<T>(json);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取Value或其Value默认值
|
|
/// </summary>
|
|
public static TValue ValueOrDefault<Tkey, TValue>(this IDictionary<Tkey, TValue> dic, Tkey key)
|
|
{
|
|
if (dic.ContainsKey(key))
|
|
{
|
|
return dic[key];
|
|
}
|
|
return default(TValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取Value或其Value默认值
|
|
/// </summary>
|
|
public static TValue ValueOrDefault<Tkey, TValue>(this IDictionary<Tkey, TValue> dic, Tkey key, TValue defaultValue)
|
|
{
|
|
if (dic.ContainsKey(key))
|
|
{
|
|
return dic[key];
|
|
}
|
|
return defaultValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 遍历集合
|
|
/// </summary>
|
|
public static void Foreach<T>(this IEnumerable<T> list, Action<T> func)
|
|
{
|
|
foreach (var item in list) func(item);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 遍历集合
|
|
/// </summary>
|
|
public static void Foreach<T>(this IEnumerable<T> list, Action<T, int> func)
|
|
{
|
|
int i = 0;
|
|
foreach (var item in list) func(item, i++);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 是否包含
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
/// <param name="args"></param>
|
|
/// <returns></returns>
|
|
public static bool In<T>(this T obj, params T[] args)
|
|
{
|
|
return args.Contains(obj);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 是否包含
|
|
/// </summary>
|
|
/// <param name="obj"></param>
|
|
/// <param name="args"></param>
|
|
/// <returns></returns>
|
|
public static bool LikeIn(this string str, params string[] args)
|
|
{
|
|
return args.Any(a => str.Contains(a));
|
|
}
|
|
|
|
public static CookieCollection ToCookies(this string cookieStr, string domain)
|
|
{
|
|
var cookies = new CookieCollection();
|
|
if (!string.IsNullOrEmpty(cookieStr))
|
|
{
|
|
var cookieArray = cookieStr.Split(';');
|
|
foreach (var cookie in cookieArray)
|
|
{
|
|
var cookieParts = cookie.Split('=');
|
|
if (cookieParts.Length == 2)
|
|
{
|
|
var cookieName = cookieParts[0].Trim();
|
|
var cookieValue = cookieParts[1].Trim();
|
|
var newCookie = new Cookie(cookieName, Uri.EscapeDataString(cookieValue));
|
|
newCookie.Path = "/";
|
|
newCookie.Domain = domain;
|
|
cookies.Add(newCookie);
|
|
}
|
|
}
|
|
}
|
|
return cookies;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 追加另一个字典
|
|
/// </summary>
|
|
/// <param name="dic"></param>
|
|
/// <param name="other"></param>
|
|
/// <returns></returns>
|
|
public static IDictionary<string, string> Append(this IEnumerable<KeyValuePair<string, string>> dic, IEnumerable<KeyValuePair<string, string>> other)
|
|
{
|
|
var res = new Dictionary<string, string>();
|
|
foreach (var item in dic)
|
|
{
|
|
res.Add(item.Key, item.Value);
|
|
}
|
|
foreach (var item in other)
|
|
{
|
|
if (res.ContainsKey(item.Key))
|
|
{
|
|
res[item.Key] = item.Value;
|
|
}
|
|
else
|
|
{
|
|
res.Add(item.Key, item.Value);
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 转换为Cookie对象列表
|
|
/// </summary>
|
|
/// <param name="dic"></param>
|
|
/// <param name="domain"></param>
|
|
/// <returns></returns>
|
|
public static CookieCollection ToCookies(this IDictionary<string, string> dic, string domain)
|
|
{
|
|
var cookieCollection = new CookieCollection();
|
|
foreach (var item in dic)
|
|
{
|
|
cookieCollection.Add(new Cookie(item.Key, item.Value, "/", domain));
|
|
}
|
|
return cookieCollection;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加Cookie
|
|
/// </summary>
|
|
/// <param name="cookies"></param>
|
|
/// <param name="dic"></param>
|
|
/// <param name="domain"></param>
|
|
public static void PushCookies(this CookieContainer cookies, string domain, IDictionary<string, string> dic)
|
|
{
|
|
if (cookies == null) return;
|
|
var cookieCollection = dic.ToCookies(domain);
|
|
cookies.Add(cookieCollection);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 将字典转为查询参数
|
|
/// </summary>
|
|
/// <param name="dic"></param>
|
|
/// <returns></returns>
|
|
public static string ToQueryParam(this IDictionary<string, string> dic, bool encode = true)
|
|
{
|
|
if (dic == null || dic.Count == 0)
|
|
return string.Empty;
|
|
|
|
var queryParams = dic.Select(kvp => kvp.Key + "=" + (encode ? WebUtility.UrlEncode(kvp.Value) : kvp.Value));
|
|
return string.Join("&", queryParams);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 赋值字典，没有则添加，有则覆盖
|
|
/// </summary>
|
|
/// <typeparam name="TKey"></typeparam>
|
|
/// <typeparam name="TValue"></typeparam>
|
|
/// <param name="dic"></param>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
public static void Set<TKey, TValue>(this IDictionary<TKey, TValue> dic, TKey key, TValue value)
|
|
{
|
|
if (dic.ContainsKey(key))
|
|
{
|
|
dic[key] = value;
|
|
}
|
|
else
|
|
{
|
|
dic.Add(key, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 赋值字典，没有则添加，有则覆盖
|
|
/// </summary>
|
|
/// <typeparam name="TKey"></typeparam>
|
|
/// <typeparam name="TValue"></typeparam>
|
|
/// <param name="dic"></param>
|
|
/// <param name="kv"></param>
|
|
public static void Set<TKey, TValue>(this IDictionary<TKey, TValue> dic, KeyValuePair<TKey, TValue> kv)
|
|
{
|
|
dic.Set(kv.Key, kv.Value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取Uri查询参数
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentNullException"></exception>
|
|
public static IDictionary<string, string> GetQueryParams(this UriBuilder uri)
|
|
{
|
|
if (uri == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(uri));
|
|
}
|
|
|
|
var queryParams = uri.Query.TrimStart('?');
|
|
|
|
if (string.IsNullOrEmpty(queryParams))
|
|
{
|
|
return new Dictionary<string, string>();
|
|
}
|
|
|
|
return queryParams
|
|
.Split('&')
|
|
.Select(param => param.Split('='))
|
|
.ToDictionary(
|
|
keyValuePair => Uri.UnescapeDataString(keyValuePair[0]),
|
|
keyValuePair => Uri.UnescapeDataString(keyValuePair.Length > 1 ? keyValuePair[1] : ""));
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <param name="vals"></param>
|
|
public static void AddQueryParam(this UriBuilder uri, IEnumerable<KeyValuePair<string, string>> vals)
|
|
{
|
|
if (uri == null) return;
|
|
var dic = uri.GetQueryParams();
|
|
foreach (var item in vals)
|
|
{
|
|
dic.Set(item);
|
|
}
|
|
uri.Query = dic.ToQueryParam();
|
|
}
|
|
|
|
/// <summary>
|
|
/// 删除一个query项
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <param name="key"></param>
|
|
public static void RemoveQueryParam(this UriBuilder uri, string key)
|
|
{
|
|
if (uri == null) return;
|
|
var dic = uri.GetQueryParams();
|
|
dic.Remove(key);
|
|
if (dic.Count > 0)
|
|
{
|
|
uri.Query = "?" + dic.ToQueryParam();
|
|
}
|
|
else
|
|
{
|
|
uri.Query = "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加参数
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <param name="key"></param>
|
|
/// <param name="value"></param>
|
|
/// <returns></returns>
|
|
public static void AddQueryParam(this UriBuilder uri, string key, string value)
|
|
{
|
|
if (uri == null) return;
|
|
uri.AddQueryParam(new[] {
|
|
new KeyValuePair<string, string>(key,value)
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取Uri查询参数
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <returns></returns>
|
|
/// <exception cref="ArgumentNullException"></exception>
|
|
public static IDictionary<string, string> GetQueryParams(this Uri uri)
|
|
{
|
|
if (uri == null)
|
|
{
|
|
throw new ArgumentNullException(nameof(uri));
|
|
}
|
|
|
|
var queryParams = uri.Query.TrimStart('?');
|
|
|
|
if (string.IsNullOrEmpty(queryParams))
|
|
{
|
|
return new Dictionary<string, string>();
|
|
}
|
|
|
|
return queryParams
|
|
.Split('&')
|
|
.Select(param => param.Split('='))
|
|
.ToDictionary(
|
|
keyValuePair => Uri.UnescapeDataString(keyValuePair[0]),
|
|
keyValuePair => Uri.UnescapeDataString(keyValuePair.Length > 1 ? keyValuePair[1] : ""));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取Uri查询参数
|
|
/// </summary>
|
|
/// <param name="uri"></param>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public static string GetQueryParam(this Uri uri, string key)
|
|
{
|
|
return uri.GetQueryParams().Where(w => w.Key == key).Select(s => s.Value).FirstOrDefault();
|
|
}
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// 模式匹配相关扩展方法
|
|
/// </summary>
|
|
public static class PatternMatchExtensions
|
|
{
|
|
/// <summary>
|
|
/// 判断是否匹配任意一个通配符
|
|
/// </summary>
|
|
/// <param name="str">要匹配的字符串</param>
|
|
/// <param name="patterns">通配符表达式数组</param>
|
|
/// <returns>是否匹配</returns>
|
|
public static bool WildcardMatchAny(this string str, params string[] patterns)
|
|
{
|
|
return patterns.Any(x => x.WildcardMatch(str));
|
|
}
|
|
|
|
/// <summary>
|
|
/// 判断是否匹配通配符
|
|
/// </summary>
|
|
/// <param name="wildcard">通配符表达式</param>
|
|
/// <param name="s">要匹配的字符串</param>
|
|
/// <param name="ignoreCase">是否忽略大小写</param>
|
|
/// <returns>是否匹配</returns>
|
|
public static bool WildcardMatch(this string wildcard, string s, bool ignoreCase = false)
|
|
{
|
|
return wildcard.WildcardMatch(s, 0, 0, ignoreCase);
|
|
}
|
|
|
|
// 递归匹配通配符
|
|
private static bool WildcardMatch(this string wildcard, string s, int wildcardIndex, int sIndex, bool ignoreCase)
|
|
{
|
|
while (wildcardIndex != wildcard.Length)
|
|
{
|
|
char c = wildcard[wildcardIndex];
|
|
switch (c)
|
|
{
|
|
case '*':
|
|
if (wildcardIndex == wildcard.Length - 1)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return Enumerable.Range(sIndex, s.Length - sIndex).Any((int i) => wildcard.WildcardMatch(s, wildcardIndex + 1, i, ignoreCase));
|
|
default:
|
|
{
|
|
char c2 = (ignoreCase ? char.ToLower(c) : c);
|
|
if (s.Length == sIndex)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
char c3 = (ignoreCase ? char.ToLower(s[sIndex]) : s[sIndex]);
|
|
if (c2 != c3)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case '?':
|
|
break;
|
|
}
|
|
|
|
wildcardIndex++;
|
|
sIndex++;
|
|
}
|
|
|
|
return sIndex == s.Length;
|
|
}
|
|
}
|
|
}
|