/// <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));
}
