/// <summary>
/// 类型转换
/// </summary>
public static partial class ValueConvert
{
/// <summary>
/// 将最后一个字符串的路径path替换
/// </summary>
/// <param name="str"></param>
/// <param name="path"></param>
/// <returns></returns>
public static string Path(this string str, string path)
{
int index = str.LastIndexOf('\\');
int indexDian = str.LastIndexOf('.');
return str.Substring(0, index + 1) + path + str.Substring(indexDian);
}
public static List<string> ToList(this string ids)
{
List<string> listId = new List<string>();
if (!string.IsNullOrEmpty(ids))
{
var sort = new SortedSet<string>(ids.Split(','));
foreach (var item in sort)
{
listId.Add(item);
}
}
return listId;
}
/// <summary>
/// 从^分割的字符串中获取多个Id,先是用 ^ 分割，再使用 & 分割
/// </summary>
/// <param name="ids">先是用 ^ 分割，再使用 & 分割</param>
/// <returns></returns>
public static List<string> GetIdSort(this string ids)
{
List<string> listId = new List<string>();
if (!string.IsNullOrEmpty(ids))
{
var sort = new SortedSet<string>(ids.Split('^')
.Where(w => !string.IsNullOrWhiteSpace(w) && w.Contains('&'))
.Select(s => s.Substring(0, s.IndexOf('&'))));
foreach (var item in sort)
{
listId.Add(item);
}
}
return listId;
}
/// <summary>
/// 从，分割的字符串中获取单个Id
/// </summary>
/// <param name="ids"></param>
/// <returns></returns>
public static string GetId(this string ids)
{
if (!string.IsNullOrEmpty(ids))
{
var sort = new SortedSet<string>(ids.Split('^')
.Where(w => !string.IsNullOrWhiteSpace(w) && w.Contains('&'))
.Select(s => s.Substring(0, s.IndexOf('&'))));
foreach (var item in sort)
{
if (!string.IsNullOrWhiteSpace(item))
{
return item;
}
}
}
return null;
}
/// <summary>
/// 将String转换为Dictionary类型，过滤掉为空的值，首先 6 分割，再 7 分割
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static Dictionary<string, string> StringToDictionary(string value)
{
Dictionary<string, string> queryDictionary = new Dictionary<string, string>();
string[] s = value.Split('^');
for (int i = 0; i < s.Length; i++)
{
if (!string.IsNullOrWhiteSpace(s[i]) && !s[i].Contains("undefined") && !s[i].Contains("请选择"))
{
var ss = s[i].Split('&');
if ((!string.IsNullOrEmpty(ss[0])) && (!string.IsNullOrEmpty(ss[1])))
{
queryDictionary.Add(ss[0], ss[1]);
}
}
}
return queryDictionary;
}
public static byte GetByte(this object value)
{
try
{
return byte.Parse(value.ToString());
}
catch
{
return 0;
}
}
/// <summary>
/// 得到对象的 Int 类型的值，默认值0
/// </summary>
/// <param name="Value">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值0</returns>
public static int GetInt(this object Value)
{
return GetInt(Value, 0);
}
/// <summary>
/// 得到对象的 Int 类型的值，默认值0
/// </summary>
/// <param name="Value">要转换的值</param>
/// <param name="defaultValue">如果转换失败，返回的默认值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值0</returns>
public static int GetInt(this object Value, int defaultValue)
{
if (Value == null) return defaultValue;
if (Value is string && Value.GetString().HasValue() == false) return defaultValue;
if (Value is DBNull) return defaultValue;
if ((Value is string) == false && (Value is IConvertible) == true)
{
return (Value as IConvertible).ToInt32(CultureInfo.CurrentCulture);
}
int retVal = defaultValue;
if (int.TryParse(Value.ToString(), NumberStyles.Any, CultureInfo.CurrentCulture, out retVal))
{
return retVal;
}
else
{
return defaultValue;
}
}
/// <summary>
/// 得到对象的 decimal 类型的值，默认值0
/// </summary>
/// <param name="Value">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值0</returns>
public static decimal GetDecimal(this object Value)
{
decimal d = 0;
return GetDecimal(Value, d);
}
/// <summary>
/// 得到对象的 decimal 类型的值，默认值0
/// </summary>
/// <param name="Value">要转换的值</param>
/// <param name="defaultValue">如果转换失败，返回的默认值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值0</returns>
public static decimal GetDecimal(this object Value, decimal defaultValue)
{
if (Value == null) return defaultValue;
if (Value is string && Value.GetString().HasValue() == false) return defaultValue;
if (Value is DBNull) return defaultValue;
if ((Value is string) == false && (Value is IConvertible) == true)
{
return (Value as IConvertible).ToInt32(CultureInfo.CurrentCulture);
}
decimal retVal = defaultValue;
if (decimal.TryParse(Value.ToString(), NumberStyles.Any, CultureInfo.CurrentCulture, out retVal))
{
return retVal;
}
else
{
return defaultValue;
}
}
/// <summary>
/// 得到对象的 decimal 类型的值，默认值0
/// </summary>
/// <param name="Value">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值0</returns>
public static double GetDouble(this object Value)
{
double d = 0;
return GetDouble(Value, d);
}
/// <summary>
/// 得到对象的 decimal 类型的值，默认值0
/// </summary>
/// <param name="Value">要转换的值</param>
/// <param name="defaultValue">如果转换失败，返回的默认值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值0</returns>
public static double GetDouble(this object Value, double defaultValue)
{
if (Value == null) return defaultValue;
if (Value is string && Value.GetString().HasValue() == false) return defaultValue;
if (Value is DBNull) return defaultValue;
if ((Value is string) == false && (Value is IConvertible) == true)
{
return (Value as IConvertible).ToDouble(CultureInfo.CurrentCulture);
}
double retVal = defaultValue;
if (double.TryParse(Value.ToString(), NumberStyles.Any, CultureInfo.CurrentCulture, out retVal))
{
return retVal;
}
else
{
return defaultValue;
}
}
/// <summary>
/// 得到对象的 String 类型的值，默认值string.Empty
/// </summary>
/// <param name="Value">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值string.Empty</returns>
public static string GetString(this object Value)
{
return GetString(Value, string.Empty);
}
/// <summary>
/// 得到对象的 String 类型的值，默认值string.Empty
/// </summary>
/// <param name="Value">要转换的值</param>
/// <param name="defaultValue">如果转换失败，返回的默认值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值 。</returns>
public static string GetString(this object Value, string defaultValue)
{
if (Value == null) return defaultValue;
string retVal = defaultValue;
try
{
var strValue = Value as string;
if (strValue != null)
{
return strValue;
}
char[] chrs = Value as char[];
if (chrs != null)
{
return new string(chrs);
}
retVal = Value.ToString();
}
catch
{
return defaultValue;
}
return retVal;
}
/// <summary>
/// 得到对象的 DateTime 类型的值，默认值为DateTime.MinValue
/// </summary>
/// <param name="Value">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回的默认值为DateTime.MinValue </returns>
public static DateTime GetDateTime(this object Value)
{
return GetDateTime(Value, DateTime.MinValue);
}
/// <summary>
/// 得到对象的 DateTime 类型的值，默认值为DateTime.MinValue
/// </summary>
/// <param name="Value">要转换的值</param>
/// <param name="defaultValue">如果转换失败，返回默认值为DateTime.MinValue</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回的默认值为DateTime.MinValue</returns>
public static DateTime GetDateTime(this object Value, DateTime defaultValue)
{
if (Value == null) return defaultValue;
if (Value is DBNull) return defaultValue;
string strValue = Value as string;
if (strValue == null && (Value is IConvertible))
{
return (Value as IConvertible).ToDateTime(CultureInfo.CurrentCulture);
}
if (strValue != null)
{
strValue = strValue
.Replace("年", "-")
.Replace("月", "-")
.Replace("日", "-")
.Replace("点", ":")
.Replace("时", ":")
.Replace("分", ":")
.Replace("秒", ":")
;
}
DateTime dt = defaultValue;
if (DateTime.TryParse(Value.GetString(), out dt))
{
return dt;
}
return defaultValue;
}
/// <summary>
/// 得到对象的布尔类型的值，默认值false
/// </summary>
/// <param name="Value">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值false</returns>
public static bool GetBool(this object Value)
{
return GetBool(Value, false);
}
/// <summary>
/// 得到对象的 Bool 类型的值，默认值false
/// </summary>
/// <param name="Value">要转换的值</param>
/// <param name="defaultValue">如果转换失败，返回的默认值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值false</returns>
public static bool GetBool(this object Value, bool defaultValue)
{
if (Value == null) return defaultValue;
if (Value is string && Value.GetString().HasValue() == false) return defaultValue;
if ((Value is string) == false && (Value is IConvertible) == true)
{
if (Value is DBNull) return defaultValue;
try
{
return (Value as IConvertible).ToBoolean(CultureInfo.CurrentCulture);
}
catch { }
}
if (Value is string)
{
if (Value.GetString() == "0") return false;
if (Value.GetString() == "1") return true;
if (Value.GetString().ToLower() == "yes") return true;
if (Value.GetString().ToLower() == "no") return false;
}
/// if (Value.GetInt(0) != 0) return true;
bool retVal = defaultValue;
if (bool.TryParse(Value.GetString(), out retVal))
{
return retVal;
}
else return defaultValue;
}
public static string ObjToFormatTime(this object obj)
{
return ObjToFormatTime(obj, "yyyy-MM-dd");
}
/// <summary>
/// 对时间格式的字符串进行格式华
/// </summary>
/// <param name="obj"></param>
/// <param name="Format">
/// 格式
/// yyyy 年
/// MM 月
/// dd 天
/// HH 24制的时间
/// hh 12制的时间
/// mm 分
/// ss 秒
/// fff 毫秒
///
/// </param>
/// <returns></returns>
public static string ObjToFormatTime(this object obj, string format)
{
string retVal = "";
if (obj != null && obj.GetString() != "")
{
DateTime dtime = GetDateTime(obj);
retVal = dtime.ToString(format);
}
return retVal;
}
public static string GetDateTimeString(this object obj)
{
string retVal = "";
DateTime dTime = obj.GetDateTime(DateTime.Now);
DateTime ntime = DateTime.Now;
TimeSpan tspan = ntime - dTime;
if (tspan.Days > 360)
{
return dTime.ToString("yy年MM月");
}
if (tspan.Days > 30)
{
return dTime.ToString("MM月dd日");
}
if (tspan.Days > 1)
{
return dTime.ToString("MM月dd日");
}
if (tspan.Days == 0 && tspan.Hours > 0)
{
return dTime.ToString("HH时mm分");
}
if (tspan.Days == 0 && tspan.Hours == 0 && tspan.Hours == 0 && tspan.Minutes > 0)
{
return dTime.ToString("mm分ss秒");
}
if (tspan.Days == 0 && tspan.Hours == 0 && tspan.Hours == 0 && tspan.Minutes == 0 && tspan.Seconds < 2)
{
return "";
}
return retVal;
}
public static string GetDateTimeString(this object Value, string format)
{
string retVal = "";
if (Value == null) return retVal;
if (Value is DBNull) return retVal;
string strValue = Value as string;
DateTime dTime = Value.GetDateTime();
retVal = dTime.ToString(format);
return retVal;
}
/// <summary>
/// 检测 GuidValue 是否包含有效的值，默认值Guid.Empty
/// </summary>
/// <param name="GuidValue">要转换的值</param>
/// <returns>如果对象的值可正确返回， 返回对象转换的值 ，否则， 返回默认值Guid.Empty</returns>
public static Guid GetGuid(string GuidValue)
{
try
{
return new Guid(GuidValue);
}
catch { return Guid.Empty; }
}
public static string GetStuAudit(this object Value)
{
return GetStuAudit(Value, string.Empty);
}public static string SubStartString(this object Value, int len, string endStr = "")
{
string retVal = "";
if (Value == null) return retVal;
if (Value is DBNull) return retVal;
retVal = Value as string;
retVal = retVal.Trim(' ');
if (retVal.Length > len)
{
retVal = retVal.Substring(0, len);
retVal += endStr;
}
return retVal;
}
/// <summary>
/// 检测 Value 是否包含有效的值，默认值false
/// </summary>
/// <param name="Value"> 传入的值</param>
/// <returns> 包含，返回true，不包含，返回默认值false</returns>
public static bool HasValue(this string Value)
{
if (Value != null)
{
return !string.IsNullOrEmpty(Value.ToString());
}
else return false;
}
/// <summary>
/// 获取本周 周一的时间
/// </summary>
/// <param name="Value"></param>
/// <returns></returns>
public static DateTime GetSundayDateTime(this DateTime Value)
{
DayOfWeek dw = Value.DayOfWeek;
DateTime retValue = Value;
switch (dw)
{
case DayOfWeek.Sunday:
retValue = Value;
break;
case DayOfWeek.Monday:
retValue = Value.AddDays(-1);
break;
case DayOfWeek.Tuesday:
retValue = Value.AddDays(-2);
break;
case DayOfWeek.Wednesday:
retValue = Value.AddDays(-3);
break;
case DayOfWeek.Thursday:
retValue = Value.AddDays(-4);
break;
case DayOfWeek.Friday:
retValue = Value.AddDays(-5);
break;
case DayOfWeek.Saturday:
retValue = Value.AddDays(-6);
break;
}
return retValue;
}
}
浙公网安备 33010602011771号