由于在项目中经常要针对基本的类型进行处理,因此写了如下的扩展类进行类的扩展。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Collections;
using System.Text;
using System.Text.RegularExpressions;
using System.Data;
/// <summary>
///StringExtender 的摘要说明
/// </summary>
public static class StringExtender
{
#region Hashtable 扩展
/// <summary>
/// 尝试将键和值添加到字典中:如果不存在,才添加;存在,不添加也不抛导常
/// </summary>
public static Hashtable TryAdd<TKey, TValue>(this Hashtable dict, TKey key, TValue value)
{
if (dict.ContainsKey(key) == false) dict.Add(key, value);
return dict;
}
/// <summary>
/// 将键和值添加或替换到字典中:如果不存在,则添加;存在,则替换
/// </summary>
public static Hashtable AddOrReplace<TKey, TValue>(this Hashtable dict, TKey key, TValue value)
{
dict[key] = value;
return dict;
}
/// <summary>
/// 获取与指定的键相关联的值,如果没有则返回输入的默认值
/// </summary>
public static TValue GetValue<TKey, TValue>(this Hashtable dict, TKey key, TValue defaultValue = default(TValue))
{
return dict.ContainsKey(key) ? (TValue)dict[key] : defaultValue;
}
/// <summary>
/// 向字典中批量添加键值对
/// </summary>
/// <param name="replaceExisted">如果已存在,是否替换</param>
public static Hashtable AddRange<TKey, TValue>(this Hashtable dict, IEnumerable<KeyValuePair<TKey, TValue>> values, bool replaceExisted)
{
foreach (var item in values)
{
if (dict.ContainsKey(item.Key) == false || replaceExisted)
dict[item.Key] = item.Value;
}
return dict;
}
#endregion
#region Dictionary<TKey, TValue>扩展
/// <summary>
/// 尝试将键和值添加到字典中:如果不存在,才添加;存在,不添加也不抛导常
/// </summary>
public static Dictionary<TKey, TValue> TryAdd<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key, TValue value)
{
if (dict.ContainsKey(key) == false) dict.Add(key, value);
return dict;
}
/// <summary>
/// 将键和值添加或替换到字典中:如果不存在,则添加;存在,则替换
/// </summary>
public static Dictionary<TKey, TValue> AddOrReplace<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key, TValue value)
{
dict[key] = value;
return dict;
}
/// <summary>
/// 获取与指定的键相关联的值,如果没有则返回输入的默认值
/// </summary>
public static TValue GetValue<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key, TValue defaultValue = default(TValue))
{
return dict.ContainsKey(key) ? dict[key] : defaultValue;
}
/// <summary>
/// 向字典中批量添加键值对
/// </summary>
/// <param name="replaceExisted">如果已存在,是否替换</param>
public static Dictionary<TKey, TValue> AddRange<TKey, TValue>(this Dictionary<TKey, TValue> dict, IEnumerable<KeyValuePair<TKey, TValue>> values, bool replaceExisted)
{
foreach (var item in values)
{
if (dict.ContainsKey(item.Key) == false || replaceExisted)
dict[item.Key] = item.Value;
}
return dict;
}
#endregion
/// <summary>
/// 将给定的对象转化为string[] ,ArrayList,List<string>,object[]
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public static string[] ToArrayStr(this object obj)
{
string[] arrStr = null;
if (IsNullOrEmpty(obj)) { return arrStr; }
if (obj.GetType() == typeof(ArrayList))
{
ArrayList arr = obj as ArrayList;
arrStr = arr.ToArray(typeof(string)) as string[];
}
else if (obj.GetType() == typeof(List<string>))
{
List<string> list = obj as List<string>;
arrStr = list.ToArray();
}
else if (obj.GetType() == typeof(object[]))
{
object[] list = obj as object[];
arrStr = (string[])ArrayList.Adapter((Array)list).ToArray(typeof(string));
}
return arrStr;
}
/// <summary>
/// 给定的数组转化为ArrayList
/// </summary>
/// <param name="array"></param>
/// <returns></returns>
public static ArrayList ToArrayList(this string[] array)
{
if (array == null)
return null;
ArrayList list = new ArrayList();
foreach (string str in array)
{
list.Add(str);
}
return list;
}
public static string _ToString(this string[] array, string Separated)
{
string Result = "";
if (array == null)
{
return Result;
}
foreach (string a in array)
{
Result += a + Separated;
}
Result = Result.Substring(0, Result.Length - Separated.Length);
return Result;
}
/// <summary>
/// 转换为枚举,忽略大小写
/// </summary>
/// <param name="EnumVal"></param>
/// <param name="EnumType"></param>
/// <returns></returns>
public static object ToEnum(this string EnumVal, Type EnumType, bool ignoreCase)
{
object oEnum = Enum.Parse(EnumType, EnumVal, ignoreCase);
return oEnum;
}
/// <summary>
/// 转换为枚举,忽略大小写
/// </summary>
/// <param name="EnumVal"></param>
/// <param name="EnumType"></param>
/// <returns></returns>
public static object ToEnum(this string EnumVal, Type EnumType)
{
return ToEnum(EnumVal, EnumType, true);
}
public static int IndexOf(this string[] array, string Value)
{
int Result = -1;
for (int i = 0; i < array.Length; i++)
{
if (array[i] == Value)
{
Result = i;
break;
}
}
return Result;
}
/// <summary>
/// 将 ▓A▓▓NA▓ 转化为 'A','NA' 格式
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static string GetSqlIn(this object obj)
{
return obj.ReplaceX(TBCSysConst.SPLIT_STR + TBCSysConst.SPLIT_STR, "','").ReplaceX(TBCSysConst.SPLIT_STR, "'");
}
/// <summary>
/// ArrayList,string[],Array,string, 把以","分隔的字符串,转变为在SQL中可直接运行的字符串
/// 111,www,rrrr 变成 '111','www','rrr'
/// </summary>
/// <param name="str"></param>
/// <param name="Separated"></param>
/// <returns></returns>
public static string GetStringSqlFilter(this object str)
{
StringBuilder builder = new StringBuilder();
if (str.GetType() == typeof(ArrayList))
{
ArrayList list = str as ArrayList;
foreach (string temp in list)
{
builder.AppendFormat(",'{0}'", temp.Replace("'", string.Empty));
}
}
else if (str.GetType() == typeof(string[]))
{
string[] list = str as string[];
foreach (string temp in list)
{
builder.AppendFormat(",'{0}'", temp.Replace("'", string.Empty));
}
}
else if (str.GetType() == typeof(Array))
{
Array list = str as Array;
foreach (string temp in list)
{
builder.AppendFormat(",'{0}'", temp.Replace("'", string.Empty));
}
}
else if (str.GetType() == typeof(string))
{
string[] arrStr = str.ToList(",");
foreach (string temp in arrStr)
{
builder.AppendFormat(",'{0}'", temp.Replace("'", string.Empty));
}
}
if (builder.Length > 0)
return builder.ToStringX().Substring(1);
else
return string.Empty;
}
/// <summary>
/// 去除空格
/// </summary>
/// <param name="str"></param>
/// <param name="flag">是否去除内部的空格</param>
/// <returns></returns>
public static string Trim(this string str, bool flag)
{
if (!str.IsNullOrEmpty())
{
str = (flag) ? Regex.Replace(str, @"\s+", string.Empty) : str.Trim();
}
return str;
}
/// <summary>
/// 将字符串转化为数字
/// </summary>
/// <param name="item">转化失败返回0</param>
/// <returns></returns>
public static int ToInt(this object item)
{
int IntResult = 0;
if (!item.IsNullOrEmpty())
{
int.TryParse(item.ToStringX(), out IntResult);
}
return IntResult;
}
/// <summary>
/// 将字符串转化为金额
/// </summary>
/// <param name="item">转化失败返回0</param>
/// <returns></returns>
public static double ToMoney(this object item)
{
double IntResult = 0.00;
if (!item.IsNullOrEmpty())
{
double.TryParse(item.ToString(), out IntResult);
}
return IntResult;
}
/// <summary>
/// 将字符串转化为金额
/// </summary>
/// <param name="item">转化失败返回0</param>
/// <returns></returns>
public static decimal ToMoney(this object item, int Num)
{
decimal DecResult = decimal.Zero;
if (!item.IsNullOrEmpty())
{
decimal.TryParse(item.ToString(), out DecResult);
DecResult = decimal.Round(DecResult, Num);
}
return DecResult;
}
/// <summary>
/// 查看字符串是否匹配指定的正则表达式 如 "12345".IsMatch(@"\d+");
/// </summary>
/// <param name="s"></param>
/// <param name="pattern"></param>
/// <returns></returns>
public static bool IsMatch(this string s, string pattern)
{
if (s == null) return false;
else return Regex.IsMatch(s, pattern);
}
/// <summary>
/// 将匹配的字符串过滤返回 如 "ljn615".Match("[a-zA-Z]+");
/// </summary>
/// <param name="s"></param>
/// <param name="pattern"></param>
/// <returns></returns>
public static string Match(this string s, string pattern)
{
if (s == null) return string.Empty;
return Regex.Match(s, pattern).Value;
}
/// <summary>
/// 判断字符是否为空或者NULL,true则为空,false不为空
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static bool IsNullOrEmpty(this object value)
{
if (value != null && value != DBNull.Value)
{
Type objType = value.GetType();
if (objType == typeof(DataSet))
{
DataSet ds = value as DataSet;
//没有表
if (ds.Tables.Count == 0) return true;
//只有一个表,但是表里没有数据
if (ds.Tables.Count == 1 && ds.Tables[0].Rows.Count == 0) return true;
if (ds.Tables.Count > 1)
{
foreach (DataTable dt in ds.Tables)
{
//只要有大于0的就不为空
if (dt.Rows.Count > 0)
{
return false;
}
}
}
}
if (objType == typeof(DataTable))
{
DataTable dt = value as DataTable;
if (dt.Rows.Count == 0) return true;
}
string val = value.ToString().Trim().ToUpper();
if (val == "NULL" || val == "UNDEFINED" || val == "{}") return true;
return (val.Length == 0);
}
return true;
}
/// <summary>
/// 格式化字符串
/// </summary>
/// <param name="format">要格式化的字符串,如 "今天是:{0:yyyy年MM月dd日 星期ddd}".FormatWith(DateTime.Today);</param>
/// <param name="args">可选的</param>
/// <returns></returns>
public static string FormatWith(this string format, params object[] args)
{
return string.Format(format, args);
}
/// <summary>
/// 将对象内指定的字符串(不区分大小写)替换为新的字符串,如果为null则返回空字符串
/// </summary>
/// <param name="item"></param>
/// <param name="OldStr">被替换的字符串</param>
/// <param name="NewStr">新的字符串</param>
/// <returns></returns>
public static string ReplaceX(this object item, string OldStr, string NewStr)
{
string StrResult = string.Empty;
if (!item.IsNullOrEmpty())
{
StrResult = item.ToString().Trim().Replace(OldStr, NewStr).Replace(OldStr.ToLower(), NewStr).Replace(OldStr.ToUpper(), NewStr);
}
return StrResult;
}
/// <summary>
/// 将对象转化为字符串后并截取字符
/// </summary>
/// <param name="item"></param>
/// <param name="start">开始截取的索引</param>
/// <returns></returns>
public static string ToStringX(this object item, int start)
{
string StrResult = string.Empty;
if (!item.IsNullOrEmpty())
{
StrResult = item.ToString().Trim();
if (start < StrResult.Length)
{
StrResult = StrResult.Substring(start);
}
}
return StrResult;
}
/// <summary>
/// 将对象转化为字符串后并截取字符
/// </summary>
/// <param name="item"></param>
/// <param name="start">开始截取的索引</param>
/// <param name="length">要截取的长度</param>
/// <returns></returns>
public static string ToStringX(this object item, int start, int length)
{
string StrResult = string.Empty;
if (!item.IsNullOrEmpty())
{
StrResult = item.ToString().Trim();
if (length <= StrResult.Length - start)
{
StrResult = StrResult.Substring(start, length);
}
}
return StrResult;
}
/// <summary>
/// 将对象转化为字符串,如果为null则返回空字符串
/// </summary>
/// <param name="item"></param>
/// <param name="flag">可选的,是否去掉空格</param>
/// <returns></returns>
public static string ToStringX(this object item)
{
string StrResult = string.Empty;
if (!item.IsNullOrEmpty())
{
if (item.GetType() == typeof(byte[]))
{
byte[] b = item as byte[];
StrResult = Encoding.Default.GetString(b);
}
else
{
StrResult = item.ToString().Trim();
}
}
return StrResult;
}
/// <summary>
/// 将对象转化为字符串,如果为null则返回空字符串
/// </summary>
/// <param name="item"></param>
/// <param name="flag">可选的,是否转换成大写,否则false小写</param>
/// <returns></returns>
public static string ToStringX(this object item, bool flag)
{
string StrResult = string.Empty;
if (!item.IsNullOrEmpty())
{
if (flag)
StrResult = item.ToString().Trim().ToUpper();
else
StrResult = item.ToString().Trim().ToLower();
}
return StrResult;
}
/// <summary>
/// 将字符串以指定的分隔符转换成数组
/// </summary>
/// <param name="item"></param>
/// <param name="Separated">分隔符</param>
/// <returns></returns>
public static string[] ToList(this object item, char Separated)
{
return ToList(item, Separated.ToString());
}
/// <summary>
/// 将字符串以指定的分隔符转换成数组
/// </summary>
/// <param name="item"></param>
/// <param name="Separated">分隔符</param>
/// <returns></returns>
public static string[] ToList(this object item, string Separated)
{
string StrResult = item.ToStringX();
string[] arrResult = null;
if (!Separated.IsNullOrEmpty() && StrResult.Contains(Separated))
{
StrResult = StrResult.Replace(Separated, TBCSysConst.REPLACE_SPLIT_CHAR.ToString());
arrResult = StrResult.Split(TBCSysConst.REPLACE_SPLIT_CHAR);
}
else
{
arrResult = new string[] { StrResult };
}
return arrResult;
}
/// <summary>
/// 转全角(SBC case)
/// </summary>
/// <param name="input">任意字符串</param>
/// <returns>全角字符串</returns>
public static string ToSBC(this string input)
{
char[] c = input.ToCharArray();
for (int i = 0; i < c.Length; i++)
{
if (c[i] == 32)
{
c[i] = (char)12288;
continue;
}
if (c[i] < 127)
{
c[i] = (char)(c[i] + 65248);
}
}
return new string(c);
}
/// <summary>
/// 转半角(DBC case)
/// </summary>
/// <param name="input">任意字符串</param>
/// <returns>半角字符串</returns>
public static string ToDBC(this string input)
{
char[] c = input.ToCharArray();
for (int i = 0; i < c.Length; i++)
{
if (c[i] == 12288)
{
c[i] = (char)32;
continue;
}
if (c[i] > 65280 && c[i] < 65375)
{
c[i] = (char)(c[i] - 65248);
}
}
return new string(c);
}
/// <summary>
/// 将对象转化为字符串,如果为null则返回空字符串
/// </summary>
/// <param name="item"></param>
/// <param name="flag">可选的,是否去掉空格</param>
/// <returns></returns>
public static string ToStringX(this object item, FormatEnum format)
{
string StrResult = string.Empty;
if (!item.IsNullOrEmpty())
{
if (!format.IsNullOrEmpty())
{
try
{
switch (format)
{
case FormatEnum.SmallDate:
DateTime SmallDate = Convert.ToDateTime(item);
StrResult = SmallDate.ToString("yyyy-MM-dd");
break;
case FormatEnum.FullDate:
DateTime FullDate = Convert.ToDateTime(item);
StrResult = FullDate.ToString("yyyy-MM-dd HH:mm:ss");
break;
case FormatEnum.FileReName:
DateTime FileReName = Convert.ToDateTime(item);
StrResult = FileReName.ToString("yyyyMMddHHmmss");
break;
case FormatEnum.SmallYear:
DateTime SmallYear = Convert.ToDateTime(item);
StrResult = SmallYear.ToString("yyyyMMdd");
break;
default:
break;
}
}
catch (Exception)
{
StrResult = item.ToString().Trim();
}
}
else
StrResult = item.ToString().Trim();
}
return StrResult;
}
}
/// <summary>
/// 格式化的枚举
/// </summary>
public enum FormatEnum
{
/// <summary>
/// yyyy-MM-dd
/// </summary>
SmallDate = 0,
/// <summary>
/// yyyyMMdd
/// </summary>
SmallYear,
/// <summary>
/// yyyy-MM-dd HH:mm:ss
/// </summary>
FullDate,
/// <summary>
/// yyyyMMddHHmmss
/// </summary>
FileReName
}