/// <summary> /// Returns a <see cref="string" /> that represents the instance. /// <para /> /// If the <paramref name="instance" /> is <c>null</c>, this method will return "null". This /// method is great when the value of a property must be logged. /// </summary> /// <param name="instance">The instance, can be <c>null</c>.</param> /// <param name="cultureInfo">The culture information.</param> /// <returns>A <see cref="string" /> that represents the instance.</returns> public static string ToString(object instance, CultureInfo cultureInfo) { if (instance is null) { return("null"); } #if !NETFX_CORE if (instance == DBNull.Value) { return("dbnull"); } #endif var instanceType = instance.GetType(); if (instanceType == typeof(DateTime) || instanceType == typeof(DateTime?)) { return(((DateTime)instance).ToString(cultureInfo)); } #if !NETFX_CORE // Note: Not supported on NETFX_CORE, don't enable, really doesn't work. If you need a ToString // for a specific string, use a cast like the DateTime about // Check if there is a culture specific version var toStringMethod = instanceType.GetMethodEx("ToString", TypeArray.From <IFormatProvider>()); if (toStringMethod != null) { return((string)toStringMethod.Invoke(instance, new object[] { cultureInfo })); } #endif return(instance.ToString()); }
private bool TryCreateDataTypeExpressionForEnum(Type propertyType, bool isNullable) { if (!propertyType.IsEnumEx()) { return(false); } if (DataTypeExpression is null) { return(true); } var enumExpressionGenericType = typeof(EnumExpression <>).MakeGenericType(propertyType); if (enumExpressionGenericType.IsAssignableFromEx(DataTypeExpression.GetType()) && (DataTypeExpression as NullableDataTypeExpression)?.IsNullable == isNullable) { return(true); } var constructorInfo = enumExpressionGenericType.GetConstructorEx(TypeArray.From <bool>()); DataTypeExpression = (DataTypeExpression)constructorInfo?.Invoke(new object[] { isNullable }); return(true); }
/// <summary> /// Determines what value this converter should return. /// </summary> /// <param name="value">The value produced by the binding source.</param> /// <param name="targetType">The type of the binding target property.</param> /// <param name="parameter">The converter parameter to use.</param> /// <returns> /// <c>true</c> if the specified value is visible; otherwise, <c>false</c>. /// </returns> protected override bool IsVisible(object value, Type targetType, object parameter) { if (value == null) { return(false); } var enumType = value.GetType(); if (!enumType.IsEnumEx()) { return(false); } var stringParameter = parameter as string; if (string.IsNullOrWhiteSpace(stringParameter)) { return(false); } var invert = false; if (stringParameter.StartsWith("!")) { invert = true; stringParameter = stringParameter.Substring(1); } var genericEnumType = typeof(Enum <>).MakeGenericType(enumType); var bindingFlags = BindingFlags.Public | BindingFlags.Static; var parseMethod = genericEnumType.GetMethodEx("Parse", TypeArray.From <string, bool>(), bindingFlags); var allowedEnumValues = stringParameter.Split(SplitChars, StringSplitOptions.RemoveEmptyEntries); foreach (var allowedEnumValueAsString in allowedEnumValues) { var parameters = new object[] { allowedEnumValueAsString, true }; try { var allowedEnumValue = parseMethod.Invoke(null, parameters); if (value.Equals(allowedEnumValue)) { return(!invert); } } catch (Exception) { // Next! } } return(invert); }
/// <summary> /// Gets the <c>Parse(string, IFormatProvider)</c> method. /// </summary> /// <param name="memberType">Type of the member.</param> /// <returns></returns> protected virtual MethodInfo GetObjectParseMethod(Type memberType) { var parseMethod = _parseMethodCache.GetFromCacheOrFetch(memberType, () => { var method = memberType.GetMethodEx("Parse", TypeArray.From <string, IFormatProvider>(), BindingFlags.Public | BindingFlags.Static | BindingFlags.FlattenHierarchy); return(method); }); return(parseMethod); }
/// <summary> /// Gets the <c>ToString(IFormatProvider)</c> method. /// </summary> /// <param name="memberType">Type of the member.</param> /// <returns></returns> protected virtual MethodInfo GetObjectToStringMethod(Type memberType) { var toStringMethod = _toStringMethodCache.GetFromCacheOrFetch(memberType, () => { var method = memberType.GetMethodEx("ToString", TypeArray.From <IFormatProvider>(), BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy); return(method); }); return(toStringMethod); }
private bool IsTypeBinarySerializable(Type type) { if (type == null) { return(false); } return(TypeBinarySerializableCache.GetFromCacheOrFetch(type, () => type.GetConstructor(TypeArray.From <SerializationInfo, StreamingContext>()) != null)); }
//// TODO: Try to combine expression builders as much as possible. private static Expression BuildStringExpression(Condition condition, Expression propertyExpression, Expression valueExpression) { switch (condition) { case Condition.Contains: return(Expression.AndAlso(Expression.Not(Expression.Call(typeof(string).GetMethod("IsNullOrEmpty", TypeArray.From <string>()), propertyExpression)), Expression.Call(propertyExpression, typeof(string).GetMethod("Contains", TypeArray.From <string>()), valueExpression))); case Condition.DoesNotContain: return(Expression.Not(BuildStringExpression(Condition.Contains, propertyExpression, valueExpression))); case Condition.StartsWith: return(Expression.AndAlso(Expression.Not(Expression.Call(typeof(string).GetMethod("IsNullOrEmpty", TypeArray.From <string>()), propertyExpression)), Expression.Call(propertyExpression, typeof(string).GetMethod("StartsWith", TypeArray.From <string>()), valueExpression))); case Condition.DoesNotStartWith: return(Expression.Not(BuildStringExpression(Condition.StartsWith, propertyExpression, valueExpression))); case Condition.EndsWith: return(Expression.AndAlso(Expression.Not(Expression.Call(typeof(string).GetMethod("IsNullOrEmpty", TypeArray.From <string>()), propertyExpression)), Expression.Call(propertyExpression, typeof(string).GetMethod("EndsWith", TypeArray.From <string>()), valueExpression))); case Condition.DoesNotEndWith: return(Expression.Not(BuildStringExpression(Condition.EndsWith, propertyExpression, valueExpression))); case Condition.EqualTo: return(Expression.AndAlso(Expression.Not(Expression.Call(typeof(string).GetMethod("IsNullOrEmpty", TypeArray.From <string>()), propertyExpression)), Expression.Equal(propertyExpression, valueExpression))); case Condition.NotEqualTo: return(Expression.Not(BuildStringExpression(Condition.EqualTo, propertyExpression, valueExpression))); case Condition.GreaterThan: return(Expression.GreaterThan(Expression.Call( typeof(string).GetMethod("Compare", TypeArray.From <string, string, StringComparison>()), propertyExpression, valueExpression, Expression.Constant(StringComparison.OrdinalIgnoreCase)), Expression.Constant(0))); case Condition.GreaterThanOrEqualTo: return(Expression.GreaterThanOrEqual( Expression.Call( typeof(string).GetMethod("Compare", TypeArray.From <string, string, StringComparison>()), propertyExpression, valueExpression, Expression.Constant(StringComparison.OrdinalIgnoreCase)), Expression.Constant(0))); case Condition.LessThan: return(Expression.LessThan(Expression.Call( typeof(string).GetMethod("Compare", TypeArray.From <string, string, StringComparison>()), propertyExpression, valueExpression, Expression.Constant(StringComparison.OrdinalIgnoreCase)), Expression.Constant(0))); case Condition.LessThanOrEqualTo: return(Expression.LessThanOrEqual(Expression.Call( typeof(string).GetMethod("Compare", TypeArray.From <string, string, StringComparison>()), propertyExpression, valueExpression, Expression.Constant(StringComparison.OrdinalIgnoreCase)), Expression.Constant(0))); case Condition.IsNull: return(Expression.Equal(propertyExpression, Expression.Constant(null))); case Condition.NotIsNull: return(Expression.Not(Expression.Equal(propertyExpression, Expression.Constant(null)))); case Condition.IsEmpty: return(Expression.Equal(propertyExpression, Expression.Constant(string.Empty))); case Condition.NotIsEmpty: return(Expression.Not(Expression.Equal(propertyExpression, Expression.Constant(string.Empty)))); default: throw new NotSupportedException(string.Format( LanguageHelper.GetString("FilterBuilder_Exception_Message_ConditionIsNotSupported_Pattern"), condition)); } }