public void ShouldParseRegisteredType() { var parsers = new TypeParsers(); parsers.RegisterTypeParser <int>(new HexParser()); Assert.That(parsers.Parse <int>("10"), Is.EqualTo(16)); }
public ValidatorFluent NotIn <T>(params object[] vals) { if (!this._checkCondition) { return(this); } if (vals == null || vals.Length == 0) { return(this); } T t = TypeParsers.ConvertTo <T>(this._target); bool isValid = true; for (int i = 0; i < vals.Length; i++) { object input = vals[i]; T t2 = TypeParsers.ConvertTo <T>(input); if (t.Equals(t2)) { isValid = false; break; } } return(this.IsValid(isValid, "不是一个有效值")); }
public void ShouldGenerateRegisteredType() { var parsers = new TypeParsers(); parsers.RegisterTypeParser <int>(new HexParser()); Assert.That(parsers.Generate(16), Is.EqualTo("10")); }
public static TType Scalar <TType>(this DataBase db, IDbTransaction tran, string strSql, params IDataParameter[] parameters) { TType tType = default(TType); object input = db.ExecuteScalar(tran, CommandType.Text, strSql, parameters); return(TypeParsers.ConvertTo <TType>(input)); }
/// <summary> /// Get the value at the row/column name. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="row"></param> /// <param name="colName"></param> /// <returns></returns> public T Get <T>(int row, string colName) { string result = (string)_records[row][colName]; T typedResult = (T)TypeParsers.Convert <T>(result); return(typedResult); }
/// <summary> /// Get typed root setting by string key. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="key"></param> /// <returns></returns> public virtual T Get <T>(string key) { object result = this[key]; T converted = (T)TypeParsers.Convert <T>(result); return(converted); }
/// <summary> /// Get typed section key value. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="section"></param> /// <param name="key"></param> /// <returns></returns> public T Get <T>(string section, string key) { object result = this[section, key]; T converted = (T)TypeParsers.Convert <T>(result); return(converted); }
public static T Get <T>(string key) { T result; try { string text = string.Empty; HttpRequest request = HttpContext.Current.Request; if (request.HttpMethod.ToUpper() == "GET") { text = request.QueryString[key]; } else { text = request[key]; } text = HttpUtility.UrlDecode(text, Encoding.UTF8); T t = TypeParsers.ConvertTo <T>(text); result = t; } catch { throw; } return(result); }
public static IList <IScheduledRule> LoadRules(string strRules) { IList <IScheduledRule> list = new List <IScheduledRule>(); foreach (Match match in ScheduledUtils.regex.Matches(strRules)) { ScheduledRule scheduledRule = new ScheduledRule(); scheduledRule.Rule = new TaskRule { Type = match.Groups["Type"].Value, Offest = match.Groups["Offset"].Value }; string value = match.Groups["Count"].Value; scheduledRule.Count = (string.IsNullOrEmpty(value) ? 0 : TypeParsers.ConvertTo <int>(value)); string value2 = match.Groups["EndDate"].Value; scheduledRule.End = (string.IsNullOrEmpty(value2) ? DateTime.MinValue : TypeParsers.ConvertTo <DateTime>(value2)); if (Enum.IsDefined(ScheduledUtils.type, scheduledRule.Rule.Type)) { list.Add(scheduledRule); } } foreach (Match match2 in ScheduledUtils.regexBlockInterval.Matches(strRules)) { ScheduledBlockIntervalRule scheduledBlockIntervalRule = new ScheduledBlockIntervalRule(); scheduledBlockIntervalRule.Begin = match2.Groups["Begin"].Value; scheduledBlockIntervalRule.Interval = match2.Groups["Interval"].Value; scheduledBlockIntervalRule.Region = new TaskRegion { Type = match2.Groups["RegionType"].Value, StartOffest = match2.Groups["StartOffset"].Value, StopOffest = match2.Groups["StopOffset"].Value }; if (Enum.IsDefined(ScheduledUtils.type, scheduledBlockIntervalRule.Region.Type)) { list.Add(scheduledBlockIntervalRule); } } foreach (Match match3 in ScheduledUtils.regexBlockTimer.Matches(strRules)) { ScheduledBlockTimerRule scheduledBlockTimerRule = new ScheduledBlockTimerRule(); scheduledBlockTimerRule.Begin = match3.Groups["Begin"].Value; scheduledBlockTimerRule.Rule = new TaskRule { Type = match3.Groups["RuleType"].Value, Offest = match3.Groups["RuleOffset"].Value }; scheduledBlockTimerRule.Region = new TaskRegion { Type = match3.Groups["RegionType"].Value, StartOffest = match3.Groups["StartOffset"].Value, StopOffest = match3.Groups["StopOffset"].Value }; if (Enum.IsDefined(ScheduledUtils.type, scheduledBlockTimerRule.Rule.Type) && Enum.IsDefined(ScheduledUtils.type, scheduledBlockTimerRule.Region.Type)) { list.Add(scheduledBlockTimerRule); } } return(list); }
public bool TypeSupported(Type targetType) { if (TypeParsers.ContainsKey(targetType)) { return(true); } return(ExtraParsers.Any(x => x.Parses(targetType))); }
public static T Get <T>(string key) { if (string.IsNullOrEmpty(key)) { throw new Exception("Key is null..."); } string input = ConfigurationManager.AppSettings[key]; return(TypeParsers.ConvertTo <T>(input)); }
public static BoolResult <TType> Scalar <TType>(this DataBase db, string strSql, params IDataParameter[] parameters) { ValidationResults validationResults = new ValidationResults(); TType item = default(TType); try { object input = db.ExecuteScalar(db.ConnectionString, CommandType.Text, strSql, parameters); item = TypeParsers.ConvertTo <TType>(input); } catch (Exception ex) { validationResults.Add(ex.Message); } return(new BoolResult <TType>(item, validationResults.IsValid, string.Empty, validationResults)); }
public object ReadValue(string rawValue, Type targetType, string fieldOrParameterName) { IParser parser; if (TypeParsers.TryGetValue(targetType, out parser)) { return(parser.ReadValue(rawValue, fieldOrParameterName)); } var extra = ExtraParsers.FirstOrDefault(x => x.Parses(targetType)); if (extra != null) { return(extra.ReadValue(targetType, rawValue, fieldOrParameterName)); } MvxTrace.Error("Parameter {0} is invalid targetType {1}", fieldOrParameterName, targetType.Name); return(null); }
public static Dictionary<string, StringValues> Parse(TParameters parameters) { var nvc = QueryHelpers.ParseQuery(""); var properties = typeof(TParameters).GetProperties(); foreach (var prop in properties.OrderBy(o => o.Name)) { if (Converters.ContainsKey(prop.PropertyType)) { var o = prop.GetValue(parameters); if (o != null) { var defaultValue = GetDefaultValue(prop); if (defaultValue == null || o.ToString() != defaultValue.ToString()) { Converters[prop.PropertyType](nvc, o, GetParameterName(prop).Camelize()); } } } } return TypeParsers.Sort(nvc); }
public static NameValueCollection Parse(TParameters parameters) { var nvc = HttpUtility.ParseQueryString(""); var properties = typeof(TParameters).GetProperties(); foreach (var prop in properties.OrderBy(o => o.Name)) { if (Converters.ContainsKey(prop.PropertyType)) { var o = prop.GetValue(parameters); if (o != null) { var defaultValue = GetDefaultValue(prop); if (defaultValue == null || o.ToString() != defaultValue.ToString()) { Converters[prop.PropertyType](nvc, o, GetParameterName(prop).Camelize()); } } } } return(TypeParsers.Sort(nvc)); }
/// <summary> /// Load settings for a specific tenant /// </summary> /// <typeparam name="TSetting"></typeparam> /// <param name="tenantKey"></param> /// <returns></returns> public static TSetting Get <TSetting>(string tenantKey) { TSetting setting = new AppCfgTypeMixer <object>().ExtendWith <TSetting>(); var props = setting.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); foreach (var prop in props) { if (TypeParsers.Get(prop.PropertyType) == null) { object settingObj = null; if (prop.PropertyType.IsInterface) { var myMethod = typeof(MyAppCfg) .GetMethods() .Where(m => m.Name == "Get") .Select(m => new { Method = m, Params = m.GetParameters(), Args = m.GetGenericArguments() }) .Where(x => x.Params.Length == 1 && x.Params[0].Name == "tenantKey") .Select(x => x.Method) .First(); MethodInfo genericMethod = myMethod.MakeGenericMethod(prop.PropertyType); settingObj = genericMethod.Invoke(null, new[] { tenantKey }); prop.SetValue(setting, settingObj); continue; } else { settingObj = Activator.CreateInstance(prop.PropertyType); if (settingObj is IJsonDataType) // auto register json parser for types which inherited from IJsonDataType { var jsParser = Activator.CreateInstance(typeof(JsonParser <>).MakeGenericType(prop.PropertyType)); TypeParsers.Register(prop.PropertyType, jsParser); } } } if (TypeParsers.Get(prop.PropertyType) != null) { try { ITypeParserOptions parserOpt = (ITypeParserOptions)prop.GetCustomAttribute <OptionAttribute>() ?? new OptionAttribute(); ISettingStore storeOpt = (ISettingStore)prop.GetCustomAttribute <StoreOptionAttribute>() ?? new StoreOptionAttribute(); string rawValue = null; if (parserOpt?.RawValue != null) { rawValue = parserOpt.RawValue; } else { var settingKey = parserOpt?.Alias ?? prop.Name; if (typeof(ITypeParserRawBuilder <>).MakeGenericType(prop.PropertyType).IsAssignableFrom(TypeParsers.Get(prop.PropertyType).GetType())) { rawValue = (string)typeof(ITypeParserRawBuilder <>).MakeGenericType(prop.PropertyType).GetMethod("GetRawValue").Invoke(TypeParsers.Get(prop.PropertyType), new[] { settingKey }); } else { rawValue = GetRawValue(prop.PropertyType, tenantKey, settingKey, parserOpt, storeOpt); } } if (rawValue != null) { prop.SetValue(setting, typeof(ITypeParser <>).MakeGenericType(prop.PropertyType).GetMethod("Parse").Invoke(TypeParsers.Get(prop.PropertyType), new[] { rawValue, (object)parserOpt }), null); } else { prop.SetValue(setting, parserOpt?.DefaultValue); } } catch (Exception ex) { var tParserType = TypeParsers.Get(prop.PropertyType) != null?TypeParsers.Get(prop.PropertyType).GetType().ToString() : "null"; throw new AppCfgException($"{ex.InnerException?.Message ?? ex.Message}\n - Setting: {typeof(TSetting)}\n - Property Name: {prop.Name}\n - Property Type: {prop.PropertyType}\n - Parser: {tParserType}", ex); } } else { throw new AppCfgException($"There is no type parser for type [{prop.PropertyType}]. You maybe need to create a custom type parser for it"); } } return(setting); }
public static string ConvertToJsonString <T>(PagedList <T> result, IList <PropertyInfo> _columnProps, bool convertBoolToYesNo = false) { StringBuilder stringBuilder = new StringBuilder(); for (int i = 0; i < result.Count; i++) { T t = result[i]; string arg_1A_0 = string.Empty; string text = string.Empty; stringBuilder.Append("{ "); for (int j = 0; j < _columnProps.Count; j++) { PropertyInfo propertyInfo = _columnProps[j]; object value = _columnProps[j].GetValue(t, null); Type propertyType = propertyInfo.PropertyType; bool flag = false; if (propertyType == typeof(string)) { text = ((value == null) ? string.Empty : value.ToString()); text = text.Replace("\\", "\\\\"); text = text.Replace("\"", "\\\""); flag = true; } else { if (propertyType == typeof(bool)) { text = ((value == null) ? "false" : value.ToString().ToLower()); if (convertBoolToYesNo) { text = ((text == "true") ? "\"yes\"" : "\"no\""); } } else { if (propertyType == typeof(DateTime)) { if (value == null) { text = "0"; } else { text = ((DateTime)value).ToShortDateString(); flag = true; } } else { if (propertyType == typeof(int) || propertyType == typeof(long) || propertyType == typeof(float) || propertyType == typeof(double)) { text = TypeParsers.ConvertTo <double>(value).ToString(); } } } } if (flag) { stringBuilder.Append(string.Concat(new string[] { "\"", _columnProps[j].Name, "\": \"", text, "\"" })); } else { stringBuilder.Append("\"" + _columnProps[j].Name + "\": " + text); } if (j != _columnProps.Count - 1) { stringBuilder.Append(", "); } } stringBuilder.Append(" }"); if (i != result.Count - 1) { stringBuilder.Append(","); } } return(stringBuilder.ToString()); }
public static TType SPScalar <TType>(this DataBase db, IDbTransaction tran, string spName, params IDataParameter[] parameters) { object input = db.ExecuteScalar(tran, spName, parameters); return(TypeParsers.ConvertTo <TType>(input)); }
public T GetValue <T>() { return(TypeParsers.ConvertTo <T>(this.m_sValue)); }