object HandleValue(Type targetType, object value) { if (value is JArray || value is JObject) { value = _serializer.FromJson(targetType, value.ToString()); } else if (targetType.IsConcept()) { value = ConceptFactory.CreateConceptInstance(targetType, value); } else if (targetType == typeof(DateTimeOffset)) { if (value is DateTime time) { value = new DateTimeOffset(time); } } else if (targetType.IsEnum) { value = Enum.Parse(targetType, value.ToString()); } else if (targetType == typeof(Guid)) { value = Guid.Parse(value.ToString()); } else { if (!targetType.IsAssignableFrom(value.GetType())) { value = System.Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture); } } return(value); }
object HandleValue(ParameterInfo parameter, string input) { _logger.Trace($"Parameter : {parameter.Name} - {input}"); if (parameter.ParameterType == typeof(string)) { return(input); } input = Unescape(input); if (parameter.ParameterType.GetTypeInfo().IsValueType) { return(TypeDescriptor.GetConverter(parameter.ParameterType).ConvertFromInvariantString(input)); } if (parameter.ParameterType.IsConcept()) { var genericArgumentType = parameter.ParameterType.GetTypeInfo().BaseType.GetTypeInfo().GetGenericArguments()[0]; var value = input.ParseTo(genericArgumentType); return(ConceptFactory.CreateConceptInstance(parameter.ParameterType, value)); } input = _jsonInterceptor.Intercept(input); _logger.Trace($"Deserialize '{input}' into {parameter.ParameterType}"); var deserialized = _serializer.FromJson(parameter.ParameterType, input, SerializationOptions.CamelCase); return(deserialized); }
/// <inheritdoc/> public T Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bsonReader = context.Reader; var actualType = args.NominalType; object value = null; BsonType bsonType = bsonReader.GetCurrentBsonType(); var valueType = actualType.GetConceptValueType(); if (bsonType == BsonType.Document) // It should be a Concept object { bsonReader.ReadStartDocument(); var keyName = bsonReader.ReadName(Utf8NameDecoder.Instance); if (keyName == "Value" || keyName == "value") { value = GetDeserializedValue(valueType, ref bsonReader); bsonReader.ReadEndDocument(); } else { //Throw exception } } else { value = GetDeserializedValue(valueType, ref bsonReader); } dynamic concept = ConceptFactory.CreateConceptInstance(ValueType, value); return(concept); }
/// <inheritdoc/> public ICommand Convert(CommandRequest request) { // todo: Cache it per transaction / command context var type = _applicationResourceResolver.Resolve(request.Type); // todo: Verify that it is a an ICommand var instance = Activator.CreateInstance(type) as ICommand; var properties = type.GetTypeInfo().DeclaredProperties.ToDictionary(p => p.Name, p => p); // todo: Verify that the command shape matches 100% - do not allow anything else // todo: Convert to target type if mismatch request.Content.Keys.ForEach(propertyName => { if (properties.ContainsKey(propertyName)) { var property = properties[propertyName]; object value = request.Content[propertyName]; if (property.PropertyType.IsConcept()) { value = ConceptFactory.CreateConceptInstance(property.PropertyType, value); } else if (property.PropertyType == typeof(DateTimeOffset) && value.GetType() == typeof(DateTime)) { value = new DateTimeOffset((DateTime)value); } property.SetValue(instance, value); } }); return(instance); }
/// <inheritdoc/> public object FromJson(Type type, string json, ISerializationOptions options = null) { var serializer = CreateSerializerForDeserialization(options); using (var textReader = new StringReader(json)) { using (var reader = new JsonTextReader(textReader)) { object instance; if (type.IsConcept()) { var genericArgumentType = type.GetConceptValueType(); var value = serializer.Deserialize(reader, genericArgumentType); return(ConceptFactory.CreateConceptInstance(type, value)); } if (type.GetTypeInfo().IsValueType || type.HasInterface <IEnumerable>()) { instance = serializer.Deserialize(reader, type); } else { IEnumerable <string> propertiesMatched; instance = CreateInstanceOf(type, json, out propertiesMatched); DeserializeRemaindingProperties(type, serializer, reader, instance, propertiesMatched); } return(instance); } } }
public object FromJson(Type type, string json, SerializationOptions options = null) { var serializer = CreateSerializerForDeserialization(options); using (var textReader = new StringReader(json)) { using (var reader = new JsonTextReader(textReader)) { object instance; if (type.IsConcept()) { var genericArgumentType = type.BaseType.GetGenericArguments()[0]; var value = serializer.Deserialize(reader, genericArgumentType); return(ConceptFactory.CreateConceptInstance(type, value)); } if (type.IsValueType || type.HasInterface <IEnumerable>()) { instance = serializer.Deserialize(reader, type); } else { instance = CreateInstanceOf(type, json); serializer.Populate(reader, instance); } return(instance); } } }
/// <inheritdoc/> public T Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bsonReader = context.Reader; var actualType = args.NominalType; BsonType bsonType = bsonReader.GetCurrentBsonType(); var valueType = actualType.GetConceptValueType(); object value; // It should be a Concept object if (bsonType == BsonType.Document) { bsonReader.ReadStartDocument(); var keyName = bsonReader.ReadName(Utf8NameDecoder.Instance); if (keyName == "Value" || keyName == "value") { value = GetDeserializedValue(valueType, ref bsonReader); bsonReader.ReadEndDocument(); } else { throw new FailedConceptSerialization("Expected a concept object, but no key named 'Value' or 'value' was found on the object"); } } else { value = GetDeserializedValue(valueType, ref bsonReader); } return((dynamic)ConceptFactory.CreateConceptInstance(ValueType, value)); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { //var instance = Activator.CreateInstance(objectType); //var genericArgumentType = objectType.BaseType.GetGenericArguments()[0]; //var value = reader.Value; //if (genericArgumentType == typeof(Guid)) // value = Guid.Parse(reader.Value.ToString()); //objectType.GetProperty("Value").SetValue(instance, value, null); //return instance; return(ConceptFactory.CreateConceptInstance(objectType, reader.Value)); }
void PopulateProperties(QueryRequest descriptor, Type queryType, object instance) { foreach (var key in descriptor.Parameters.Keys) { var property = queryType .GetProperties() .SingleOrDefault(_ => _ .Name.Equals(key, StringComparison.InvariantCultureIgnoreCase)); if (property != null) { var propertyValue = descriptor.Parameters[key].ToString(); object value = null; if (property.PropertyType.IsConcept()) { var valueType = property.PropertyType.GetConceptValueType(); object underlyingValue = null; try { if (valueType == typeof(Guid)) { underlyingValue = Guid.Parse(propertyValue); } else { underlyingValue = Convert.ChangeType(propertyValue, valueType, CultureInfo.InvariantCulture); } value = ConceptFactory.CreateConceptInstance(property.PropertyType, underlyingValue); } catch { } } else { if (property.PropertyType == typeof(Guid)) { value = Guid.Parse(propertyValue); } else { value = Convert.ChangeType(propertyValue, property.PropertyType, CultureInfo.InvariantCulture); } } property.SetValue(instance, value, null); } } }
/// <inheritdoc/> public object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bsonReader = context.Reader; var actualType = args.NominalType; object value = null; var valueType = actualType.GetConceptValueType(); if (valueType == typeof(Guid)) { var binaryData = bsonReader.ReadBinaryData(); value = binaryData.ToGuid(); } else if (valueType == typeof(double)) { value = bsonReader.ReadDouble(); } else if (valueType == typeof(float)) { value = (float)bsonReader.ReadDouble(); } else if (valueType == typeof(Int32)) { value = bsonReader.ReadInt32(); } else if (valueType == typeof(Int64)) { value = bsonReader.ReadInt64(); } else if (valueType == typeof(bool)) { value = bsonReader.ReadBoolean(); } else if (valueType == typeof(string)) { value = bsonReader.ReadString(); } else if (valueType == typeof(decimal)) { value = decimal.Parse(bsonReader.ReadString()); } var concept = ConceptFactory.CreateConceptInstance(actualType, value); return(concept); }
KeyValuePair <object, object> BuildKeyValuePair(JProperty prop, Type keyType, Type valueType) { var key = ConceptFactory.CreateConceptInstance(keyType, prop.Name); var valueProp = prop.Value; object value = null; if (valueType.IsAPrimitiveType()) { value = valueProp.ToObject(valueType); } else if (valueType.IsConcept()) { value = ConceptFactory.CreateConceptInstance(valueType, valueProp.ToObject(valueType.GetConceptValueType())); } else { value = valueType == typeof(object) ? prop.First() : _serializer.FromJson(valueType, prop.Value.ToString()); } return(new KeyValuePair <object, object>(key, value)); }
/// <summary> /// Convert a string into the desired type /// </summary> /// <param name="input">the string to parse</param> /// <param name="type">the desired type</param> /// <returns>value as the desired type</returns> public static object ParseTo(this string input, Type type) { if (type == typeof(Guid)) { Guid result; if (Guid.TryParse(input, out result)) { return(result); } return(Guid.Empty); } if (type.IsConcept()) { var primitiveType = type.GetConceptValueType(); var primitive = ParseTo(input, primitiveType); return(ConceptFactory.CreateConceptInstance(type, primitive)); } return(Convert.ChangeType(input, type, null)); }
object HandleValue(ParameterInfo parameter, string input) { if (parameter.ParameterType == typeof(string)) { return(input); } input = Unescape(input); if (parameter.ParameterType.IsValueType) { return(TypeDescriptor.GetConverter(parameter.ParameterType).ConvertFromInvariantString(input)); } if (parameter.ParameterType.IsConcept()) { var genericArgumentType = parameter.ParameterType.BaseType.GetGenericArguments()[0]; var value = input.ParseTo(genericArgumentType); return(ConceptFactory.CreateConceptInstance(parameter.ParameterType, value)); } input = _jsonInterceptor.Intercept(input); return(_serializer.FromJson(parameter.ParameterType, input)); }
static dynamic ConstructInstanceOfType(PropertyBag pb, Type targetType, string pbKey, IObjectFactory factory) { if (!pb.ContainsKey(pbKey)) { return(null); } var value = pb[pbKey]; if (value == null) { return(null); } if (targetType.IsDate()) { return(BuildDate(value)); } if (targetType.IsDateTimeOffset()) { return(BuildDateTimeOffset(value)); } if (targetType.IsAPrimitiveType() || targetType == typeof(PropertyBag)) { return(targetType == typeof(PropertyBag)? (PropertyBag)value : value); } if (targetType.IsConcept()) { return(ConceptFactory.CreateConceptInstance(targetType, value)); } if (targetType.IsEnumerable()) { return(targetType.ConstructEnumerable(factory, value)); } return(factory.Build(targetType, value as PropertyBag)); }
/// <summary> /// Convert a <see cref="System.Protobuf.guid"/> to <see cref="ConceptAs{T}">Guid concept</see> /// </summary> /// <param name="guid"><see cref="System.Protobuf.guid"/> to convert from</param> /// <typeparam name="T">Type of <see cref="ConceptAs{T}"/> to convert to</typeparam> /// <returns>Converted instance - matching the type given</returns> public static T ToConcept <T>(this System.Protobuf.guid guid) where T : ConceptAs <Guid> { return(ConceptFactory.CreateConceptInstance(typeof(T), new Guid(guid.Value.ToByteArray())) as T); }
/// <inheritdoc/> public object ConvertFrom(Type objectType, object value) { return(ConceptFactory.CreateConceptInstance(objectType, value)); }
/// <inheritdoc/> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { return(ConceptFactory.CreateConceptInstance(objectType, reader.Value)); }
/// <summary> /// Get a value from a <see cref="DynamicTableEntity"/> by giving a property info representing the property to get value for /// </summary> /// <param name="entity"><see cref="DynamicTableEntity">Entity</see> to get from</param> /// <param name="propertyInfo"><see cref="PropertyInfo"/> for the property</param> /// <returns>Value of the property from the <see cref="DynamicTableEntity">entity</see></returns> public static object GetValue(DynamicTableEntity entity, PropertyInfo propertyInfo) { var valueType = propertyInfo.PropertyType; var entityProperty = entity.Properties[propertyInfo.Name]; var concept = valueType.IsConcept(); object value = null; if (concept) { valueType = valueType.GetConceptValueType(); } if (valueType == typeof(EventSourceVersion)) { value = EventSourceVersion.FromCombined(entityProperty.DoubleValue.Value); } if (valueType == typeof(Guid)) { value = entityProperty.GuidValue.Value; } if (valueType == typeof(int)) { value = entityProperty.Int32Value.Value; } if (valueType == typeof(long)) { value = entityProperty.Int64Value.Value; } if (valueType == typeof(string)) { value = entityProperty.StringValue; } if (valueType == typeof(DateTime)) { value = entityProperty.DateTime.Value; } if (valueType == typeof(DateTimeOffset)) { value = entityProperty.DateTimeOffsetValue.Value; } if (valueType == typeof(bool)) { value = entityProperty.BooleanValue.Value; } if (valueType == typeof(double)) { value = entityProperty.DoubleValue.Value; } if (valueType == typeof(float)) { value = (float)entityProperty.DoubleValue.Value; } if (concept) { return(ConceptFactory.CreateConceptInstance(propertyInfo.PropertyType, value)); } return(value); }