/// <summary> /// Deserializes the member. /// </summary> /// <param name="context">The context.</param> /// <param name="memberValue">The member value.</param> /// <returns>The <see cref="SerializationObject"/> representing the deserialized value or result.</returns> protected override SerializationObject DeserializeMember(ISerializationContext <BinarySerializationContextInfo> context, MemberValue memberValue) { var serializationContext = context.Context; var memberValues = serializationContext.MemberValues; var finalMemberValue = (from x in memberValues where string.Equals(x.Name, memberValue.Name, StringComparison.Ordinal) select x).FirstOrDefault(); if (finalMemberValue != null) { if (finalMemberValue.Value is string && ShouldSerializeUsingParseAndToString(memberValue, false)) { var tempValue = memberValue.Value; memberValue.Value = finalMemberValue.Value; var parsedValue = DeserializeUsingObjectParse(context, memberValue); if (parsedValue != null) { finalMemberValue.Value = parsedValue; } else { memberValue.Value = tempValue; } } return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, finalMemberValue.Value)); } return(SerializationObject.FailedToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name)); }
/// <summary> /// Carga el archivo del progreso del juego y actualiza los valores del manager de progreso /// </summary> public void LoadFile() { if (!File.Exists(destination)) { return; } string readedJson = File.ReadAllText(destination); SerializationObjectChiper chiperObj = ProgressManager.Instance.GetChiperfromJson(readedJson); SerializationObject ReadedObj = chiperObj.obj; string testObjJson = ProgressManager.Instance.GetJson(ReadedObj); byte[] fileBytes = Encoding.UTF8.GetBytes(testObjJson); ActualGameID = GameManager.Instance.gameID; FileBytes = Encoding.UTF8.GetBytes(ActualGameID); string testResult = ConvertObject(fileBytes); if (testResult == chiperObj._result) { ProgressManager.Instance.UpdateValues(ReadedObj); } else { ProgressManager.Instance.ResetProgress(); } }
public VFile[] Load() { try { var apiResult = (JObject)Vkapi.Instance.StartTaskSync(new ApiQuery( "photos.getAlbums", new Dictionary <string, string>() { { "owner_id", _ownerId.ToString() } })); var items = (JArray)apiResult.GetValue("items"); var result = new List <VFile>(); foreach (var jToken in items) { var album = jToken.ToObject <SerializationObject.Album>(); var curFolder = new Folder(album.Title, new Get(_ownerId, album.Id)); var unixTimeStamp = new DateTime(1970, 1, 1, 0, 0, 0, 0); curFolder.CreationTime = unixTimeStamp.AddSeconds(album.Created); curFolder.LastWriteTime = unixTimeStamp.AddSeconds(album.Updated); result.Add(curFolder); } return(result.ToArray()); } catch (Exception exception) { return(new VFile[] { SerializationObject.ExceptionToFile(exception) }); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// /// /// MÉTODOS PÚBLICOS /// /// /// /////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Genera y guarda el archivo de progreso /// </summary> /// <param name="obj">Objeto que se utiliza para obtener los valores de los datos a guardar</param> public void SaveFile(SerializationObject obj) { FileStream file; if (File.Exists(destination)) { file = File.OpenWrite(destination); } else { file = File.Create(destination); } file.Dispose(); File.WriteAllText(destination, String.Empty); SerializationObjectChiper chiperObject = new SerializationObjectChiper(); string jsonToChiper = ProgressManager.Instance.GetJson(obj); byte[] fileBytesToChiper = Encoding.UTF8.GetBytes(jsonToChiper); ActualGameID = GameManager.Instance.gameID; FileBytes = Encoding.UTF8.GetBytes(ActualGameID); string hashResult = ConvertObject(fileBytesToChiper); chiperObject.obj = obj; chiperObject._result = hashResult; File.AppendAllText(destination, ProgressManager.Instance.GetJson(chiperObject)); file.Close(); }
public VFile[] Load() { var result = new HashSet <VFile>(); try { var apiResult = (JObject)Vkapi.Instance.StartTaskSync(new ApiQuery( "audio.search", new Dictionary <string, string> { { "q", _query }, { "count", _count.ToString() } } )); foreach (var jToken in apiResult.GetValue("items")) { result.Add(new Mp3( jToken.ToObject <SerializationObject.Audio>() )); } return(result.ToArray()); } catch (Exception e) { return(new VFile[] { SerializationObject.ExceptionToFile(e) }); } }
public void ReturnsPropertyValueForSucceededDeserialization() { var serializationObject = SerializationObject.SucceededToDeserialize(typeof(SerializationObject), SerializationMemberGroup.CatelProperty, "property", 42); object propertyValue = serializationObject.MemberValue; Assert.AreEqual(42, propertyValue); }
/// <summary> /// Crea un objeto de serializacion con los valores actuales y guarda el progreso /// </summary> public void SaveProgress() { SerializationObject sObj = new SerializationObject(levelsCompleted, _virtualCoin, _adsBought, _serializationVersion, _completedChallenges, _timeWhenChallengeDone, _timeWhenDailyRewardOpened); persistenceController.SaveFile(sObj); }
public void ThrowsInvalidOperationExceptionForFailedDeserialization() { var serializationObject = SerializationObject.FailedToDeserialize(typeof(SerializationObject), SerializationMemberGroup.CatelProperty, "property"); object propertyValue = null; ExceptionTester.CallMethodAndExpectException <InvalidOperationException>(() => propertyValue = serializationObject.MemberValue); Assert.IsNull(propertyValue); }
/// <summary> /// Actualiza los valores actuales a los que se obtienen por parámetro /// </summary> /// <param name="obj">Contenedor de los valores más actuales</param> public void UpdateValues(SerializationObject obj) { levelsCompleted = obj._levelsCompleted; _virtualCoin = obj._virtualCoin; _adsBought = obj._adsBought; _timeWhenChallengeDone = obj.GetChallengeDate(); _serializationVersion = obj._serializationVersion; _timeWhenDailyRewardOpened = obj.GetDailyRewardDate(); _completedChallenges = obj._completedChallenges; }
/// <summary> /// Deserializes the member. /// </summary> /// <param name="context">The context.</param> /// <param name="memberValue">The member value.</param> /// <returns>The <see cref="SerializationObject"/> representing the deserialized value or result.</returns> protected override SerializationObject DeserializeMember(ISerializationContext <XmlSerializationContextInfo> context, MemberValue memberValue) { var modelType = context.ModelType; var element = context.Context.Element; try { var propertyDataManager = PropertyDataManager.Default; if (propertyDataManager.IsPropertyNameMappedToXmlAttribute(modelType, memberValue.Name)) { var mappedPropertyName = propertyDataManager.MapPropertyNameToXmlAttributeName(modelType, memberValue.Name); //Log.Debug("Deserializing property {0}.{1} as xml attribute '{2}'", modelType.FullName, memberValue.Name, mappedPropertyName); foreach (var childAttribute in element.Attributes()) { if (string.Equals(mappedPropertyName, childAttribute.Name.LocalName)) { var value = GetObjectFromXmlAttribute(childAttribute, memberValue); return(SerializationObject.SucceededToDeserialize(modelType, memberValue.MemberGroup, memberValue.Name, value)); } } } else { string elementName = memberValue.Name; if (propertyDataManager.IsPropertyNameMappedToXmlElement(modelType, memberValue.Name)) { elementName = propertyDataManager.MapPropertyNameToXmlElementName(modelType, memberValue.Name); } //Log.Debug("Deserializing property {0}.{1} as xml element '{2}'", modelType.FullName, memberValue.Name, elementName); foreach (var childElement in element.Elements()) { if (string.Equals(elementName, childElement.Name.LocalName)) { var value = GetObjectFromXmlElement(context, childElement, memberValue, modelType); return(SerializationObject.SucceededToDeserialize(modelType, memberValue.MemberGroup, memberValue.Name, value)); } } } } catch (Exception ex) { Log.Debug(ex, "Failed to deserialize '{0}.{1}'", memberValue.ModelType.GetSafeFullName(), memberValue.Name); } return(SerializationObject.FailedToDeserialize(modelType, memberValue.MemberGroup, memberValue.Name)); }
/// <summary> /// Retrieves the serialization object hierarchy from the controls /// </summary> /// <returns></returns> private static SerializationObject GetSerializationObject(Controls.ISerializableControl serializableControl) { SerializationObject serializableObject = serializableControl.SerializationObject; serializableObject.Controls.Clear(); Controls.IFrameControl parentFrame = serializableControl as Controls.IFrameControl; if (parentFrame != null) { if (parentFrame.Frames.Count <Controls.IFrameControl>() > 0) { FrameTypeFrames frames = new FrameTypeFrames(); serializableObject.Controls.Add(frames); foreach (var childFrame in parentFrame.Frames) { SerializationObject childObject = GetSerializationObject(childFrame); frames.Controls.Add(childObject); } } Serialization.FrameType frameType = serializableObject as Serialization.FrameType; if (frameType != null) { Dictionary <DRAWLAYER, FrameTypeLayersLayer> layerDictionary = new Dictionary <DRAWLAYER, FrameTypeLayersLayer>(); foreach (Controls.ILayerable layerable in parentFrame.Layerables) { if (!layerDictionary.ContainsKey(layerable.LayerLevel)) { layerDictionary.Add(layerable.LayerLevel, new FrameTypeLayersLayer()); } FrameTypeLayersLayer layer = layerDictionary[layerable.LayerLevel]; layer.level = layerable.LayerLevel; layer.Layerables.Add(layerable.SerializationObject); } frameType.LayersList.Clear(); if (layerDictionary.Count > 0) { FrameTypeLayers layers = new FrameTypeLayers(); layers.Layer.AddRange(layerDictionary.Values); frameType.LayersList.Add(layers); } } } return(serializableObject); }
/// <summary> /// Deserializes the member. /// </summary> /// <param name="context">The context.</param> /// <param name="memberValue">The member value.</param> /// <returns>The <see cref="SerializationObject"/> representing the deserialized value or result.</returns> protected override SerializationObject DeserializeMember(ISerializationContext <BinarySerializationContextInfo> context, MemberValue memberValue) { var serializationContext = context.Context; var memberValues = serializationContext.MemberValues; var finalMembervalue = (from x in memberValues where string.Equals(x.Name, memberValue.Name, StringComparison.Ordinal) select x).FirstOrDefault(); if (finalMembervalue != null) { return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, finalMembervalue.Value)); } return(SerializationObject.FailedToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name)); }
/// <summary> /// Creates a control corresponding to the serialization object passed. /// </summary> /// <param name="serializationObject">The serialization object.</param> /// <param name="parent">parent control</param> /// <param name="inherited">true if the control is inherited (should be locked)</param> /// <returns></returns> private ISerializableControl CreateControl(SerializationObject serializationObject, Control parent, bool inherited) { Type controlType = GetControlType(serializationObject); if (controlType == null) { return(null); } IComponent component = LoaderHost.CreateComponent(controlType); ISerializableControl iControl = (ISerializableControl)component; iControl.DesignerLoader = this; iControl.SerializationObject = serializationObject; LayoutFrameType layoutFrameType = serializationObject as LayoutFrameType; if (layoutFrameType != null) { if (!inherited) { component.Site.Name = layoutFrameType.ExpandedName; } BaseControl control = iControl as BaseControl; if (control != null) { control.Inherited = inherited; Size size = layoutFrameType.SizeInPixels; if (!size.IsEmpty) { control.Size = size; } else { control.SetDefaultSize(); } if (parent != null) { control.Parent = parent; } } } return(iControl); }
/// <summary> /// Returns the type of the control corresponding to the serialization object passed /// </summary> /// <param name="serializationObject">The serialization object.</param> /// <returns></returns> private static Type GetControlType(SerializationObject serializationObject) { //LayoutFrameType layoutFrame = serializationObject as LayoutFrameType; //if (layoutFrame != null && layoutFrame.@virtual) // return typeof(VirtualComponent); // converts serialization object type name to control type name string typeName = serializationObject.GetType().Name; if (typeName.EndsWith("Type")) { typeName = typeName.Substring(0, typeName.Length - 4); } typeName = typeof(ISerializableControl).Namespace + '.' + typeName; return(Type.GetType(typeName)); }
private void CreateLayers(SerializationObject serializationObject, Control parent, bool inherited) { FrameType frameType = serializationObject as FrameType; if (frameType != null) { foreach (FrameTypeLayers layers in frameType.LayersList) { foreach (FrameTypeLayersLayer layer in layers.Layer) { foreach (SerializationObject so in layer.Layerables) { ILayerable layerable = CreateControl(so, parent, inherited) as ILayerable; layerable.LayerLevel = layer.level; } } } } }
private static Attribute[] GetAttributes(SerializationObject serializationObject, string name) { LayoutFrameType layoutFrame = serializationObject as LayoutFrameType; var attibutes = new List <Attribute>(); if (layoutFrame != null && layoutFrame.Properties.HasInheritedValue(name)) { // set DefaultValue attribute if there is an inherited value object defaultValue = layoutFrame.InheritedObject.Properties[name]; attibutes.Add(new DefaultValueAttribute(defaultValue)); // add Inherited attribute if it doesn't have a private value if (!layoutFrame.Properties.HasValue(name)) { attibutes.Add(new InheritedAttribute()); } } return(attibutes.ToArray()); }
/// <summary> /// Main iterator logic /// </summary> /// <param name="serializationObject">The serialization object.</param> /// <returns></returns> private IEnumerable <LayoutFrameType> GetInternalElements(SerializationObject serializationObject) { if (serializationObject != null) { // return current element if (serializationObject is LayoutFrameType) { yield return(serializationObject as LayoutFrameType); } // return child layers FrameType frame = serializationObject as FrameType; if (frame != null) { foreach (var layers in frame.LayersList) { foreach (var layer in layers.Layer) { foreach (var layerable in layer.Layerables.OfType <LayoutFrameType>()) { yield return(layerable); } } } } // return child controls foreach (var childObject in serializationObject.Controls) { var childElements = GetInternalElements(childObject); foreach (var element in childElements) { yield return(element); } } } }
/// <summary> /// Creates the controls from the hierarchy of Serialization object. /// </summary> /// <param name="serializationObject">The serialization object.</param> /// <param name="parent">The parent.</param> /// <remarks>Recursive</remarks> private Control CreateControls(SerializationObject serializationObject, Control parent, bool inherited) { Control control = this.CreateControl(serializationObject, parent, inherited) as Control; // bypass controls that cannot be created by the control factory (and the virtual ones) if (control == null) { Debug.WriteLine(String.Format("Bypassing object '{0}' during control creation.", serializationObject)); } else { parent = control; } CreateLayers(serializationObject, parent, false); foreach (SerializationObject childItem in serializationObject.Controls) { CreateControls(childItem, parent, inherited); } LayoutFrameType layoutFrame = serializationObject as LayoutFrameType; if (layoutFrame != null) { LayoutFrameType inheritedLayoutFrame = layoutFrame.InheritedObject; if (inheritedLayoutFrame != null) { CreateLayers(inheritedLayoutFrame, parent, true); foreach (SerializationObject childItem in inheritedLayoutFrame.Controls) { CreateControls(childItem, parent, true); } } } return(control); }
/// <summary> /// Deserializes the member. /// </summary> /// <param name="context">The context.</param> /// <param name="memberValue">The member value.</param> /// <returns>The <see cref="SerializationObject"/> representing the deserialized value or result.</returns> protected override SerializationObject DeserializeMember(ISerializationContext <JsonSerializationContextInfo> context, MemberValue memberValue) { var serializationContext = context.Context; var jsonProperties = serializationContext.JsonProperties; if (jsonProperties != null) { if (PreserveReferences) { var graphRefIdPropertyName = string.Format("${0}_{1}", memberValue.NameForSerialization, GraphRefId); if (jsonProperties.ContainsKey(graphRefIdPropertyName)) { var graphId = (int)jsonProperties[graphRefIdPropertyName].Value; var referenceManager = context.ReferenceManager; var referenceInfo = referenceManager.GetInfoById(graphId); if (referenceInfo == null) { Log.Error("Expected to find graph object with id '{0}' in ReferenceManager, but it was not found. Defaulting value for member '{1}' to null", graphId, memberValue.Name); return(null); } return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, referenceInfo.Instance)); } } if (memberValue.MemberGroup == SerializationMemberGroup.Dictionary) { var dictionary = CreateModelInstance(memberValue.MemberType) as IDictionary; var keyType = typeof(object); var valueType = typeof(object); if (memberValue.MemberType.IsGenericTypeEx()) { var genericArguments = memberValue.MemberType.GetGenericArgumentsEx(); if (genericArguments.Length == 2) { keyType = genericArguments[0]; valueType = genericArguments[1]; } } foreach (var jsonPropertyKeyValuePair in jsonProperties) { var jsonProperty = jsonPropertyKeyValuePair.Value; object deserializedItem = null; object key = jsonProperty.Name; if (keyType != typeof(object)) { key = StringToObjectHelper.ToRightType(keyType, jsonProperty.Name); } var typeToDeserialize = valueType; if (jsonProperty.Value != null) { if (jsonProperty.Value.Type != JTokenType.Object) { switch (jsonProperty.Value.Type) { case JTokenType.Integer: typeToDeserialize = typeof(int); break; case JTokenType.Float: typeToDeserialize = typeof(float); break; case JTokenType.String: typeToDeserialize = typeof(string); break; case JTokenType.Boolean: typeToDeserialize = typeof(bool); break; case JTokenType.Date: typeToDeserialize = typeof(DateTime); break; case JTokenType.Guid: typeToDeserialize = typeof(Guid); break; case JTokenType.Uri: typeToDeserialize = typeof(Uri); break; case JTokenType.TimeSpan: typeToDeserialize = typeof(TimeSpan); break; } } } var shouldValueTypeBeHandledByExternalSerializer = ShouldExternalSerializerHandleMember(typeToDeserialize); if (shouldValueTypeBeHandledByExternalSerializer) { deserializedItem = jsonProperty.Value.ToObject(valueType, serializationContext.JsonSerializer); } else { var reader = jsonProperty.Value.CreateReader(context.Configuration); reader.Culture = context.Configuration.Culture; deserializedItem = Deserialize(valueType, reader, context.Configuration); } dictionary[key] = deserializedItem; } return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, dictionary)); } if (jsonProperties.ContainsKey(memberValue.NameForSerialization)) { var jsonProperty = jsonProperties[memberValue.NameForSerialization]; var jsonValue = jsonProperty.Value; if (jsonValue != null) { object finalMemberValue = null; var valueType = memberValue.GetBestMemberType(); if (valueType.IsEnumEx()) { var enumName = Enum.GetName(valueType, (int)jsonValue); if (!string.IsNullOrWhiteSpace(enumName)) { finalMemberValue = Enum.Parse(valueType, enumName, false); } } else { try { var isDeserialized = false; if (jsonValue.Type == JTokenType.String && ShouldSerializeUsingParseAndToString(memberValue, false)) { var tempValue = memberValue.Value; memberValue.Value = (string)jsonValue; var parsedValue = DeserializeUsingObjectParse(context, memberValue); if (parsedValue != null) { finalMemberValue = parsedValue; isDeserialized = true; } else { memberValue.Value = tempValue; } } if (!isDeserialized) { if (ShouldExternalSerializerHandleMember(memberValue)) { finalMemberValue = jsonValue.ToObject(valueType, serializationContext.JsonSerializer); } else if (ShouldSerializeAsCollection(memberValue)) { finalMemberValue = Deserialize(valueType, jsonProperty.Value.CreateReader(context.Configuration), context.Configuration); } else { if (jsonValue.HasValues) { var finalValueType = valueType; var typeNameValue = jsonValue.Value <string>(TypeName); if (!string.IsNullOrWhiteSpace(typeNameValue)) { finalValueType = TypeCache.GetType(typeNameValue); } // Serialize ourselves finalMemberValue = Deserialize(finalValueType, jsonValue.CreateReader(context.Configuration), context.Configuration); } } } } catch (Exception ex) { Log.Debug(ex, "Failed to parse json value for '{0}', treating value as string", memberValue.Name); // As a fallback, interpret as a string (might be a modifier) finalMemberValue = (string)jsonValue; } } if (finalMemberValue != null) { if (PreserveReferences && finalMemberValue.GetType().IsClassType()) { var graphIdPropertyName = string.Format("${0}_{1}", memberValue.NameForSerialization, GraphId); if (jsonProperties.ContainsKey(graphIdPropertyName)) { var graphId = (int)jsonProperties[graphIdPropertyName].Value; var referenceManager = context.ReferenceManager; referenceManager.RegisterManually(graphId, finalMemberValue); } } return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, finalMemberValue)); } } } } var shouldSerializeAsCollection = ShouldSerializeAsCollection(memberValue); if (shouldSerializeAsCollection) { var collection = new List <object>(); var jArray = context.Context.JsonArray; if (jArray != null) { var memberType = memberValue.GetBestMemberType(); var collectionItemType = memberType.GetCollectionElementType(); var shouldBeHandledByExternalSerializer = ShouldExternalSerializerHandleMember(collectionItemType); foreach (var item in jArray.Children()) { object deserializedItem = null; if (shouldBeHandledByExternalSerializer) { deserializedItem = item.ToObject(collectionItemType, serializationContext.JsonSerializer); } else { deserializedItem = Deserialize(collectionItemType, item.CreateReader(context.Configuration), context.Configuration); } collection.Add(deserializedItem); } } return(SerializationObject.SucceededToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name, collection)); } return(SerializationObject.FailedToDeserialize(context.ModelType, memberValue.MemberGroup, memberValue.Name)); }
/// <summary> /// Obtiene el json de un Objeto de serializacion /// </summary> /// <param name="obj">Objeto de serializacion</param> /// <returns>Json del objeto</returns> public string GetJson(SerializationObject obj) { return(JsonUtility.ToJson(obj)); }
public void ThrowsArgumentExceptionForNullOrEmptyPropertyName() { ExceptionTester.CallMethodAndExpectException <ArgumentException>(() => SerializationObject.SucceededToDeserialize(typeof(SerializationObject), SerializationMemberGroup.CatelProperty, null, null)); ExceptionTester.CallMethodAndExpectException <ArgumentException>(() => SerializationObject.SucceededToDeserialize(typeof(SerializationObject), SerializationMemberGroup.CatelProperty, string.Empty, null)); }
public void ThrowsArgumentNullExceptionForNullType() { ExceptionTester.CallMethodAndExpectException <ArgumentNullException>(() => SerializationObject.SucceededToDeserialize(null, SerializationMemberGroup.CatelProperty, "property", null)); }
/// <summary> /// Creates a control corresponding to the serialization object passed. /// </summary> /// <param name="serializationObject">The serialization object.</param> /// <param name="parent">parent control</param> /// <returns></returns> private ISerializableControl CreateControl(SerializationObject serializationObject, Control parent) { return(CreateControl(serializationObject, parent, false)); }