public override object Convert(object source, Type sourceType, Type targetType) { if (source == null) { return(null); } var targetElementType = ConversionUtils.GetElementType(targetType); if (targetElementType == null) { throw new InvalidOperationException("No target element type"); } var enumerable = source as IEnumerable; var len = ConversionUtils.Count(enumerable); var array = Array.CreateInstance(targetElementType, len); var i = 0; foreach (var sourceElement in enumerable) { var targetElement = _conversionService.Convert(sourceElement, sourceElement.GetType(), targetElementType); array.SetValue(targetElement, i++); } return(array); }
public override object Convert(object source, Type sourceType, Type targetType) { if (source == null) { return(null); } var sourceString = source as string; var fields = sourceString.Split(_delimit, StringSplitOptions.RemoveEmptyEntries); var targetElementType = ConversionUtils.GetElementType(targetType); var list = ConversionUtils.CreateCompatListFor(targetType); if (list == null) { throw new InvalidOperationException("Unable to create compatable list"); } for (var i = 0; i < fields.Length; i++) { var sourceElement = fields[i]; var targetElement = _conversionService.Convert(sourceElement.Trim(), sourceType, targetElementType); list.Add(targetElement); } return(list); }
private bool CanConvertValue(Type sourceType, Type targetType) { return(ConversionUtils.CanConvertElements( ConversionUtils.GetDictionaryValueType(sourceType), ConversionUtils.GetDictionaryValueType(targetType), _conversionService)); }
public override bool Matches(Type sourceType, Type targetType) { if (sourceType == typeof(string) && ConversionUtils.CanCreateCompatListFor(targetType)) { return(ConversionUtils.CanConvertElements(sourceType, ConversionUtils.GetElementType(targetType), _conversionService)); } return(false); }
public override bool Matches(Type sourceType, Type targetType) { if (!targetType.IsArray || sourceType.IsArray) { return(false); } return(ConversionUtils.CanConvertElements( ConversionUtils.GetElementType(sourceType), ConversionUtils.GetElementType(targetType), _conversionService)); }
private static MethodInfo DetermineToMethod(Type targetClass, Type sourceClass) { if (typeof(string) == targetClass || typeof(string) == sourceClass) { // Do not accept a ToString() method or any to methods on String itself return(null); } var method = ConversionUtils.GetMethodIfAvailable(sourceClass, "To" + targetClass.Name); return(method != null && !method.IsStatic && targetClass.IsAssignableFrom(method.ReturnType) ? method : null); }
public override object Convert(object source, Type sourceType, Type targetType) { string asString = source as string; if (string.IsNullOrEmpty(asString)) { return(null); } targetType = ConversionUtils.GetNullableElementType(targetType); return(Enum.Parse(targetType, asString.Trim(), true)); }
public override object Convert(object source, Type sourceType, Type targetType) { if (source == null) { return(null); } var sourceDict = source as IDictionary; var len = sourceDict.Count; // Shortcut if possible... var copyRequired = !targetType.IsInstanceOfType(source); if (!copyRequired && len == 0) { return(source); } var targetKeyType = ConversionUtils.GetDictionaryKeyType(targetType); var targetValueType = ConversionUtils.GetDictionaryValueType(targetType); var sourceKeyType = ConversionUtils.GetDictionaryKeyType(sourceType); var sourceValueType = ConversionUtils.GetDictionaryValueType(sourceType); var dict = ConversionUtils.CreateCompatDictionaryFor(targetType); if (dict == null) { throw new InvalidOperationException("Unable to create compatable dictionary"); } if (!targetType.IsGenericType) { var enumerator = sourceDict.GetEnumerator(); while (enumerator.MoveNext()) { dict.Add(enumerator.Key, enumerator.Value); } } else { var enumerator = sourceDict.GetEnumerator(); while (enumerator.MoveNext()) { var targetKey = ConvertKey(enumerator.Key, sourceKeyType, targetKeyType); var targetValue = ConvertValue(enumerator.Value, sourceValueType, targetValueType); dict.Add(targetKey, targetValue); } } return(dict); }
public override bool Matches(Type sourceType, Type targetType) { // NO OP check Arrays already implement IList, etc. if (targetType.IsAssignableFrom(sourceType)) { return(false); } if (sourceType.IsArray && ConversionUtils.CanCreateCompatListFor(targetType)) { return(ConversionUtils.CanConvertElements( ConversionUtils.GetElementType(sourceType), ConversionUtils.GetElementType(targetType), _conversionService)); } return(false); }
public override object Convert(object source, Type sourceType, Type targetType) { var sourceCollection = source as IEnumerable; if (sourceCollection == null) { return(null); } var list = ConversionUtils.CreateCompatListFor(targetType); if (list == null) { throw new InvalidOperationException("Unable to create compatible list"); } if (!targetType.IsGenericType) { foreach (var elem in sourceCollection) { list.Add(elem); } } else { var targetElementType = ConversionUtils.GetElementType(targetType) ?? typeof(object); foreach (var sourceElement in sourceCollection) { if (sourceElement != null) { var targetElement = _conversionService.Convert(sourceElement, sourceElement.GetType(), targetElementType); list.Add(targetElement); } else { list.Add(sourceElement); } } } return(list); }
private static MethodInfo DetermineFactoryMethod(Type targetClass, Type sourceClass) { if (typeof(string) == targetClass) { // Do not accept the String.valueOf(Object) method return(null); } var method = ConversionUtils.GetStaticMethod(targetClass, "ValueOf", sourceClass); if (method == null) { method = ConversionUtils.GetStaticMethod(targetClass, "Of", sourceClass); if (method == null) { method = ConversionUtils.GetStaticMethod(targetClass, "From", sourceClass); } } return(method); }
public override object Convert(object source, Type sourceType, Type targetType) { if (source == null) { return(null); } var elementDesc = ConversionUtils.GetElementType(targetType); var target = ConversionUtils.CreateCompatListFor(targetType); if (elementDesc == null) { target.Add(source); } else { var singleElement = _conversionService.Convert(source, sourceType, elementDesc); target.Add(singleElement); } return(target); }
public override object Convert(object source, Type sourceType, Type targetType) { var asArray = source as Array; if (asArray == null) { return(null); } var len = asArray.GetLength(0); var arrayElementType = ConversionUtils.GetElementType(asArray.GetType()); var list = ConversionUtils.CreateCompatListFor(targetType); if (list == null) { throw new InvalidOperationException("Unable to create compatible list"); } if (!targetType.IsGenericType) { for (var i = 0; i < len; i++) { list.Add(asArray.GetValue(i)); } } else { var targetElementType = ConversionUtils.GetElementType(targetType); for (var i = 0; i < len; i++) { var sourceElement = asArray.GetValue(i); var targetElement = _conversionService.Convert(sourceElement, arrayElementType, targetElementType); list.Add(targetElement); } } return(list); }
private static ConstructorInfo DetermineFactoryConstructor(Type targetClass, Type sourceClass) { return(ConversionUtils.GetConstructorIfAvailable(targetClass, sourceClass)); }
public override bool Matches(Type sourceType, Type targetType) { var targetCheck = ConversionUtils.GetNullableElementType(targetType); return(sourceType == typeof(string) && targetCheck == typeof(char)); }
public override bool Matches(Type sourceType, Type targetType) { return(ConversionUtils.CanCreateCompatDictionaryFor(targetType) && CanConvertKey(sourceType, targetType) && CanConvertValue(sourceType, targetType)); }