public SerializedValue Add(string strName, byte[] objValue)
{
SerializedValue objSerializedValue = new SerializedValue(strName, objValue);
Add(objSerializedValue);
return(objSerializedValue);
}
public SerializedValue Add(string strName, object objValue, SerializedValueType enuValueType)
{
SerializedValue objSerializedValue = new SerializedValue(strName, objValue, enuValueType);
Add(objSerializedValue);
return(objSerializedValue);
}
public SerializedValue Add(string strName, String objValue, bool blnEncrypted)
{
SerializedValue objSerializedValue = new SerializedValue(strName, objValue, blnEncrypted);
Add(objSerializedValue);
return(objSerializedValue);
}
public SerializedValue Add(string strName, TimeSpan objValue)
{
SerializedValue objSerializedValue = new SerializedValue(strName, objValue);
Add(objSerializedValue);
return(objSerializedValue);
}
public TObjectType GetValue <TObjectType>(string strName, TObjectType objDefaultValue)
{
TObjectType objReturnValue = objDefaultValue;
SerializedValue objSerializaedValue = this[strName];
if (objSerializaedValue != null)
{
objReturnValue = (TObjectType)objSerializaedValue.GetValue <TObjectType>();
}
return(objReturnValue);
}
public object GetValue(string strName, object objDefaultValue)
{
object objReturnValue = objDefaultValue;
SerializedValue objSerializaedValue = this[strName];
if (objSerializaedValue != null)
{
objReturnValue = objSerializaedValue.Value;
}
return(objReturnValue);
}
public SerializedValue[] GetValues(string strName)
{
if (strName == null)
{
throw new ArgumentNullException("strName", "A valid non-null string is required.");
}
SerializedValue[] arrValues = null;
if (Values.ContainsKey(strName) == true)
{
arrValues = Values[strName].ToArray();
}
else
{
arrValues = new SerializedValue[0];
}
return(arrValues);
}
public void Add(SerializedValue objSerializedValue)
{
if (objSerializedValue == null)
{
throw new ArgumentNullException("objSerializedValue", "A valid non-null SerializedValue is required..");
}
string strKey = objSerializedValue.Name;
List <SerializedValue> objIndexedValues = null;
if (Values.TryGetValue(strKey, out objIndexedValues) == false)
{
objIndexedValues = new List <SerializedValue>();
Values.Add(strKey, objIndexedValues);
}
objIndexedValues.Add(objSerializedValue);
}
public SerializedValue this[string strName]
{
get
{
if (strName == null)
{
throw new ArgumentNullException("strName", "a valid non-null string is required..");
}
SerializedValue objSerializedValue = null;
List <SerializedValue> objIndexedValues = null;
if (Values.TryGetValue(strName, out objIndexedValues) == true)
{
objSerializedValue = objIndexedValues[0];
}
return(objSerializedValue);
}
set
{
if (strName == null)
{
throw new ArgumentNullException("strName", "a valid non-null string is required..");
}
List <SerializedValue> objIndexedValues = null;
if (Values.TryGetValue(strName, out objIndexedValues) == false)
{
objIndexedValues = new List <SerializedValue>();
Values.Add(strName, objIndexedValues);
}
objIndexedValues.Add(value);
}
}
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);
}
}
}
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);
}
