private static string GetPropertyValue <T>(T config, IReadOnlyList <string> propertyAccessors) { IReflectionType reflectionType = Reflector.Get(typeof(T)); var jsonSerializer = Container.Get <IJsonSerializer>(); object propertyValue = reflectionType.GetPropertyValue(propertyAccessors[0], config); reflectionType = Reflector.Get(reflectionType.GetProperty(propertyAccessors[0]).Type); for (int i = 1; i < propertyAccessors.Count; i++) { propertyValue = reflectionType.GetPropertyValue(propertyAccessors[i], propertyValue); reflectionType = Reflector.Get(reflectionType.GetProperty(propertyAccessors[i]).Type); if (i == (propertyAccessors.Count - 2)) { i++; propertyValue = reflectionType.GetPropertyValue(propertyAccessors[i], propertyValue); } } if (propertyValue != null) { string serializedValue = jsonSerializer.Serialize(propertyValue); return(serializedValue); } return(null); }
private static XElement BuildElement(IReflectionType reflectionType, string elementName = null) { XmlElementAttribute attribute = (XmlElementAttribute)reflectionType.Attributes.SingleOrDefault(x => x is XmlElementAttribute); XNamespace defaultNamspace = null; List <XAttribute> namespaceList = new List <XAttribute>(); var nodeName = reflectionType.Name; if (attribute != null) { defaultNamspace = attribute.DefaultNamespace; namespaceList.AddRange(attribute.NamespaceList.Select(x => new XAttribute(XNamespace.Xmlns + x.Key, x.Value)).ToList()); if (!string.IsNullOrWhiteSpace(attribute.Name)) { nodeName = attribute.Name; } } if (!string.IsNullOrWhiteSpace(elementName)) { nodeName = elementName; } XElement xElement = defaultNamspace != null ? new XElement(defaultNamspace + nodeName, namespaceList) : new XElement(nodeName, namespaceList); return(xElement); }
///------------------------------------------------------------------------------------------------- /// <summary> /// Deserializes. /// </summary> /// /// <exception cref="NotImplementedException"> /// Thrown when the requested operation is unimplemented. /// </exception> /// /// <param name="type"> /// The type. /// </param> /// <param name="value"> /// The value. /// </param> /// /// <returns> /// . /// </returns> ///------------------------------------------------------------------------------------------------- public object Deserialize(Type type, string value) { if (type == null) { throw new ArgumentNullException("type"); } IReflectionType reflectionType = Reflector.Get(type); object instance = reflectionType.CreateInstance(); if (!string.IsNullOrWhiteSpace(value)) { XDocument document = XDocument.Parse(value, LoadOptions.SetLineInfo); var root = document.Root; if (root != null) { this.SetRootValue(reflectionType, instance, root); } } return(instance); }
public static Type GetReflectionType(ITypeId typeId) { IReflectionType reflectionType = typeId as IReflectionType; if (reflectionType != null) { return(reflectionType.ReflectionType); } return((Type)null); }
private void SetRootValue(IReflectionType reflectionType, object instance, XElement root) { var properties = reflectionType.Properties.OrderBy( p => { OrderAttribute priority = p.Attributes.SingleOrDefault(x => x is OrderAttribute) as OrderAttribute; return(priority != null ? priority.Value : int.MaxValue); }).ToList(); SetPropertiesValue(properties, instance, root); }
private static Dictionary <string, IReflectionProperty> Build(Type type, string name = null) { Dictionary <string, IReflectionProperty> dictionary = new Dictionary <string, IReflectionProperty>(); IReflectionType reflectionType = Reflector.Get(type); foreach (var property in reflectionType.Properties) { ParseProperty(dictionary, property, name); } return(dictionary); }
public TemplateContext( TextWriter writer, object instance, bool disposeWriter = true, Func <string, string> templateLocator = null) { this.writer = writer; this.disposeWriter = disposeWriter; this.templateLocator = templateLocator; if (instance != null) { this.instance = instance; this.reflectionType = Reflector.Get(instance); } }
private static XElement BuildPropertyRoot(object instance, IReflectionProperty rootProperty) { IReflectionType reflectionType = Reflector.Get(instance.GetType()); XElement root = BuildElement(rootProperty); var properties = reflectionType.Properties.OrderBy( p => { OrderAttribute priority = p.Attributes.SingleOrDefault(x => x is OrderAttribute) as OrderAttribute; return(priority != null ? priority.Value : int.MaxValue); }).ToList(); foreach (var property in properties) { AddProperty(instance, root, property); } return(root); }
protected virtual async Task <RestResponse <T> > ExecuteAsync <T>(RestRequest request, MethodType method) where T : new() { request.Method = method; RestResponse <T> response = new RestResponse <T>(await GetResponseAsync(request)); try { if (!string.IsNullOrWhiteSpace(response.Content)) { switch (response.ResponseMode) { case ResponseMode.Json: IJsonSerializer jsonSerializer = Container.Get <IJsonSerializer>(); response.ContentObject = jsonSerializer.Deserialize <T>(response.Content); break; case ResponseMode.Xml: IXmlSerializer xmlSerializer = Container.Get <IXmlSerializer>(); response.ContentObject = xmlSerializer.Deserialize <T>(response.Content); break; } if (typeof(ISerializable).IsAssignableFrom(typeof(T))) { if (response.ContentObject == null) { IReflectionType reflectionType = Reflector.Get <T>(); response.ContentObject = (T)reflectionType.CreateInstance(); ((ISerializable)response.ContentObject).Deserialize(response.Content); } } } } catch (Exception exception) { response.Status = ResponseStatus.Error; response.ErrorMessage = exception.Message; response.ErrorException = new RestException(exception.Message, response.StatusCode, response.ErrorException); } return(response); }
private void CheckBaseTypeInvariants() { string name = this.Name; if (!this.IsInterface) { if (this.baseType == null && this.type != null) { Type baseType = this.type.BaseType; } IType type = this.baseType; } if (this.type != null && this.baseType != null) { IReflectionType reflectionType = this.baseType as IReflectionType; if (reflectionType == null) { return; } Type reflectionType1 = reflectionType.ReflectionType; } }
private static void ParseProperty(Dictionary <string, IReflectionProperty> dictionary, IReflectionProperty property, string parentName = "") { string propertyName = property.Name; if (!string.IsNullOrWhiteSpace(parentName)) { propertyName = parentName + "." + propertyName; } if (property.IsClass) { IReflectionType reflectionType = Reflector.Get(property.Type); foreach (var reflectionProperty in reflectionType.Properties) { ParseProperty(dictionary, reflectionProperty, propertyName); } } else { dictionary.Add(propertyName, property); } }
private static void SetPropertyValue <T>(T config, IReadOnlyList <string> propertyAccessors, string value) { if (!string.IsNullOrWhiteSpace(value)) { IReflectionType reflectionType = Reflector.Get(typeof(T)); var jsonSerializer = Container.Get <IJsonSerializer>(); object propertyValue = reflectionType.GetPropertyValue(propertyAccessors[0], config); IReflectionProperty reflectionProperty = reflectionType.GetProperty(propertyAccessors[0]); if (reflectionProperty != null) { if (reflectionProperty.IsPrimitive) { object deserializeValue = jsonSerializer.Deserialize(reflectionProperty.Type, value); reflectionProperty.Set(config, deserializeValue); } else { reflectionType = Reflector.Get(reflectionProperty.Type); for (int i = 1; i < propertyAccessors.Count - 1; i++) { propertyValue = reflectionType.GetPropertyValue(propertyAccessors[i], propertyValue); reflectionType = Reflector.Get(reflectionType.GetProperty(propertyAccessors[i]).Type); } IReflectionProperty property = reflectionType.GetProperty(propertyAccessors[propertyAccessors.Count - 1]); object deserializeValue = jsonSerializer.Deserialize(property.Type, value); property.Set(propertyValue, deserializeValue); } } } }