/// <summary>
/// Perform a deep Copy of the object.
/// </summary>
/// <typeparam name="T">The type of object being copied.</typeparam>
/// <param name="source">The object instance to copy.</param>
/// <returns>The copied object.</returns>
public static T Clone <T>(this T source, bool ignoreId = false)
{
//if (!typeof(T).IsSerializable)
//{
// throw new ArgumentException("The type must be serializable.", "source");
//}
// Don't serialize a null object, simply return the default for that object
if (Object.ReferenceEquals(source, null))
{
return(default(T));
}
//IFormatter formatter = new BinaryFormatter();
//formatter.Context = new StreamingContext(StreamingContextStates.Clone);
//Stream stream = new MemoryStream();
//using (stream)
//{
// formatter.Serialize(stream, source);
// stream.Seek(0, SeekOrigin.Begin);
// return (T)formatter.Deserialize(stream);
//}
var tmp = SilverlightSerializer.IgnoreIds;
SilverlightSerializer.IgnoreIds = ignoreId;
var c = SilverlightSerializer.Serialize(source);
var res = (T)SilverlightSerializer.Deserialize(c);
SilverlightSerializer.IgnoreIds = tmp;
return(res);
}
public static bool IsModified(this object currentCopy, object original)
{
string orgSum = SilverlightSerializer.GetChecksum(original);
string copySum = SilverlightSerializer.GetChecksum(currentCopy);
return(orgSum != copySum);
}
public static ApplicationState LoadState()
{
try
{
using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
{
if (store.FileExists(Constants.StateFileName))
{
using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(Constants.StateFileName, FileMode.Open, store))
{
//DataContractSerializer serializer = new DataContractSerializer(typeof(ApplicationState));
//return (ApplicationState)serializer.ReadObject(stream);
var state = (ApplicationState)SilverlightSerializer.Deserialize(stream);
return(state);
}
}
}
}
catch (Exception ex)
{
#if DEBUG
//throw;
#endif
}
return(null);
}
public static T Copy <T>(this T oSource, bool ignoreId = false)
{
//T oClone;
//DataContractSerializer dcs = new DataContractSerializer(typeof(T));
//using (MemoryStream ms = new MemoryStream())
//{
// dcs.WriteObject(ms, oSource);
// ms.Position = 0;
// oClone = (T)dcs.ReadObject(ms);
//}
//return oClone;
//BUG FII
SilverlightSerializer.Reset();
var tmp = SilverlightSerializer.IgnoreIds;
SilverlightSerializer.IgnoreIds = ignoreId;
var c = SilverlightSerializer.Serialize(oSource);
var res = (T)SilverlightSerializer.Deserialize(c);
SilverlightSerializer.IgnoreIds = tmp;
return(res);
}
private void Save()
{
if (string.IsNullOrEmpty(Name))
{
return;
}
var data = SilverlightSerializer.Serialize(ColumnInfo);
File.WriteAllBytes(LocalSettings.DocumentPath + "\\" + Name + ".dat", data);
}
public async Task SaveToStorage(object model)
{
var datafile = await ApplicationData.Current.LocalFolder.CreateFileAsync(GetDataFileName(model.GetType()),
CreationCollisionOption.ReplaceExisting);
using (var fileStream = await datafile.OpenStreamForWriteAsync())
{
SilverlightSerializer.Serialize(model, fileStream);
}
}
private void TestDateTimeOffsetEqualness(DateTimeOffset testDate)
{
var m = new MemoryStream();
SilverlightSerializer.Serialize(testDate, m);
m.Seek(0, SeekOrigin.Begin);
var testDate2 = (DateTimeOffset)SilverlightSerializer.Deserialize(m);
Assert.AreEqual(testDate, testDate2);
}
private void PersistAllAsync(object o)
{
LocalSettings.UpdateThreadLanguage();
if (!string.IsNullOrEmpty(o.ToString()) && (int)o != _tNumber)
{
return;
}
var data = SilverlightSerializer.Serialize(_storage);
File.WriteAllBytes(_fileName, data);
}
public bool StartSerializing(Entry entry, int id)
{
if (entry.MustHaveName)
{
ushort nameID = SilverlightSerializer.GetPropertyDefinitionId(entry.Name);
WriteSimpleValue(nameID);
}
var item = entry.Value ?? new SilverlightSerializer.Nuller();
EncodeType(item, entry.StoredType);
return(false);
}
public void TestDateTime()
{
var testDate = DateTime.Now;
var m = new MemoryStream();
SilverlightSerializer.Serialize(testDate, m);
m.Seek(0, SeekOrigin.Begin);
var testDate2 = (DateTime)SilverlightSerializer.Deserialize(m);
Assert.AreEqual(testDate, testDate2);
}
private void PersistAllAsync(object o)
{
LocalSettings.UpdateThreadLanguage();
if (!string.IsNullOrEmpty(o.ToString()) && (int)o != _tNumber)
{
return;
}
//var serializerHelper = new XmlSerializerHelper { IgnoreSerializableAttribute = true, IgnoreSerialisationErrors = true };
//serializerHelper.Serialize(_storage, _fileName);
var data = SilverlightSerializer.Serialize(_storage);
File.WriteAllBytes(_fileName, data);
}
public void StartDeserializing()
{
SilverlightSerializer.KtStack.Push(SilverlightSerializer.KnownTypes);
SilverlightSerializer.PiStack.Push(SilverlightSerializer.PropertyIds);
var stream = new MemoryStream(Data);
var reader = new BinaryReader(stream);
var version = reader.ReadString();
SilverlightSerializer.currentVersion = int.Parse(version.Substring(4));
if (SilverlightSerializer.currentVersion >= 3)
{
SilverlightSerializer.Verbose = reader.ReadBoolean();
}
SilverlightSerializer.PropertyIds = new List <string>();
SilverlightSerializer.KnownTypes = new List <RuntimeTypeHandle>();
var count = reader.ReadInt32();
for (var i = 0; i < count; i++)
{
var typeName = reader.ReadString();
var tp = Type.GetType(typeName);
if (tp == null)
{
var map = new SilverlightSerializer.TypeMappingEventArgs
{
TypeName = typeName
};
SilverlightSerializer.InvokeMapMissingType(map);
tp = map.UseType;
}
if (tp == null)
{
throw new ArgumentException(string.Format("Cannot reference type {0} in this context", typeName));
}
SilverlightSerializer.KnownTypes.Add(tp.TypeHandle);
}
count = reader.ReadInt32();
for (var i = 0; i < count; i++)
{
SilverlightSerializer.PropertyIds.Add(reader.ReadString());
}
var data = reader.ReadBytes(reader.ReadInt32());
_myStream = new MemoryStream(data);
_reader = new BinaryReader(_myStream);
reader.Close();
stream.Close();
}
public static T RetrieveFromPhoneState <T>(this Application app) where T : class
{
var modelKey = GetModelKey(typeof(T));
if (PhoneApplicationService.Current.State.ContainsKey(modelKey))
{
using (var ms = new MemoryStream(PhoneApplicationService.Current.State[modelKey] as byte[]))
{
return(SilverlightSerializer.Deserialize(ms) as T);
}
}
return(null);
}
private static object GetVanilla(RuntimeTypeHandle type)
{
object vanilla;
lock (Vanilla)
{
if (!Vanilla.TryGetValue(type, out vanilla))
{
vanilla = SilverlightSerializer.CreateObject(Type.GetTypeFromHandle(type));
Vanilla[type] = vanilla;
}
}
return(vanilla);
}
public void ReloadAll()
{
if (File.Exists(_fileName))
{
try
{
var data = File.ReadAllBytes(_fileName);
_storage = SilverlightSerializer.Deserialize(data) as DataStorage;
}
catch (Exception)
{
_storage = new DataStorage();
}
}
}
public static void SaveToPhoneState(this Application app, object model)
{
var modelKey = GetModelKey(model.GetType());
if (PhoneApplicationService.Current.State.ContainsKey(modelKey))
{
PhoneApplicationService.Current.State.Remove(modelKey);
}
using (var ms = new MemoryStream())
{
SilverlightSerializer.Serialize(model, ms);
PhoneApplicationService.Current.State.Add(modelKey, ms.GetBuffer());
}
}
private void Load()
{
if (string.IsNullOrEmpty(Name))
{
return;
}
var fn = LocalSettings.DocumentPath + "\\" + Name + ".dat";
if (File.Exists(fn))
{
var data = File.ReadAllBytes(fn);
var ci = SilverlightSerializer.Deserialize(data);
ColumnInfo = (ObservableCollection <ColumnInfo>)ci;
}
}
/// <summary>
/// Set serialize packet
/// </summary>
/// <param name="obj">serialize class object</param>
public void SetPacket(PacketStruct obj)
{
m_stream = new MemoryStream();
switch (Mode)
{
case SerializerMode.DEFAULT:
case SerializerMode.ALLOW_ALL_ASSEMBLY_VERSION_DESERIALIZATION:
m_formatter.Serialize(m_stream, obj);
break;
case SerializerMode.SILVERLIGHT_SERIALIZER:
SilverlightSerializer.Serialize(obj, m_stream);
break;
}
}
public void TestBasicPosition()
{
var testobj = new BasicGeoposition {
Latitude = 52.155915, Longitude = 5.390376, Altitude = 10.0
};
var m = new MemoryStream();
SilverlightSerializer.Serialize(testobj, m);
m.Seek(0, SeekOrigin.Begin);
var testObj2 = (BasicGeoposition)SilverlightSerializer.Deserialize(m);
Assert.AreEqual(testobj, testObj2);
}
public void TestObjectWithSimpleProperties()
{
var testobj = new SimpleTestObject {
Prop1 = 1, Prop2 = "BLABLA", Prop3 = 21.0
};
var m = new MemoryStream();
SilverlightSerializer.Serialize(testobj, m);
m.Seek(0, SeekOrigin.Begin);
var testObj2 = (SimpleTestObject)SilverlightSerializer.Deserialize(m);
Assert.AreEqual(testobj.Prop1, testObj2.Prop1);
Assert.AreEqual(testobj.Prop2, testObj2.Prop2);
Assert.AreEqual(testobj.Prop3, testObj2.Prop3);
}
public void SaveToStorage(object model)
{
var dataFileName = GetDataFileName(model.GetType());
using (var appStorage = IsolatedStorageFile.GetUserStoreForApplication())
{
if (appStorage.FileExists(dataFileName))
{
appStorage.DeleteFile(dataFileName);
}
using (var iss = appStorage.CreateFile(dataFileName))
{
SilverlightSerializer.Serialize(model, iss);
}
}
}
private static GetSet[][] GetAccessors(RuntimeTypeHandle type)
{
lock (PropertyAccess)
{
var index = (SilverlightSerializer.IsChecksum ? 1 : 0) + (SilverlightSerializer.IsChecksum && SilverlightSerializer.IgnoreIds ? 1 : 0);
GetSet[][][] collection;
if (!PropertyAccess.TryGetValue(type, out collection))
{
collection = new GetSet[3][][];
PropertyAccess[type] = collection;
}
var accessors = collection[index];
if (accessors == null)
{
var vanilla = GetVanilla(type);
var acs = new List <GetSet>();
var props = SilverlightSerializer.GetPropertyInfo(type);
foreach (var p in props)
{
var gs = typeof(GetSetGeneric <,>);
var tp = gs.MakeGenericType(new Type[] { Type.GetTypeFromHandle(type), p.PropertyType });
var getSet = (GetSet)Activator.CreateInstance(tp, new object[] { p });
getSet.Vanilla = getSet.Get(vanilla);
acs.Add(getSet);
}
accessors = new GetSet[2][];
accessors[0] = acs.ToArray();
acs.Clear();
var fields = SilverlightSerializer.GetFieldInfo(type);
foreach (var f in fields)
{
var gs = typeof(GetSetGeneric <,>);
var tp = gs.MakeGenericType(new Type[] { Type.GetTypeFromHandle(type), f.FieldType });
var getSet = (GetSet)Activator.CreateInstance(tp, new object[] { f });
getSet.Vanilla = getSet.Get(vanilla);
acs.Add(getSet);
}
accessors[1] = acs.ToArray();
collection[index] = accessors;
}
return(accessors);
}
}
/// <summary>
/// Default constructor
/// </summary>
/// <param name="packet">packet class object</param>
/// <param name="serializerMode">serializer mode</param>
public PacketSerializer(PacketStruct packet = null, SerializerMode serializerMode = SerializerMode.SILVERLIGHT_SERIALIZER)
{
m_formatter.AssemblyFormat = FormatterAssemblyStyle.Simple;
m_stream = new MemoryStream();
Mode = serializerMode;
switch (Mode)
{
case SerializerMode.DEFAULT:
case SerializerMode.ALLOW_ALL_ASSEMBLY_VERSION_DESERIALIZATION:
m_formatter.Serialize(m_stream, packet);
break;
case SerializerMode.SILVERLIGHT_SERIALIZER:
SilverlightSerializer.Serialize(packet, m_stream);
break;
}
}
/// <summary>
/// Clone and return packet class object
/// </summary>
/// <returns>cloned packet class object</returns>
public PacketStruct ClonePacketObj()
{
PacketStruct retPacketObj = null;
m_stream.Seek(0, SeekOrigin.Begin);
switch (Mode)
{
case SerializerMode.ALLOW_ALL_ASSEMBLY_VERSION_DESERIALIZATION:
case SerializerMode.DEFAULT:
retPacketObj = (PacketStruct)m_formatter.Deserialize(m_stream);
break;
case SerializerMode.SILVERLIGHT_SERIALIZER:
retPacketObj = (PacketStruct)SilverlightSerializer.Deserialize(m_stream);
break;
}
return(retPacketObj);
}
public void SaveState()
{
try
{
using (IsolatedStorageFile store = IsolatedStorageFile.GetUserStoreForApplication())
{
using (IsolatedStorageFileStream stream = new IsolatedStorageFileStream(Constants.PageStateFileName, FileMode.Create, store))
{
//DataContractSerializer serializer = new DataContractSerializer(typeof(ApplicationState));
//serializer.WriteObject(stream, this);
SilverlightSerializer.Serialize(this, stream);
}
}
}
catch (Exception ex)
{
}
}
public void TestSimpleSerialize()
{
var bla = new ReflectionTestSubject();
bla.MyList.Add("hallo");
bla.MyList.Add("hallo2");
bla.MyList.Add("hallo3");
bla.MyString = "hoi";
var m = new MemoryStream();
SilverlightSerializer.Serialize(bla, m);
m.Seek(0, SeekOrigin.Begin);
var bla2 = SilverlightSerializer.Deserialize(m) as ReflectionTestSubject;
Assert.AreEqual(bla.MyString, bla2.MyString);
Assert.AreEqual(bla.MyList.Count, bla2.MyList.Count);
}
public async Task <T> RetrieveFromStorage()
{
try
{
var datafile = await GetDataFile();
if (datafile != null)
{
using (var fileStream = await datafile.OpenSequentialReadAsync())
{
return(SilverlightSerializer.Deserialize(fileStream.AsStreamForRead()) as T);
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex);
}
return(null);
}
public T RetrieveFromStorage()
{
using (var appStorage = IsolatedStorageFile.GetUserStoreForApplication())
{
var dataFileName = GetDataFileName(typeof(T));
if (appStorage.FileExists(dataFileName))
{
using (var iss = appStorage.OpenFile(dataFileName, FileMode.Open))
{
try
{
return(SilverlightSerializer.Deserialize(iss) as T);
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e);
}
}
}
}
return(null);
}
public void TestDateTimeOffset3()
{
var testObj = new ComplexTestObject();
var d1 = new DateTimeOffset(DateTime.UtcNow);
var d2 = new DateTimeOffset(DateTime.Now);
testObj.Alist.Add(d1);
testObj.Alist.Add(d2);
testObj.DateTime1 = d1;
testObj.DateTime2 = d2;
var m = new MemoryStream();
SilverlightSerializer.Serialize(testObj, m);
m.Seek(0, SeekOrigin.Begin);
var testObj2 = (ComplexTestObject)SilverlightSerializer.Deserialize(m);
Assert.AreEqual(testObj2.Alist[0], d1);
Assert.AreEqual(testObj2.Alist[1], d2);
Assert.AreEqual(testObj2.DateTime1, d1);
Assert.AreEqual(testObj2.DateTime2, d2);
}
private void EncodeType(object item, Type storedType)
{
if (item == null)
{
WriteSimpleValue((ushort)0xFFFE);
return;
}
var itemType = item.GetType().TypeHandle;
//If this isn't a simple type, then this might be a subclass so we need to
//store the type
if (storedType == null || !storedType.Equals(item.GetType()) || SilverlightSerializer.Verbose)
{
//Write the type identifier
var tpId = SilverlightSerializer.GetTypeId(itemType);
WriteSimpleValue(tpId);
}
else
{
//Write a dummy identifier
WriteSimpleValue((ushort)0xFFFF);
}
}
