C# 一些零零碎碎的方法，都是些帮助类，留存，也希望能帮助到各位
------------------------------------------------------------------------------------------------------------
1、Table转List
/// <summary>
/// Table转List
/// </summary>
/// <typeparam name="T"></typeparam>
public class GenericList<T> : List<T>
{
public GenericList(DataTable dt, Type tt)
{
object ff = Activator.CreateInstance(tt, null);//创建指定类型实例
PropertyInfo[] fields = ff.GetType().GetProperties();//获取指定对象的所有公共属性
foreach (DataRow dr in dt.Rows)
{
object obj = Activator.CreateInstance(tt, null);
foreach (DataColumn dc in dt.Columns)
{
var dc1 = dc;
foreach (PropertyInfo t in fields.Where(t => dc1.ColumnName.ToLower().Equals(t.Name.ToLower())))
{
var value = dr[dc.ColumnName];
if (t.PropertyType.Name.ToLower() == "int32" && dr[dc.ColumnName].ToString().Length < )
value = ;
t.SetValue(obj, Convert.ChangeType(value, t.PropertyType), null); //给对象赋值
continue;
}
}
Add((T)obj);//将对象填充到list集合
}
}
}
------------------------------------------------------------------------------------------------------------
2、PredicateBuilder，启用查询谓词的高效、动态组合。
/// <summary>
/// 启用查询谓词的高效、动态组合。
/// </summary>
public static class PredicateBuilder
{
/// <summary>
/// 创建一个谓词，该谓词计算为true。
/// </summary>
public static Expression<Func<T, bool>> True<T>() { return param => true; } /// <summary>
/// 创建一个谓词，该谓词计算为false。
/// </summary>
public static Expression<Func<T, bool>> False<T>() { return param => false; } /// <summary>
/// 从指定的lambda表达式创建谓词表达式。
/// </summary>
public static Expression<Func<T, bool>> Create<T>(Expression<Func<T, bool>> predicate) { return predicate; } /// <summary>
/// 将第一个谓词与第二个谓词结合使用逻辑“和”。
/// </summary>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
return first.Compose(second, Expression.AndAlso);
} /// <summary>
/// 将第一个谓词与第二个谓词结合使用逻辑“或”。
/// </summary>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
return first.Compose(second, Expression.OrElse);
} /// <summary>
/// 否定谓语。
/// </summary>
public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expression)
{
var negated = Expression.Not(expression.Body);
return Expression.Lambda<Func<T, bool>>(negated, expression.Parameters);
} /// <summary>
/// 使用指定的合并函数将第一个表达式与第二个表达式组合在一起。
/// </summary>
static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
{
// zip parameters (map from parameters of second to parameters of first)
var map = first.Parameters
.Select((f, i) => new { f, s = second.Parameters[i] })
.ToDictionary(p => p.s, p => p.f); // replace parameters in the second lambda expression with the parameters in the first
var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body); // create a merged lambda expression with parameters from the first expression
return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
} /// <summary>
/// 参数绑定
/// </summary>
class ParameterRebinder : ExpressionVisitor
{
/// <summary>
/// The ParameterExpression map
/// </summary>
readonly Dictionary<ParameterExpression, ParameterExpression> map; /// <summary>
/// Initializes a new instance of the <see cref="ParameterRebinder"/> class.
/// </summary>
/// <param name="map">The map.</param>
ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
{
this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
} /// <summary>
/// Replaces the parameters.
/// </summary>
/// <param name="map">The map.</param>
/// <param name="exp">The exp.</param>
/// <returns>Expression</returns>
public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
{
return new ParameterRebinder(map).Visit(exp);
} /// <summary>
/// Visits the parameter.
/// </summary>
/// <param name="p">The p.</param>
/// <returns>Expression</returns>
protected override Expression VisitParameter(ParameterExpression p)
{
ParameterExpression replacement; if (map.TryGetValue(p, out replacement))
{
p = replacement;
} return base.VisitParameter(p);
}
}
}
------------------------------------------------------------------------------------------------------------
3、数据验证
/// <summary>
/// 验证
/// </summary>
public class Valid
{
#region IsEmail(是否邮箱) /// <summary>
/// 是否邮箱
/// </summary>
/// <param name="value">邮箱地址</param>
/// <param name="isRestrict">是否按严格模式验证</param>
/// <returns></returns>
public static bool IsEmail(string value, bool isRestrict = false)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = isRestrict
? @"^(?("")("".+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$"
: @"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
} /// <summary>
/// 是否存在邮箱
/// </summary>
/// <param name="value">值</param>
/// <param name="isRestrict">是否按严格模式验证</param>
/// <returns></returns>
public static bool HasEmail(string value, bool isRestrict = false)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = isRestrict
? @"^(?("")("".+?""@)|(([0-9a-zA-Z]((\.(?!\.))|[-!#\$%&'\*\+/=\?\^`\{\}\|~\w])*)(?<=[0-9a-zA-Z])@))(?(\[)(\[(\d{1,3}\.){3}\d{1,3}\])|(([0-9a-zA-Z][-\w]*[0-9a-zA-Z]\.)+[a-zA-Z]{2,6}))$"
: @"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsPhoneNumber(是否合法的手机号码)
/// <summary>
/// 是否合法的手机号码
/// </summary>
/// <param name="value">手机号码</param>
/// <returns></returns>
public static bool IsPhoneNumber(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^(0|86|17951)?(13[0-9]|15[012356789]|18[0-9]|14[57]|17[678])[0-9]{8}$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsMobileNumber(是否手机号码)
/// <summary>
/// 是否手机号码
/// </summary>
/// <param name="value">手机号码</param>
/// <param name="isRestrict">是否按严格模式验证</param>
/// <returns></returns>
public static bool IsMobileNumberSimple(string value, bool isRestrict = false)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = isRestrict ? @"^[1][3-8]\d{9}$" : @"^[1]\d{10}$";
return Regex.IsMatch(value, pattern);
}
/// <summary>
/// 是否手机号码
/// </summary>
/// <param name="value">手机号码</param>
/// <returns></returns>
public static bool IsMobileNumber(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
value = value.Trim().Replace("^", "").Replace("$", "");
/**
* 手机号码:
* 13[0-9], 14[5,7], 15[0, 1, 2, 3, 5, 6, 7, 8, 9], 17[6, 7, 8], 18[0-9], 170[0-9]
* 移动号段: 134,135,136,137,138,139,150,151,152,157,158,159,182,183,184,187,188,147,178,1705
* 联通号段: 130,131,132,155,156,185,186,145,176,1709
* 电信号段: 133,153,180,181,189,177,1700
*/
string pattern = @"^1(3[0-9]|4[57]|5[0-35-9]|8[0-9]|70)\d{8}$";
return Regex.IsMatch(value, pattern);
} /// <summary>
/// 是否存在手机号码
/// </summary>
/// <param name="value">值</param>
/// <param name="isRestrict">是否按严格模式验证</param>
/// <returns></returns>
public static bool HasMobileNumberSimple(string value, bool isRestrict = false)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = isRestrict ? @"[1][3-8]\d{9}" : @"[1]\d{10}";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsChinaMobilePhone(是否中国移动号码)
/// <summary>
/// 是否中国移动号码
/// </summary>
/// <param name="value">手机号码</param>
/// <returns></returns>
public static bool IsChinaMobilePhone(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
/**
* 中国移动：China Mobile
* 134,135,136,137,138,139,150,151,152,157,158,159,182,183,184,187,188,147,178,1705
*/
string pattern = @"(^1(3[4-9]|4[7]|5[0-27-9]|7[8]|8[2-478])\d{8}$)|(^1705\d{7}$)";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsChinaUnicomPhone(是否中国联通号码)
/// <summary>
/// 是否中国联通号码
/// </summary>
/// <param name="value">手机号码</param>
/// <returns></returns>
public static bool IsChinaUnicomPhone(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
/**
* 中国联通：China Unicom
* 130,131,132,155,156,185,186,145,176,1709
*/
string pattern = @"(^1(3[0-2]|4[5]|5[56]|7[6]|8[56])\d{8}$)|(^1709\d{7}$)";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsChinaTelecomPhone(是否中国电信号码)
/// <summary>
/// 是否中国电信号码
/// </summary>
/// <param name="value">手机号码</param>
/// <returns></returns>
public static bool IsChinaTelecomPhone(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
/**
* 中国电信：China Telecom
* 133,153,180,181,189,177,1700
*/
string pattern = @"(^1(33|53|77|8[019])\d{8}$)|(^1700\d{7}$)";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsIdCard(是否身份证号码)
/// <summary>
/// 是否身份证号码
/// </summary>
/// <param name="value">身份证</param>
/// <returns></returns>
public static bool IsIdCard(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = string.Empty;
if (value.Length == )
{
pattern = @"^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$";
return Regex.IsMatch(value, pattern);
}
pattern = @"^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[Xx])$";
return value.Length == 0x12 &&
Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsBase64String(是否Base64编码)
/// <summary>
/// 是否Base64编码
/// </summary>
/// <param name="value">Base64字符串</param>
/// <returns></returns>
public static bool IsBase64String(string value)
{
string pattern = @"[A-Za-z0-9\+\/\=]";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsDate(是否日期) /// <summary>
/// 是否日期
/// </summary>
/// <param name="value">日期字符串</param>
/// <param name="isRegex">是否正则验证</param>
/// <returns></returns>
public static bool IsDate(string value, bool isRegex = false)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
if (isRegex)
{
//考虑到4年一度的366天，还有特殊的2月的日期
string pattern = @"^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-)) (20|21|22|23|[0-1]?\d):[0-5]?\d:[0-5]?\d$";
return Regex.IsMatch(value, pattern);
}
DateTime minValue;
return DateTime.TryParse(value, out minValue);
} /// <summary>
/// 是否日期
/// </summary>
/// <param name="value">日期字符串</param>
/// <param name="format">格式化字符串</param>
/// <returns></returns>
public static bool IsDate(string value, string format)
{
return IsDate(value, format, null, DateTimeStyles.None);
} /// <summary>
/// 是否日期
/// </summary>
/// <param name="value">日期字符串</param>
/// <param name="format">格式化字符串</param>
/// <param name="provider">格式化提供者</param>
/// <param name="styles">日期格式</param>
/// <returns></returns>
public static bool IsDate(string value, string format, IFormatProvider provider, DateTimeStyles styles)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
DateTime minValue;
return DateTime.TryParseExact(value, format, provider, styles, out minValue);
}
#endregion #region IsDateTime(是否有效时间)
/// <summary>
/// 是否大于最小时间
/// </summary>
/// <param name="value">时间</param>
/// <param name="min">最小时间</param>
/// <returns></returns>
public static bool IsDateTimeMin(string value, DateTime min)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
DateTime dateTime;
if (DateTime.TryParse(value, out dateTime))
{
if (DateTime.Compare(dateTime, min) >= )
{
return true;
}
}
return false;
}
/// <summary>
/// 是否小于最大时间
/// </summary>
/// <param name="value">时间</param>
/// <param name="max">最大时间</param>
/// <returns></returns>
public static bool IsDateTimeMax(string value, DateTime max)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
DateTime dateTime;
if (DateTime.TryParse(value, out dateTime))
{
if (DateTime.Compare(max, dateTime) >= )
{
return true;
}
}
return false;
}
#endregion #region IsGuid(是否Guid)
/// <summary>
/// 是否Guid
/// </summary>
/// <param name="guid">Guid字符串</param>
/// <returns></returns>
public static bool IsGuid(string guid)
{
if (string.IsNullOrEmpty(guid))
{
return false;
}
string pattern = @"[A-F0-9]{8}(-[A-F0-9]{4}){3}-[A-F0-9]{12}|[A-F0-9]{32}";
return Regex.IsMatch(guid, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsUrl(是否Url地址)
/// <summary>
/// 是否Url地址（统一资源定位）
/// </summary>
/// <param name="value">url地址</param>
/// <returns></returns>
public static bool IsUrl(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^(http|https)\://([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{1,10}))(\:[0-9]+)*(/($|[a-zA-Z0-9\.\,\?\'\\\+&%\$#\=~_\-]+))*$";
return
Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsUri(是否Uri)
/// <summary>
/// 是否Uri（统一资源标识）
/// </summary>
/// <param name="value">uri</param>
/// <returns></returns>
public static bool IsUri(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
if (value.IndexOf(".", StringComparison.OrdinalIgnoreCase) == -)
{
return false;
}
var schemes = new[]
{
"file",
"ftp",
"gopher",
"http",
"https",
"ldap",
"mailto",
"net.pipe",
"net.tcp",
"news",
"nntp",
"telnet",
"uuid"
}; bool hasValidSchema = false;
foreach (string scheme in schemes)
{
if (hasValidSchema)
{
continue;
}
if (value.StartsWith(scheme, StringComparison.OrdinalIgnoreCase))
{
hasValidSchema = true;
}
}
if (!hasValidSchema)
{
value = "http://" + value;
}
return Uri.IsWellFormedUriString(value, UriKind.Absolute);
}
#endregion #region IsMac(是否Mac地址)
/// <summary>
/// 是否Mac地址
/// </summary>
/// <param name="value">Mac地址</param>
/// <returns></returns>
public static bool IsMac(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
return Regex.IsMatch(value, @"^([0-9A-F]{2}-){5}[0-9A-F]{2}$") || Regex.IsMatch(value, @"^[0-9A-F]{12}$");
}
#endregion #region IsPositiveInteger(是否大于0的正整数)
/// <summary>
/// 是否大于0的正整数
/// </summary>
/// <param name="value">正整数</param>
/// <returns></returns>
public static bool IsPositiveInteger(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^[1-9]+\d*$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsInt32(是否Int32类型)
/// <summary>
/// 是否Int32类型
/// </summary>
/// <param name="value">整数</param>
/// <returns></returns>
public static bool IsInt32(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^[0-9]*$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsDouble(是否Double类型，如果带有.默认为1位0)
/// <summary>
/// 是否Double类型
/// </summary>
/// <param name="value">小数</param>
/// <returns></returns>
public static bool IsDouble(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^\d[.]?\d?$";
return Regex.IsMatch(value, pattern);
}
/// <summary>
/// 是否Double类型
/// </summary>
/// <param name="value">小数</param>
/// <param name="minValue">最小值</param>
/// <param name="maxValue">最大值</param>
/// <param name="digit">小数位数，如果是0则不检测</param>
/// <returns></returns>
public static bool IsDouble(string value, double minValue, double maxValue, int digit)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string patten = string.Format(@"^\d[.]?\d{0}$", "{0,10}");
if (digit > )
{
patten = string.Format(@"^\d[.]?\d{0}$", "{" + digit + "}");
}
if (Regex.IsMatch(value, patten))
{
double val = Convert.ToDouble(value);
if (val >= minValue && val <= maxValue)
{
return true;
}
}
return false;
}
#endregion #region IsPassword(是否密码格式)
/// <summary>
/// 是否密码One的格式，6-25位包含特殊字符
/// </summary>
/// <param name="value">密码</param>
/// <returns></returns>
public static bool IsPasswordOne(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^[\@A-Za-z0-9\!\#\$\%\^\&\*\.\~_]{6,25}$";
return Regex.IsMatch(value, pattern);
}
/// <summary>
/// 是否密码One的格式，指定密码长度，包含特殊字符
/// </summary>
/// <param name="value">密码</param>
/// <param name="min">最小长度</param>
/// <param name="max">最大长度</param>
/// <returns></returns>
public static bool IsPasswordOne(string value, int min, int max)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = string.Format(@"^[\@A-Za-z0-9\!\#\$\%\^\&\*\.\~_]{0},{1}$", "{" + min, max + "}");
return Regex.IsMatch(value, pattern);
}
/// <summary>
/// 是否密码Two的格式，6-25位包含特殊字符
/// </summary>
/// <param name="value">密码</param>
/// <returns></returns>
public static bool IsPasswordTwo(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"(?=^.{6,25}$)(?=(?:.*?\d){1})(?=.*[a-z])(?=(?:.*?[A-Z]){1})(?=(?:.*?[!@#$%*()_+^&}{:;?.]){1})(?!.*\s)[0-9a-zA-Z!@#$%*()_+^&]*$";
return
Regex.IsMatch(value, pattern);
}
#endregion #region IsLoginName(是否登录账号)
/// <summary>
/// 是否登录账号，6-30位长度
/// </summary>
/// <param name="value">登录账号</param>
/// <returns></returns>
public static bool IsLoginName(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^(?![^a-zA-Z]+$)[A-Za-z0-9]{6,30}$";
return Regex.IsMatch(value, pattern);
}
/// <summary>
/// 是否登录账号
/// </summary>
/// <param name="value">登录账号</param>
/// <param name="min">最小长度</param>
/// <param name="max">最大长度</param>
/// <returns></returns>
public static bool IsLoginName(string value, int min, int max)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = string.Format(@"^(?![^a-zA-Z]+$)[A-Za-z0-9]{0},{1}$", "{" + min, max + "}");
return Regex.IsMatch(value, pattern);
}
#endregion #region IsBankCard(是否银行卡号)
/// <summary>
/// 是否银行卡号，16位或19位银行卡（简单校验）
/// </summary>
/// <param name="value">银行卡号</param>
/// <returns></returns>
public static bool IsBandCard(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^(\d{16}|\d{19})$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsSafeSqlString(是否安全Sql语句)
/// <summary>
/// 是否安全Sql语句
/// </summary>
/// <param name="value">sql语句</param>
/// <returns></returns>
public static bool IsSafeSqlString(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"[-|;|,|\/|\(|\)|\[|\]|\}|\{|%|@|\*|!|\']";
return !Regex.IsMatch(value, pattern);
}
#endregion #region IsVersion(是否有效的版本号)
/// <summary>
/// 是否有效版本号，范例：1.3,1.1.5,1.25.256
/// </summary>
/// <param name="value">版本号</param>
/// <param name="length">长度</param>
/// <returns></returns>
public static bool IsVersion(string value, int length = )
{
if (string.IsNullOrEmpty(value))
{
return false;
}
value = value.Replace("^", "").Replace("$", "");
string pattern = string.Format(@"^{0}{1}{2}$", @"\d{0,4}\.(\d{1,4}\.){0,", length, @"}\d{1,4}");
return Regex.IsMatch(value, pattern);
}
#endregion #region IsContainsChinese(是否包含中文)
/// <summary>
/// 是否中文
/// </summary>
/// <param name="value">中文</param>
/// <returns></returns>
public static bool IsChinese(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^[\u4e00-\u9fa5]+$";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
/// <summary>
/// 是否包含中文
/// </summary>
/// <param name="value">中文</param>
/// <returns></returns>
public static bool IsContainsChinese(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"[\u4e00-\u9fa5]+";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsContainsNumber(是否包含数字)
/// <summary>
/// 是否包含数字
/// </summary>
/// <param name="value">数字</param>
/// <returns></returns>
public static bool IsContainsNumber(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"[0-9]+";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsMainDomain(是否主域名)
/// <summary>
/// 是否主域名或者www开头的域名
/// </summary>
/// <param name="value">url地址</param>
/// <returns></returns>
public static bool IsMainDomain(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^http(s)?\://((www.)?[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{1,10}))(\:[0-9]+)*(/($|[a-zA-Z0-9\.\,\?\'\\\+&%\$#\=~_\-]+))*$";
return
Regex.IsMatch(value, pattern);
}
#endregion #region IsMobileUser(是否手机用户)
/// <summary>
/// 是否手机用户
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
//public static bool IsMobileUser(HttpContext context = null)
//{
// if (context == null)
// {
// context = HttpContext.Current;
// }
// if (context != null)
// {
// if (context.Request.Browser.IsMobileDevice)
// {
// return true;
// }
// if (!context.Request.UserAgent.IsEmpty())
// {
// return
// context.Request.UserAgent.IsMatch(
// @"(iemobile|iphone|ipod|android|nokia|sonyericsson|blackberry|samsung|sec\-|windows ce|motorola|mot\-|up.b|midp\-)",
// RegexOptions.IgnoreCase | RegexOptions.Compiled);
// }
// }
// return false;
//}
#endregion #region IsIpAddress(是否IP地址)
/// <summary>
/// 是否IP地址
/// </summary>
/// <param name="value">ip地址</param>
/// <returns>结果</returns>
public static bool IsIpAddress(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^(\d(25[0-5]|2[0-4][0-9]|1?[0-9]?[0-9])\d\.){3}\d(25[0-5]|2[0-4][0-9]|1?[0-9]?[0-9])\d$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsInteger(是否整数)
/// <summary>
/// 是否整数
/// </summary>
/// <param name="value">值</param>
/// <returns>结果</returns>
public static bool IsInteger(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^\-?[0-9]+$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsUnicode(是否Unicode字符串)
/// <summary>
/// 是否Unicode字符串
/// </summary>
/// <param name="value">unicode字符串</param>
/// <returns>结果</returns>
public static bool IsUnicode(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^(http|https|ftp|rtsp|mms):(\/\/|\\\\)[A-Za-z0-9%\-_@]+\.[A-Za-z0-9%\-_@]+[A-Za-z0-9\.\/=\?%\-&_~`@:\+!;]*$";
return
Regex.IsMatch(value, pattern);
}
#endregion #region IsLengthStr(字符串长度是否在指定范围内)
/// <summary>
/// 字符串长度是否在指定范围内，一个中文为2个字符
/// </summary>
/// <param name="value">字符串</param>
/// <param name="begin">开始</param>
/// <param name="end">结束</param>
/// <returns></returns>
public static bool IsLengthStr(string value, int begin, int end)
{
int length = Regex.Replace(value, @"[^\x00-\xff]", "OK").Length;
if ((length <= begin) && (length >= end))
{
return false;
}
return true;
}
#endregion #region IsTel(是否中国电话)
/// <summary>
/// 是否中国电话，格式：010-85849685
/// </summary>
/// <param name="value">电话</param>
/// <returns></returns>
public static bool IsTel(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^\d{3,4}-?\d{6,8}$";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsPostalCode(是否邮政编码)
/// <summary>
/// 是否邮政编码，6位数字
/// </summary>
/// <param name="value">邮政编码</param>
/// <returns></returns>
public static bool IsPostalCode(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^[1-9]\d{5}$";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsNormalChar(是否正常字符，字母、数字、下划线的组合)
/// <summary>
/// 是否正常字符，字母、数字、下划线的组合
/// </summary>
/// <param name="value">字符串</param>
/// <returns></returns>
public static bool IsNormalChar(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"[\w\d_]+";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsPostfix(是否指定后缀)
/// <summary>
/// 是否指定后缀
/// </summary>
/// <param name="value">字符串</param>
/// <param name="postfixs">后缀名数组</param>
/// <returns></returns>
public static bool IsPostfix(string value, string[] postfixs)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string postfix = string.Join("|", postfixs);
string pattern = string.Format(@".(?i:{0})$", postfix);
return Regex.IsMatch(value, pattern);
}
#endregion #region IsDecimal(是否数字型)
/// <summary>
/// 是否数字型
/// </summary>
/// <param name="value">数字</param>
/// <returns></returns>
public static bool IsDecimal(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^([0-9])[0-9]*(\.\w*)?$";
return Regex.IsMatch(value, pattern);
}
#endregion #region IsBase64(是否Base64字符串)
/// <summary>
/// 是否Base64字符串
/// </summary>
/// <param name="value">字符串</param>
/// <returns></returns>
public static bool IsBase64(string value)
{
if (value.Length % != )
{
return false;
}
string pattern = @"^[A-Z0-9/+=]*$";
return Regex.IsMatch(value, pattern, RegexOptions.IgnoreCase);
}
#endregion #region IsRepeat(是否重复)
/// <summary>
/// 是否重复，范例：112,返回true
/// </summary>
/// <param name="value">值</param>
/// <returns></returns>
public static bool IsRepeat(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
var array = value.ToCharArray();
return array.Any(c => array.Count(t => t == c) > );
}
#endregion #region IsQQ(是否合法QQ号码)
/// <summary>
/// 是否合法QQ号码
/// </summary>
/// <param name="value">QQ号码</param>
/// <returns></returns>
// ReSharper disable once InconsistentNaming
public static bool IsQQ(string value)
{
if (string.IsNullOrEmpty(value))
{
return false;
}
string pattern = @"^[1-9][0-9]{4,9}$";
return Regex.IsMatch(value, pattern);
}
#endregion
}
} //只能输入数字："^[0-9]*$"。
//只能输入n位的数字："^\d{n}$"。
//只能输入至少n位的数字："^\d{n,}$"。
//只能输入m ~n位的数字：。"^\d{m,n}$"
//只能输入零和非零开头的数字："^(0|[1-9][0-9]*)$"。
//只能输入有两位小数的正实数："^[0-9]+(.[0-9]{2})?$"。
//只能输入有1 ~3位小数的正实数："^[0-9]+(.[0-9]{1,3})?$"。
//只能输入非零的正整数："^\+?[1-9][0-9]*$"。
//只能输入非零的负整数："^\-[1-9][]0-9"*$。
//只能输入长度为3的字符："^.{3}$"。
//只能输入由26个英文字母组成的字符串："^[A-Za-z]+$"。
//只能输入由26个大写英文字母组成的字符串："^[A-Z]+$"。
//只能输入由26个小写英文字母组成的字符串："^[a-z]+$"。
//只能输入由数字和26个英文字母组成的字符串："^[A-Za-z0-9]+$"。
//只能输入由数字、26个英文字母或者下划线组成的字符串："^\w+$"。
//只能输入由数字、26个英文字母或者下划线,中文组成的字符串：^\\w+$
//验证用户密码："^[a-zA-Z]\w{5,17}$"正确格式为：以字母开头，长度在6 ~18之间，只能包含字符、数字和下划线。
//验证是否含有^%&',;=?$\"等字符："[^%&',;=?$\x22]+"。
//只能输入汉字："^[\u4e00-\u9fa5]{0,}$"
//验证Email地址："^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$"。
//验证InternetURL："^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$"。
//验证电话号码："^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$"正确格式为："XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX"。
//验证身份证号（15位或18位数字）："^\d{15}|\d{18}$"。
//验证一年的12个月："^(0?[1-9]|1[0-2])$"正确格式为："01"～"09"和"1"～"12"。
//验证一个月的31天："^((0?[1-9])|((1|2)[0-9])|30|31)$"正确格式为；"01"～"09"和"1"～"31"。
namespace CarHailing.Base
{
[Flags]
public enum ValidateType
{
/// <summary>
/// 验证电子邮件
/// </summary>
IsEmail = ,
/// <summary>
/// 验证手机号码
/// </summary>
IsMobileNumber = ,
/// <summary>
/// 验证身份证号
/// </summary>
IsIdCard = ,
/// <summary>
/// 验证Base64编码
/// </summary>
IsBase64String = ,
/// <summary>
/// 验证Url地址
/// </summary>
IsUrl = ,
/// <summary>
/// 验证Uri
/// </summary>
IsUri = ,
/// <summary>
/// 是否银行卡号，16位或19位银行卡（简单校验）
/// </summary>
IsBankCard = ,
/// <summary>
/// 验证空值
/// </summary>
NotEmpty = ,
/// <summary>
/// 验证最大长度
/// </summary>
MaxLength = ,
/// <summary>
/// 验证最小长度
/// </summary>
MinLength = ,
/// <summary>
/// 验证数字（包含整数和小数）@"^[-]?\d+[.]?\d*$"
/// </summary>
IsNum = ,
/// <summary>
/// 验证整数"^[0-9]*$"
/// </summary>
IsInt = ,
/// <summary>
/// 验证日期
/// bool bValid = Regex.IsMatch(Date, @"^((((1[6-9]|[2-9]\d)\d{2})-(0?[13578]|1[02])-(0?[1-9]|[12]\d|3[01]))|(((1[6-9]|[2-9]\d)\d{2})-(0?[13456789]|1[012])-(0?[1-9]|[12]\d|30))|(((1[6-9]|[2-9]\d)\d{2})-0?2-(0?[1-9]|1\d|2[0-8]))|(((1[6-9]|[2-9]\d)(0[48]|[2468][048]|[13579][26])|((16|[2468][048]|[3579][26])00))-0?2-29-))$");
/// return (bValid && Date.CompareTo("1753-01-01") >= 0);
/// </summary>
IsDate = ,
/// <summary>
/// 验证手机号@"^[1]+[3,5]+\d{9}"
/// </summary>
IsMobilePhone = ,
/// <summary>
/// 验证电话号码@"^(\d{3,4}-)?\d{6,8}$"
/// </summary>
IsTelephone = ,
/// <summary>
/// 验证IP@"^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$"
/// </summary>
IsIpAddress = // NotEmpty = 1,
//MaxLength = 2,
//MinLength = 4,
//IsPhone = 8 } [AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
public class ValidateAttribute : Attribute
{
public ValidateAttribute(ValidateType validateType)
{
ValidateType = validateType;
}
private ValidateType validateType;
private int minLength;
private int maxLength;
private string errorMessage;
public ValidateType ValidateType { get { return validateType; } set { validateType = value; } }
public string ErrorMessage { get { return errorMessage; } set { errorMessage = value; } }
public int MinLength { get { return minLength; } set { minLength = value; } }
public int MaxLength { get { return maxLength; } set { maxLength = value; } }
}
public class ValidateModel
{
private ValidateType type;
private ValidateHelper.Func checkFunc;
private string errorMessage;
//private delegate bool func();
/// <summary>
/// 验证类型
/// </summary>
public ValidateType Type { get { return type; } set { type = value; } }
/// <summary>
/// 验证函数
/// </summary>
public ValidateHelper.Func CheckFunc { get { return checkFunc; } set { checkFunc = value; } }
/// <summary>
/// 错误信息
/// </summary>
public string ErrorMessage { get { return errorMessage; } set { errorMessage = value; } }
}
public class ValidateHelper
{
public delegate bool Func();
/// <summary>
/// 检查需要验证的函数是否通过
/// </summary>
/// <param name="checkType">被检查类型</param>
/// <param name="matchType">需要检查的类型</param>
/// <param name="func">检查函数</param>
/// <param name="errMessage">错误信息</param>
/// <returns>Emtpy 验证通过，否则返回错误信息</returns>
private static string CheckValidate(ValidateType checkType, ValidateType matchType, Func func, string errMessage)
{
if ((checkType & matchType) != )
{
if (func())
{
return errMessage;
}
}
return String.Empty;
} /// <summary>
/// 检查对象是否通过验证
/// </summary>
/// <param name="entityObject">需要检查的对象</param>
/// <param name="errMessage">返回错误信息</param>
/// <returns>true:通过，false：失败</returns>
public static bool GetValidateResult(object entityObject, out string errMessage)
{
Type type = entityObject.GetType();
PropertyInfo[] properties = type.GetProperties(); string validateResult = string.Empty;
errMessage = string.Empty;
foreach (PropertyInfo property in properties)
{
object[] validateContent = property.GetCustomAttributes(typeof(ValidateAttribute), true);
if (validateContent != null)
{
object value = property.GetValue(entityObject, null);
foreach (ValidateAttribute validateAttribute in validateContent)
{
IList<ValidateModel> condition = new List<ValidateModel>();
//需要什么验证，在这里添加
ValidateModel vmode = new ValidateModel();
vmode.Type = ValidateType.NotEmpty;
vmode.CheckFunc = delegate { return (value == null || value.ToString().Length < ); };
vmode.ErrorMessage = validateAttribute.ErrorMessage ?? String.Format("元素{0}不能为空。", property.Name);
condition.Add(vmode); vmode = new ValidateModel();
vmode.Type = ValidateType.MaxLength;
vmode.CheckFunc = delegate { return (value.ToString().Length > validateAttribute.MaxLength); };
vmode.ErrorMessage = validateAttribute.ErrorMessage ?? String.Format("元素{0}长度不能超过{1}", property.Name, validateAttribute.MaxLength);
condition.Add(vmode); vmode = new ValidateModel();
vmode.Type = ValidateType.MinLength;
vmode.CheckFunc = delegate { return (value.ToString().Length < validateAttribute.MinLength); };
vmode.ErrorMessage = validateAttribute.ErrorMessage ?? String.Format("元素{0}长度不能小于{1}", property.Name, validateAttribute.MinLength);
condition.Add(vmode); vmode = new ValidateModel();
vmode.Type = ValidateType.IsMobileNumber;
vmode.CheckFunc = delegate { return (!Valid.IsMobileNumber(value.ToString())); };
vmode.ErrorMessage = validateAttribute.ErrorMessage ?? String.Format("元素{0}必须是电话号码", property.Name);
condition.Add(vmode); vmode = new ValidateModel();
vmode.Type = ValidateType.IsIdCard;
vmode.CheckFunc = delegate { return (!Valid.IsIdCard(value.ToString())); };
vmode.ErrorMessage = validateAttribute.ErrorMessage ?? String.Format("元素{0}必须是身份证号码", property.Name);
condition.Add(vmode); foreach (ValidateModel model in condition)
{
validateResult = CheckValidate(
validateAttribute.ValidateType,
model.Type,
model.CheckFunc,
model.ErrorMessage
);
if (!string.IsNullOrEmpty(validateResult))
{
errMessage = validateResult;
return false;
}
}
}
}
}
return true;
}
}
}
------------------------------------------------------------------------------------------------------------
4、其它一些Helper类
Log4Help，SwaggerWcf在线Api，解决引用的包及项目版本不匹配或者过低问题
以上这些东西在这个链接里面https://www.cnblogs.com/AV1973/p/8674958.html，因为之前写过了，这里就懒得留了。
一个简单实用的SqlHelper类
链接：http://www.cnblogs.com/AV1973/p/8674533.html
一份DataHelper类，这里面还是有些东西的，不多，但够平常用了。
链接：http://www.cnblogs.com/AV1973/p/8674515.html
------------------------------------------------------------------------------------------------------------
5、概率转换（double转为百分比）
#region 概率转换（double转为百分比）
/// <summary>
/// 概率转换（double转为百分比）
/// 不进行四舍五入
/// 23.6%
/// </summary>
/// <param name="str">double类型的字符串</param>
/// <param name="lenght">保留小数位（默认1位）</param>
/// <param name="addStr">是否显示百分比符号%（默认显示）；1-显示、2-不显示</param>
/// <returns></returns>
public static string doubleToRate(string str, int lenght = , int addStr = )
{
string rateStr = string.Empty;
str = (Convert.ToDouble(str) * ).ToString();
var sprtStr = str.ToString().Split('.');
if (sprtStr.Length > )
{
if (sprtStr[].Length > lenght)
{
int indexStr = Convert.ToInt32(sprtStr[].Substring(, lenght));
rateStr = sprtStr[] + "." + (indexStr).ToString();
}
else
{
rateStr = sprtStr[] + "." + (Convert.ToInt32(sprtStr[])).ToString();
}
}
else
{
rateStr = (Convert.ToInt32(str)).ToString();
}
if (addStr == )
return rateStr + "%";
else
return rateStr;
}
/// <summary>
/// 概率转换（double转为百分比）
/// 不进行四舍五入
/// 23.6%
/// </summary>
/// <param name="str">double类型的字符串</param>
/// <param name="lenght">保留小数位（默认1位）</param>
/// <param name="addStr">是否显示百分比符号%（默认显示）；1-显示、2-不显示</param>
/// <returns></returns>
public static string divisionToRate(string bcs, string cs, int lenght = , int addStr = )
{
string rateStr = string.Empty;
double str = ;
if (bcs.Equals("") || bcs.Equals("0.00"))
return "0%";
str = (Convert.ToDouble(bcs) / Convert.ToDouble(cs)) *;
//str = (Convert.ToDouble(str) * 100).ToString();
var sprtStr = str.ToString().Split('.');
if (sprtStr.Length > )
{
if (sprtStr[].Length > lenght)
{
int indexStr = Convert.ToInt32(sprtStr[].Substring(, lenght));
rateStr = sprtStr[] + "." + (indexStr).ToString();
}
else
{
rateStr = sprtStr[] + "." + (Convert.ToInt32(sprtStr[])).ToString();
}
}
else
{
rateStr = (Convert.ToInt32(str)).ToString();
}
if (addStr == )
return rateStr + "%";
else
return rateStr;
}
/// <summary>
/// 概率转换（double转为百分比）四舍五入
/// </summary>
/// <param name="bcs">被除数</param>
/// <param name="cs">除数</param>
/// <param name="ftype">保留的百分比小数位，1-2位（22.22%）、2-1位（22.2%）</param>
/// <returns></returns>
public static string divisionToRate(double bcs,double cs,int ftype=)
{
string str;
try
{
switch (ftype)
{
case :
str = (bcs / cs).ToString("p");
break;
case :
str = (bcs / cs).ToString("0.0%");
break;
default:
str = (bcs / cs).ToString("p");
break;
}
}
catch
{
str = "";
}
return str;
}
#endregion
------------------------------------------------------------------------------------------------------------
6、数字转换为货币表达方式（三位加逗号）
#region 数字转换为货币表达方式（三位加逗号）
/// <summary>
/// 输入decimal格式数字，将其转换为货币表达方式
/// </summary>
/// <param name="ftype">货币表达类型：0=带￥的货币表达方式；1=不带￥的货币表达方式；其它=带￥的货币表达方式；默认为1</param>
/// <param name="fmoney">传入的decimal数字</param>
/// <returns>返回转换的货币表达形式</returns>
public static string Rmoney(decimal fmoney, int ftype = )
{
string _rmoney;
try
{
switch (ftype)
{
case :
_rmoney = string.Format("{0:C2}", fmoney);
break;
case :
_rmoney = string.Format("{0:N2}", fmoney);
break;
default:
_rmoney = string.Format("{0:C2}", fmoney);
break;
}
}
catch
{
_rmoney = "";
}
return _rmoney;
}
#endregion
需要的自己看，自己拿啊。
转载需注明出处。
C# 一些零零碎碎的方法，都是些帮助类，留存，也希望能帮助到各位的更多相关文章
- 所有做java开发的都是些垃圾
所有做java开发的都是些垃圾,再垃圾的框架,只要有人用,对java程序员来说那就是高性能,高可用,解耦的,非常优秀的一款框架.属于吃屎都吃的津津有味.java里的框架都是垃圾,连一个不错的都没有.比 ...
- cookie、session和application都是些什么神？——图文加案例，不怕你不会，就怕你不看
cookie.session和application都是些什么神? 前言: 一直想写一篇关于cookie和session的博客,由于种种原因,一直没有整理,这不,今天还就遇到问题了,之前虽然会,但是好 ...
- SEO大神都是些什么人
http://www.wocaoseo.com/thread-97-1-1.html 貌似好久没有更新seo培训联盟的文章了,最近一直在专心学习其他的东西,前一段写了几篇关于用户需求和体验的文章,但是 ...
- 别再眼高手低了! 这些Linq方法都清楚地掌握了吗？
不要再眼高手低了,这些Enumerable之常见Linq扩展方法都清楚掌握了吗?其实这是对我自己来说的! 例如:一个人这个技术掌握了一点那个技术也懂一点,其他的好像也了解一些,感觉自己啥都会一点,又觉 ...
- hive权威安装出现的不解错误！（完美解决）两种方法都可以
以下两种方法都可以,推荐用方法一! 方法一: 步骤一: yum -y install mysql-server 步骤二:service mysqld start 步骤三:mysql -u root - ...
- java多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
多线程有两种实现方法,分别是继承Thread类与实现Runnable接口 同步的实现方面有两种,分别是synchronized,wait与notify 先看一下java线程运行时各个阶段的运行状态 j ...
- -1-5 java 多线程 概念 进程 线程区别联系 java创建线程方式 线程组 线程池概念 线程安全 同步 同步代码块 Lock锁 sleep()和wait()方法的区别 为什么wait(),notify(),notifyAll()等方法都定义在Object类中
本文关键词: java 多线程 概念 进程 线程区别联系 java创建线程方式 线程组 线程池概念 线程安全 同步 同步代码块 Lock锁 sleep()和wait()方法的区别 为什么wait( ...
- PHP正则表达式 /i, /is, /s, /isU等 都是些什么东西呢？
PHP正则表达式 /i, /is, /s, /isU等 都是些什么东西呢? i 不区分大小写 s 模式中的圆点元字符(.)匹配所有的字符,包括换行符 x 模式中的空白字符除了被转义的或在字符类中的以外 ...
- Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行，它们有什么区别? 线程的sleep()方法和yield()方法有什么区别？
Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行,它们有什么区别? sleep()方法(休眠)是线程类(Thread)的静态方法,调用此方法会让当前线程暂停执行指定的时间 ...
随机推荐
- JDK Linux下安装
下载jdk-6u45-linux-x64.bin到/root目录下执行./jdk-6u45-linux-x64.bin 会在/root目录下生成 jdk1.6.0_45 文件 之后配置环境变量 编辑/ ...
- 51nod 1350 斐波那契表示（递推+找规律）
传送门 题意 分析 我们发现该数列遵循下列规律: 1 1,2 1,2,2 1,2,2,2,3 1,2,2,2,3,2,3,3 我们令A[i]表示f[i]开始长为f[i-1]的i的最短表示和 那么得到A ...
- 【NOIP 2013】积木大赛
描述 春春幼儿园举办了一年一度的“积木大赛”.今年比赛的内容是搭建一座宽度为 n 的大厦,大厦可以看成由 n 块宽度为1的积木组成,第
- CentOS文件服务与数据管理
CentOS文件服务与数据管理-专栏简介 本专栏内容涵盖了中高级Linux系统管理员所必须的文件服务.磁盘管理.数据管理.文件恢复等必备技能,实乃涨薪.跳槽之必备技能,且听一线运维老兵为你逐步揭开迷雾 ...
- 牛客寒假算法基础集训营4 F Applese 的QQ群
链接:https://ac.nowcoder.com/acm/contest/330/F来源:牛客网 Applese 有一个QQ群.在这个群中,大家互相请教问题.如 b 向 a 请教过问题,就把 a ...
- eclipse字体
- pytorch 迁移学习[摘自官网]
迁移学习包含两种:微调和特征提取器. 微调:对整个网络进行训练,更新所有参数 特征提取器:只对最后的输出层训练,其他层的权重保持不变 当然,二者的共性就是需要加载训练好的权重,比如在ImageNet上 ...
- js 多张爆炸效果轮播图
<!doctype html> <html> <head> <meta charset="utf-8"> <title> ...
- C# repeater控件序号绑定
做项目列表经常会需要列表有一个序号列,根据控件自身的属性就可以很方便的实现这个功能,如下图 这个不能用翻页功能,如果翻页重新刷新控件的话,序号会又重新开始!
- 及时从数据库中取得数据填放进Form表单的多选框中
#写上以下代码就不用担心数据库添加了数据而不能及时获取了 def __init__(self, *args, **kwargs): #每次创建Form1对象时执行init方法 super(Form1, ...