public override void WriteData(SerializedObject objSerializedObject)
{
base.WriteData(objSerializedObject);
if (_objItems.Count > 0)
{
SerializedObject objChildren = objSerializedObject.Objects.Add("Items");
SerializedObjectCollection objObjects = objChildren.Objects;
SerializedValueCollection objValues = objChildren.Values;
SerializedValueType enuSerializedValueType = SerializedValueTypeHelper.GetTypeFromSystemType(typeof(TObjectType));
foreach (TObjectType objChildItem in _objItems)
{
if (enuSerializedValueType != SerializedValueType.Unknown)
{
objValues.Add("Item", objChildItem);
}
else if (objChildItem is ICustomSerializer)
{
objObjects.Add("Item", (ICustomSerializer)objChildItem);
}
else
{
objObjects.Add("Item", new SerializedWrapperObject(objChildItem));
}
}
}
}
public SerializedValue Add(string strName, object objValue, SerializedValueType enuValueType)
{
SerializedValue objSerializedValue = new SerializedValue(strName, objValue, enuValueType);
Add(objSerializedValue);
return(objSerializedValue);
}
public SerializedValue(string strName, object objValue, SerializedValueType enuValueType, bool blnEncrypted)
{
if (enuValueType == SerializedValueType.Unknown)
{
throw new ArgumentOutOfRangeException("objValue", "The SerializedValueType for this object is not known or supported.");
}
Name = strName;
_objValue = objValue;
ValueType = enuValueType;
Encrypted = blnEncrypted;
}
public override void WriteData(SerializedObject objSerializedObject)
{
base.WriteData(objSerializedObject);
SerializedObject objSettings = objSerializedObject.Objects.Add("Settings");
foreach (KeyValuePair <string, object> objKeyValuePair in Settings)
{
SerializedValueType enuValueType = SerializedValueTypeHelper.GetTypeFromObject(objKeyValuePair.Value);
if (enuValueType != SerializedValueType.Unknown)
{
objSettings.Values.Add(objKeyValuePair.Key, objKeyValuePair.Value);
}
else if (objKeyValuePair.Value is ICustomSerializer)
{
objSettings.Objects.Add(objKeyValuePair.Key, (ICustomSerializer)objKeyValuePair.Value);
}
else
{
objSettings.Objects.Add(objKeyValuePair.Key, new SerializedWrapperObject(objKeyValuePair.Value));
}
}
}
public TObjectType GetValue <TObjectType>()
{
TObjectType objValue = default(TObjectType);
Type objObjectType = typeof(TObjectType);
if (objObjectType.IsEnum == true)
{
objValue = (TObjectType)Enum.Parse(objObjectType, Value.ToString());
}
else
{
SerializedValueType enuValueType = SerializedValueTypeHelper.GetTypeFromSystemType(objObjectType);
switch (enuValueType)
{
case (SerializedValueType.Boolean):
objValue = (TObjectType)((object)GetBoolean());
break;
case (SerializedValueType.Byte):
objValue = (TObjectType)((object)GetByte());
break;
case (SerializedValueType.Char):
objValue = (TObjectType)((object)GetChar());
break;
case (SerializedValueType.DateTime):
objValue = (TObjectType)((object)GetDateTime());
break;
case (SerializedValueType.Decimal):
objValue = (TObjectType)((object)GetDecimal());
break;
case (SerializedValueType.Double):
objValue = (TObjectType)((object)GetDouble());
break;
case (SerializedValueType.Enum):
objValue = (TObjectType)Enum.Parse(objObjectType, GetString());
break;
case (SerializedValueType.Guid):
objValue = (TObjectType)((object)GetGuid());
break;
case (SerializedValueType.Int16):
objValue = (TObjectType)((object)GetInt16());
break;
case (SerializedValueType.Int32):
objValue = (TObjectType)((object)GetInt32());
break;
case (SerializedValueType.Int64):
objValue = (TObjectType)((object)GetInt64());
break;
case (SerializedValueType.SByte):
objValue = (TObjectType)((object)GetSByte());
break;
case (SerializedValueType.Single):
objValue = (TObjectType)((object)GetSingle());
break;
case (SerializedValueType.String):
objValue = (TObjectType)((object)GetString());
break;
case (SerializedValueType.UInt16):
objValue = (TObjectType)((object)GetUInt16());
break;
case (SerializedValueType.UInt32):
objValue = (TObjectType)((object)GetUInt32());
break;
case (SerializedValueType.UInt64):
objValue = (TObjectType)((object)GetUInt64());
break;
case (SerializedValueType.Timespan):
objValue = (TObjectType)((object)GetTimespan());
break;
case (SerializedValueType.ByteArray):
objValue = (TObjectType)((object)GetByteArray());
break;
}
}
return(objValue);
}
public SerializedValue(string strName, object objValue, SerializedValueType enuValueType)
: this(strName, objValue, enuValueType, false)
{
}
private void Deserialize(XmlLiteElement objXmlElement, SerializedObject objSerializedObject)
{
foreach (XmlLiteElement objChildElement in objXmlElement.Elements.ToArray())
{
string strAssemblyName = objChildElement.Attributes.GetValue(AssemblyAttributeName, string.Empty);
string strTypeName = objChildElement.Attributes.GetValue(TypeAttributeName, string.Empty);
if ((strTypeName.Length > 0) && (strAssemblyName.Length > 0))
{
SerializedTypeInfo objTypeInfo = new SerializedTypeInfo(strTypeName, strAssemblyName);
SerializedObject objChildObject = new SerializedObject(objChildElement.Name, objTypeInfo);
Deserialize(objChildElement, objChildObject);
objSerializedObject.Objects.Add(objChildObject);
}
else if (strTypeName.Length > 0)
{
XmlLiteAttribute objChildAttribute = objChildElement.Attributes[TypeAttributeName];
SerializedValueType enuValueType = (SerializedValueType)Enum.Parse(typeof(SerializedValueType), objChildAttribute.Value);
bool blnIsNull = Convert.ToBoolean(objChildElement.Attributes.GetValue(IsNullAttributeName, "false"));
bool blnIsEncrypted = Convert.ToBoolean(objChildElement.Attributes.GetValue(EncryptedAttributeName, "false"));
string strValue = ((blnIsNull == true) ? null : objChildElement.Value);
if (blnIsEncrypted == true)
{
strValue = EncryptionBase.Default.Decrypt(objChildElement.Value);
}
object objValue = null;
switch (enuValueType)
{
case (SerializedValueType.Boolean):
objValue = Convert.ToBoolean(strValue);
break;
case (SerializedValueType.Byte):
objValue = Convert.ToByte(strValue);
break;
case (SerializedValueType.ByteArray):
List <byte> objBytes = new List <byte>();
string[] strBytes = strValue.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);
foreach (string strByte in strBytes)
{
objBytes.Add(Convert.ToByte(strByte));
}
objValue = objBytes.ToArray();
break;
case (SerializedValueType.Char):
objValue = Convert.ToChar(strValue);
break;
case (SerializedValueType.DateTime):
objValue = Convert.ToDateTime(strValue);
break;
case (SerializedValueType.Decimal):
objValue = Convert.ToDecimal(strValue);
break;
case (SerializedValueType.Double):
objValue = Convert.ToDouble(strValue);
break;
case (SerializedValueType.Guid):
objValue = new Guid(strValue);
break;
case (SerializedValueType.Int16):
objValue = Convert.ToInt16(strValue);
break;
case (SerializedValueType.Int32):
// For backwards compatability
//
int intResult = 0;
if (Int32.TryParse(strValue, out intResult) == true)
{
objValue = Convert.ToInt32(strValue);
}
else
{
objValue = strValue;
}
break;
case (SerializedValueType.Int64):
objValue = Convert.ToInt64(strValue);
break;
case (SerializedValueType.Null):
objValue = null;
break;
case (SerializedValueType.SByte):
objValue = Convert.ToSByte(strValue);
break;
case (SerializedValueType.Single):
objValue = Convert.ToSingle(strValue);
break;
case (SerializedValueType.String):
case (SerializedValueType.Enum):
objValue = strValue;
break;
case (SerializedValueType.UInt16):
objValue = Convert.ToUInt16(strValue);
break;
case (SerializedValueType.UInt32):
objValue = Convert.ToUInt32(strValue);
break;
case (SerializedValueType.UInt64):
objValue = Convert.ToUInt64(strValue);
break;
case (SerializedValueType.Timespan):
objValue = TimeSpan.Parse(strValue);
break;
default:
string strErrorMessage = string.Format("No case handler is defined for SerializedValueType.{0}", enuValueType);
throw new Exception(strErrorMessage);
}
SerializedValue objSerializedValue = new SerializedValue(objChildElement.Name, objValue, enuValueType, blnIsEncrypted);
objSerializedObject.Values.Add(objSerializedValue);
}
else // This element is just an empty type / container.
{
SerializedObject objChildObject = new SerializedObject(objChildElement.Name, new SerializedTypeInfo());
Deserialize(objChildElement, objChildObject);
objSerializedObject.Objects.Add(objChildObject);
}
}
}
public static bool IsTypeSupported(Type objType)
{
SerializedValueType enuValueType = GetTypeFromSystemType(objType);
return(enuValueType != SerializedValueType.Unknown);
}
public static bool IsTypeSupported(object objValue)
{
SerializedValueType enuValueType = GetTypeFromObject(objValue);
return(enuValueType != SerializedValueType.Unknown);
}
public static SerializedValueType GetTypeFromObject(object objValue)
{
SerializedValueType enuValueType = SerializedValueType.Unknown;
if ((objValue == null) || (objValue is DBNull))
{
enuValueType = SerializedValueType.Null;
}
else if (objValue is Boolean)
{
enuValueType = SerializedValueType.Boolean;
}
else if (objValue is byte)
{
enuValueType = SerializedValueType.Byte;
}
else if (objValue is byte[])
{
enuValueType = SerializedValueType.ByteArray;
}
else if (objValue is Char)
{
enuValueType = SerializedValueType.Char;
}
else if (objValue is DateTime)
{
enuValueType = SerializedValueType.DateTime;
}
else if (objValue is Decimal)
{
enuValueType = SerializedValueType.Decimal;
}
else if (objValue is Double)
{
enuValueType = SerializedValueType.Double;
}
else if (objValue is Enum)
{
enuValueType = SerializedValueType.Enum;
}
else if (objValue is Guid)
{
enuValueType = SerializedValueType.Guid;
}
else if (objValue is Int16)
{
enuValueType = SerializedValueType.Int16;
}
else if (objValue is Int32)
{
enuValueType = SerializedValueType.Int32;
}
else if (objValue is Int64)
{
enuValueType = SerializedValueType.Int64;
}
else if (objValue is SByte)
{
enuValueType = SerializedValueType.SByte;
}
else if (objValue is Single)
{
enuValueType = SerializedValueType.Single;
}
else if (objValue is String)
{
enuValueType = SerializedValueType.String;
}
else if (objValue is UInt16)
{
enuValueType = SerializedValueType.UInt16;
}
else if (objValue is UInt32)
{
enuValueType = SerializedValueType.UInt32;
}
else if (objValue is UInt64)
{
enuValueType = SerializedValueType.UInt64;
}
else if (objValue is TimeSpan)
{
enuValueType = SerializedValueType.Timespan;
}
return(enuValueType);
}
public static SerializedValueType GetTypeFromSystemType(Type objType)
{
SerializedValueType enuValueType = SerializedValueType.Unknown;
if ((objType == null) || (objType.IsAssignableFrom(typeof(DBNull)) == true))
{
enuValueType = SerializedValueType.Null;
}
else if (objType.IsAssignableFrom(typeof(Boolean)) == true)
{
enuValueType = SerializedValueType.Boolean;
}
else if (objType.IsAssignableFrom(typeof(byte)) == true)
{
enuValueType = SerializedValueType.Byte;
}
else if (objType.IsAssignableFrom(typeof(byte[])) == true)
{
enuValueType = SerializedValueType.ByteArray;
}
else if (objType.IsAssignableFrom(typeof(char)) == true)
{
enuValueType = SerializedValueType.Char;
}
else if (objType.IsAssignableFrom(typeof(DateTime)) == true)
{
enuValueType = SerializedValueType.DateTime;
}
else if (objType.IsAssignableFrom(typeof(decimal)) == true)
{
enuValueType = SerializedValueType.Decimal;
}
else if (objType.IsAssignableFrom(typeof(double)) == true)
{
enuValueType = SerializedValueType.Double;
}
else if (objType.IsAssignableFrom(typeof(Enum)) == true)
{
enuValueType = SerializedValueType.Enum;
}
else if (objType.IsAssignableFrom(typeof(Guid)) == true)
{
enuValueType = SerializedValueType.Guid;
}
else if (objType.IsAssignableFrom(typeof(Int16)) == true)
{
enuValueType = SerializedValueType.Int16;
}
else if (objType.IsAssignableFrom(typeof(Int32)) == true)
{
enuValueType = SerializedValueType.Int32;
}
else if (objType.IsAssignableFrom(typeof(Int64)) == true)
{
enuValueType = SerializedValueType.Int64;
}
else if (objType.IsAssignableFrom(typeof(SByte)) == true)
{
enuValueType = SerializedValueType.SByte;
}
else if (objType.IsAssignableFrom(typeof(Single)) == true)
{
enuValueType = SerializedValueType.Single;
}
else if (objType.IsAssignableFrom(typeof(String)) == true)
{
enuValueType = SerializedValueType.String;
}
else if (objType.IsAssignableFrom(typeof(UInt16)) == true)
{
enuValueType = SerializedValueType.UInt16;
}
else if (objType.IsAssignableFrom(typeof(UInt32)) == true)
{
enuValueType = SerializedValueType.UInt32;
}
else if (objType.IsAssignableFrom(typeof(UInt64)) == true)
{
enuValueType = SerializedValueType.UInt64;
}
else if (objType.IsAssignableFrom(typeof(TimeSpan)) == true)
{
enuValueType = SerializedValueType.Timespan;
}
return(enuValueType);
}
public SerializedValue Add(string strName, object objValue)
{
SerializedValueType enuValueType = SerializedValueTypeHelper.GetTypeFromObject(objValue);
return(Add(strName, objValue, enuValueType));
}
private SerializedObject Deserialize(BinaryReader objBinaryReader, BinaryFormatterKeyManager objKeyManager)
{
SerializedObject objRootObject = null;
SerializedObject objCurrentObject = null;
Stack <SerializedObject> objObjectStack = new Stack <SerializedObject>();
byte objDataType = 0;
while ((objDataType = objBinaryReader.ReadByte()) != EndDataType)
{
switch (objDataType)
{
case (ObjectRecordType):
string strObjectName = objKeyManager.Element.FindValueByKey(objBinaryReader.ReadString());
string strObjectTypeName = objKeyManager.Type.FindValueByKey(objBinaryReader.ReadString());
string strObjectAssessmblyName = objKeyManager.Assembly.FindValueByKey(objBinaryReader.ReadString());
objCurrentObject = new SerializedObject(strObjectName, new SerializedTypeInfo(strObjectTypeName, strObjectAssessmblyName));
if (objRootObject == null)
{
objRootObject = objCurrentObject;
objObjectStack.Push(objCurrentObject);
}
else
{
SerializedObject objParentObject = objObjectStack.Peek();
objParentObject.Objects.Add(objCurrentObject);
objObjectStack.Push(objCurrentObject);
}
break;
case (ValueRecordType):
string strValueName = objKeyManager.Element.FindValueByKey(objBinaryReader.ReadString());
SerializedValueType enuValueType = (SerializedValueType)objBinaryReader.ReadByte();
bool blnValueEncrypted = objBinaryReader.ReadBoolean();
bool blnIsNull = objBinaryReader.ReadBoolean();
object objValue = null;
if (blnIsNull == false)
{
switch (enuValueType)
{
case (SerializedValueType.Boolean):
objValue = objBinaryReader.ReadBoolean();
break;
case (SerializedValueType.Byte):
objValue = objBinaryReader.ReadByte();
break;
case (SerializedValueType.ByteArray):
int intByteCount = objBinaryReader.ReadInt32();
objValue = objBinaryReader.ReadBytes(intByteCount);
break;
case (SerializedValueType.Char):
objValue = objBinaryReader.ReadChar();
break;
case (SerializedValueType.DateTime):
objValue = DateTime.FromBinary(objBinaryReader.ReadInt64());
break;
case (SerializedValueType.Decimal):
objValue = objBinaryReader.ReadDecimal();
break;
case (SerializedValueType.Double):
objValue = objBinaryReader.ReadDouble();
break;
case (SerializedValueType.Enum):
objValue = objBinaryReader.ReadInt32();
break;
case (SerializedValueType.Guid):
int intGuidByteCount = objBinaryReader.ReadInt32();
byte[] bytGuidBytes = objBinaryReader.ReadBytes(intGuidByteCount);
objValue = new Guid(bytGuidBytes);
break;
case (SerializedValueType.Int16):
objValue = objBinaryReader.ReadInt16();
break;
case (SerializedValueType.Int32):
objValue = objBinaryReader.ReadInt32();
break;
case (SerializedValueType.Int64):
objValue = objBinaryReader.ReadInt64();
break;
case (SerializedValueType.Null):
objValue = null;
break;
case (SerializedValueType.SByte):
objValue = objBinaryReader.ReadSByte();
break;
case (SerializedValueType.Single):
objValue = objBinaryReader.ReadSingle();
break;
case (SerializedValueType.String):
string strValue = objBinaryReader.ReadString();
if (blnValueEncrypted == true)
{
strValue = EncryptionBase.Instance.Decrypt(strValue);
}
objValue = strValue;
break;
case (SerializedValueType.UInt16):
objValue = objBinaryReader.ReadUInt16();
break;
case (SerializedValueType.UInt32):
objValue = objBinaryReader.ReadUInt32();
break;
case (SerializedValueType.UInt64):
objValue = objBinaryReader.ReadUInt64();
break;
case (SerializedValueType.Timespan):
objValue = TimeSpan.Parse(objBinaryReader.ReadString());
break;
default:
string strErrorMessage = string.Format("No case handler is defined for SerializedValueType.{0}", enuValueType);
throw new Exception(strErrorMessage);
}
}
SerializedValue objSerializedValue = new SerializedValue(strValueName, objValue, enuValueType, false);
objCurrentObject.Values.Add(objSerializedValue);
break;
case (EndObjectRecordType):
objObjectStack.Pop();
break;
}
}
return(objRootObject);
}
