// Convert IEnumerable to array public bool TryConvert(ConverterContext context, out object?target) { target = null; // Ensure requested type is an array if (context.Parameter.Type.IsArray) { Type?elementType = context.Parameter.Type.GetElementType(); if (elementType is not null) { // Ensure that we can assign from source to parameter type if (elementType.Equals(typeof(string)) || elementType.Equals(typeof(byte[])) || elementType.Equals(typeof(ReadOnlyMemory <byte>)) || elementType.Equals(typeof(long)) || elementType.Equals(typeof(double))) { target = context.Source switch { IEnumerable <string> source => source.ToArray(), IEnumerable <ReadOnlyMemory <byte> > source => GetBinaryData(source, elementType !), IEnumerable <double> source => source.ToArray(), IEnumerable <long> source => source.ToArray(), _ => null }; } } } return(target is not null); }
public bool TryConvert(ConverterContext context, out object?target) { target = default; if (context.Parameter.Type == typeof(string)) { return(false); } byte[]? bytes = null; if (context.Source is string sourceString) { bytes = Encoding.UTF8.GetBytes(sourceString); } else if (context.Source is ReadOnlyMemory <byte> sourceMemory) { bytes = sourceMemory.ToArray(); } if (bytes == null) { return(false); } return(TryDeserialize(bytes, context.Parameter.Type, out target)); }
public async ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { if (context.TargetType == typeof(string)) { return(ConversionResult.Unhandled()); } byte[]? bytes = null; if (context.Source is string sourceString) { bytes = Encoding.UTF8.GetBytes(sourceString); } else if (context.Source is ReadOnlyMemory <byte> sourceMemory) { bytes = sourceMemory.ToArray(); } if (bytes == null) { return(ConversionResult.Unhandled()); } return(await GetConversionResultFromDeserialization(bytes, context.TargetType)); }
public ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { // Special handling for the context. if (context.TargetType == typeof(FunctionContext)) { return(new ValueTask <ConversionResult>(ConversionResult.Success(context.FunctionContext))); } return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); }
public ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { if (context.TargetType == typeof(Guid) || context.TargetType == typeof(Guid?)) { if (context.Source is string sourceString && Guid.TryParse(sourceString, out Guid parsedGuid)) { return(new ValueTask <ConversionResult>(ConversionResult.Success(parsedGuid))); } } return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); }
public ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { Type?sourceType = context.Source?.GetType(); if (sourceType is not null && context.TargetType.IsAssignableFrom(sourceType)) { var conversionResult = ConversionResult.Success(context.Source); return(new ValueTask <ConversionResult>(conversionResult)); } return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); }
public bool TryConvert(ConverterContext context, out object?target) { target = default; if (!(context.Parameter.Type.IsAssignableFrom(typeof(byte[])) && context.Source is string sourceString)) { return(false); } target = Encoding.UTF8.GetBytes(sourceString); return(true); }
public ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { if (!(context.TargetType.IsAssignableFrom(typeof(byte[])) && context.Source is string sourceString)) { return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); } var byteArray = Encoding.UTF8.GetBytes(sourceString); var conversionResult = ConversionResult.Success(byteArray); return(new ValueTask <ConversionResult>(conversionResult)); }
public bool TryConvert(ConverterContext context, out object?target) { Type?sourceType = context.Source?.GetType(); if (sourceType is not null && context.Parameter.Type.IsAssignableFrom(sourceType)) { target = context.Source; return(true); } target = default; return(false); }
internal bool TryConvert(ConverterContext context, out object?target) { target = null; // The first converter to successfully convert wins. // For example, this allows a converter that parses JSON strings to return false if the // string is not valid JSON. This manager will then continue with the next matching provider. foreach (var converter in _converters) { if (converter.TryConvert(context, out object?targetObj)) { target = targetObj; return(true); } } return(false); }
public bool TryConvert(ConverterContext context, out object?target) { FunctionParameter param = context.Parameter; target = null; if (param.Type.IsGenericType) { var genericType = param.Type.GetGenericTypeDefinition(); if (genericType == typeof(OutputBinding <>)) { var elementType = param.Type.GetGenericArguments()[0]; Type constructed = defaultBindingType.MakeGenericType(new Type[] { elementType }); target = Activator.CreateInstance(constructed, context.Parameter, context.ExecutionContext.OutputBindings); return(true); } } return(false); }
public ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { if (context.Source is not ReadOnlyMemory <byte> sourceMemory) { return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); } if (context.TargetType.IsAssignableFrom(typeof(string))) { var target = Encoding.UTF8.GetString(sourceMemory.Span); return(new ValueTask <ConversionResult>(ConversionResult.Success(target))); } if (context.TargetType.IsAssignableFrom(typeof(byte[]))) { var target = sourceMemory.ToArray(); return(new ValueTask <ConversionResult>(ConversionResult.Success(target))); } return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); }
public bool TryConvert(ConverterContext context, out object?target) { target = default; if (context.Parameter.Type == typeof(string) || context.Source is not string sourceString || string.IsNullOrEmpty(sourceString)) { return(false); } try { target = JsonSerializer.Deserialize(sourceString, context.Parameter.Type, _options.Value); return(true); } catch (JsonException) { } return(false); }
public bool TryConvert(ConverterContext context, out object?target) { target = default; if (context.Source is not ReadOnlyMemory <byte> sourceMemory) { return(false); } if (context.Parameter.Type.IsAssignableFrom(typeof(string))) { target = Encoding.UTF8.GetString(sourceMemory.Span); return(true); } if (context.Parameter.Type.IsAssignableFrom(typeof(byte[]))) { target = sourceMemory.ToArray(); return(true); } return(false); }
// Convert IEnumerable to array public ValueTask <ConversionResult> ConvertAsync(ConverterContext context) { object?target = null; // Ensure requested type is an array if (context.TargetType.IsArray) { Type?elementType = context.TargetType.GetElementType(); if (elementType is not null) { // Ensure that we can assign from source to parameter type if (elementType.Equals(typeof(string)) || elementType.Equals(typeof(byte[])) || elementType.Equals(typeof(ReadOnlyMemory <byte>)) || elementType.Equals(typeof(long)) || elementType.Equals(typeof(double))) { target = context.Source switch { IEnumerable <string> source => source.ToArray(), IEnumerable <ReadOnlyMemory <byte> > source => GetBinaryData(source, elementType !), IEnumerable <double> source => source.ToArray(), IEnumerable <long> source => source.ToArray(), _ => null }; } } } if (target is not null) { return(new ValueTask <ConversionResult>(ConversionResult.Success(target))); } return(new ValueTask <ConversionResult>(ConversionResult.Unhandled())); }