public string GetNavigationState(MtFrame frame)
{
// remove pages which do not support tombstoning
var pagesToSerialize = _pages;
var currentIndexToSerialize = CurrentIndex;
var firstPageToRemove = _pages.FirstOrDefault(p =>
{
var page = p.GetPage(frame);
return(!page.IsSuspendable);
});
if (firstPageToRemove != null)
{
var index = pagesToSerialize.IndexOf(firstPageToRemove);
pagesToSerialize = _pages.Take(index).ToList();
currentIndexToSerialize = index - 1;
}
var output = DataContractSerialization.Serialize(
new MtFrameDescription
{
CurrentPageIndex = currentIndexToSerialize,
PageStack = pagesToSerialize
},
true, MtSuspensionManager.KnownTypes.ToArray());
return(output);
}
public void SetNavigationState(string data)
{
var frameDescription = DataContractSerialization.Deserialize <MtFrameDescription>(data, MtSuspensionManager.KnownTypes.ToArray());
_pages = frameDescription.PageStack;
CurrentIndex = frameDescription.CurrentPageIndex;
}
public static string Encrypt(DataTable dt)
{
if (dt == null)
{
return(null);
}
return(AesCryptography.Encrypt(Utils.Compress(DataContractSerialization.Serialize(dt))));
}
/// <summary>Gets an object which is deserialized with <see cref="DataContractSerialization"/>. </summary>
/// <typeparam name="T">The type of the object. </typeparam>
/// <param name="key">The key. </param>
/// <returns>The object. </returns>
public T Get <T>(string key)
{
if (PageState != null)
{
return(DataContractSerialization.Deserialize <T>((string)PageState[key]));
}
return(default(T));
}
/// <summary>Serializes and writes a setting object in a file (uses the DataContractSerializer).</summary>
/// <typeparam name="TValue">The type of the setting value.</typeparam>
/// <param name="key">The key.</param>
/// <param name="value">The value.</param>
/// <param name="roaming">If set to <c>true</c> the setting is synchronized between devices.</param>
/// <param name="extraTypes">The extra types.</param>
/// <returns>The task.</returns>
public static async Task SetSettingToFileAsync <TValue>(string key, TValue value, bool roaming = false, Type[] extraTypes = null)
{
var file = roaming ? await ApplicationData.Current.RoamingFolder.CreateFileAsync(key + ".settings", CreationCollisionOption.ReplaceExisting) :
await ApplicationData.Current.LocalFolder.CreateFileAsync(key + ".settings", CreationCollisionOption.ReplaceExisting);
var xml = DataContractSerialization.Serialize(value, true, extraTypes);
await FileIO.WriteTextAsync(file, xml, UnicodeEncoding.Utf8);
}
public static DataTable Decrypt(string encryptedString)
{
if (string.IsNullOrEmpty(encryptedString))
{
return(null);
}
return(DataContractSerialization.Deserialize <DataTable>(Utils.Decompress(AesCryptography.Decrypt(encryptedString))) as DataTable);
}
/// <summary>Reads and deserializes a setting object from a file (uses the DataContractSerializer).</summary>
/// <typeparam name="TValue">The type of the setting value.</typeparam>
/// <param name="key">The key.</param>
/// <param name="defaultValue">The default setting value.</param>
/// <param name="roaming">If set to <c>true</c> the setting is synchronized between devices.</param>
/// <param name="extraTypes">The extra types.</param>
/// <returns>The task.</returns>
public static async Task <TValue> GetSettingFromFileAsync <TValue>(string key, TValue defaultValue, bool roaming = false, Type[] extraTypes = null)
{
var file = roaming ? await ApplicationData.Current.RoamingFolder.CreateFileAsync(key + ".settings", CreationCollisionOption.OpenIfExists) :
await ApplicationData.Current.LocalFolder.CreateFileAsync(key + ".settings", CreationCollisionOption.OpenIfExists);
var xml = await FileIO.ReadTextAsync(file, UnicodeEncoding.Utf8);
return(!String.IsNullOrEmpty(xml) ? DataContractSerialization.Deserialize <TValue>(xml, extraTypes) : defaultValue);
}
public static void WriteDataContract(string Container, string DocumentType, string DocumentID, Object DataContract)
{
try
{
string Xml = DataContractSerialization.Serialize(DataContract);
WriteAsync(Container, DocumentType, DocumentID, Xml);
}
catch (Exception ex) { LittleWatson.ReportException(ex); }
}
private Gra ZapisanaRozgrywka()
{
try
{
//return BinarySerialization.DeserializeFromFile<Gra>(SAVE_FILENAME);
return(DataContractSerialization.DeserializeFromFile <Gra>(SAVE_FILENAME));
}
catch (Exception e)
{
return(null);
}
}
/// <summary>Used set the serialized the current page stack (used in the SuspensionManager). </summary>
/// <param name="data">The data. </param>
public void SetNavigationState(string data)
{
var frameDescription = DataContractSerialization.Deserialize <MtFrameDescription>(data, MtSuspensionManager.KnownTypes.ToArray());
_pages = frameDescription.PageStack;
CurrentIndex = frameDescription.CurrentPageIndex;
if (CurrentIndex != -1)
{
ContentGrid.Children.Add(CurrentPage.GetPage(this).InternalPage);
RaisePageOnNavigatedTo(CurrentPage, NavigationMode.Back);
}
}
public static object ReadDataContract(string Container, string DocumentType, string DocumentID, Type DataContractType)
{
try
{
string Xml = Read(Container, DocumentType, DocumentID);
if (Xml == null)
{
return(null);
}
return(DataContractSerialization.Deserialize(Xml, DataContractType));
}
catch (Exception ex) { LittleWatson.ReportException(ex); }
return(null);
}
public static async Task LoadFromFileAsync <T, TIdentity>(this EntityContainer <T, TIdentity> me, string fileName, List <T> defaultList = null)
where T : class, IEntity <TIdentity>
{
var data = await FileUtilities.ReadAllTextAsync(fileName);
if (data != null)
{
me.Collection.Initialize(await DataContractSerialization.DeserializeAsync <List <T> >(data));
}
else if (defaultList != null)
{
me.Collection.Initialize(defaultList);
}
else
{
me.Collection.Clear();
}
}
public static void ReplaceWith(String Xml)
{
try {
if (Xml == null)
{
return;
}
current = (UserSettings)DataContractSerialization.Deserialize(Xml, typeof(UserSettings));
current.VerifyDefaults();
current.DoneLoading = true;
current.Save();
current.UpdateAgent();
current.UpdateReminders();
}catch (Exception ex)
{
LittleWatson.ReportException(ex);
}
}
public static void LoadFromFile <TEntity, TIdentity>(this EntityContainer <TEntity, TIdentity> container, string fileName, List <TEntity> defaultList = null)
where TEntity : class, IEntity <TIdentity>
{
var data = FileUtilities.ReadAllText(fileName);
if (data != null)
{
container.Collection.Initialize(DataContractSerialization.Deserialize <List <TEntity> >(data));
}
else if (defaultList != null)
{
container.Collection.Initialize(defaultList);
}
else
{
container.Collection.Clear();
}
}
public static T LoadOrNew(string name)
{
T result = default(T);
try
{
// Prefer LocalDB
result = (T)LocalDB.ReadDataContract("Settings", typeof(T).Name, "All", typeof(T));
if (result == null)
{
// Fall back to IsolatedStorageSettings
if (IsolatedStorageSettings.ApplicationSettings.TryGetValue(name, out result))
{
return(result);
}
else
{
return(new T());
}
}
#if DEBUG
// in debug, compare LocalDB and IsolatedStorageSettings based retrieval (to validate the LocalDB)
T fromAS = default(T);
if (IsolatedStorageSettings.ApplicationSettings.Contains(name))
{
IsolatedStorageSettings.ApplicationSettings.TryGetValue(name, out fromAS);
}
if (fromAS != null)
{
if (!DataContractSerialization.IsObjectTreeIdentical(result, fromAS))
{
System.Diagnostics.Debugger.Break();
}
}
#endif
}
catch (Exception ex) { LittleWatson.ReportException(ex); }
return(result);
}
private static void RunMapReduce(IEnumerable<string> fileData, DataContractSerialization serialization)
{
using (var connection = DataFlowConnection.CreateDefaultConnection())
{
Console.WriteLine();
Console.WriteLine("Serialization: {0}", serialization);
var timer = Stopwatch.StartNew();
var result = MapReduce.Create<string, Words, Words>(connection, new DataContractOptions(serialization))
.Map<MapTask>()
.Reduce<ReduceTask>()
.Create()
.Execute(fileData);
try
{
var value = result.Value;
timer.Stop();
const string format = @"{0, -30}{1, -30}";
Console.WriteLine(format, "Word:", "Frequency:");
foreach (var word in value)
{
Console.WriteLine(format, word.Value, word.Count);
}
Console.WriteLine("Timing:");
Console.WriteLine("Outer: {0}", timer.Elapsed);
Console.WriteLine("Inner: {0}", result.Timing);
}
catch (JobExecutionException e)
{
Console.WriteLine(e.Message);
foreach (var error in e.Errors.Errors)
{
Console.WriteLine(error.Error);
}
}
}
}
/// <summary>Adds an object which is serialized with <see cref="DataContractSerialization"/>. </summary>
/// <typeparam name="T">The type of the object. </typeparam>
/// <param name="key">The key. </param>
/// <param name="obj">The object. </param>
/// <param name="extraTypes">The additional types. </param>
public void Set <T>(string key, T obj, Type[] extraTypes = null)
{
PageState[key] = DataContractSerialization.Serialize(obj, true, extraTypes);
}
public DataContractVisualizerObjectSource()
{
serializer = new DataContractSerialization();
}
public DataContractOptions(DataContractSerialization serialization, Encoding encoding = null)
{
Serialization = serialization;
Encoding = encoding ?? Encoding.Unicode;
}
public DebuggerSideDataContractVisualizer()
{
IsEditable = true;
Name = VISUALIZER_NAME;
Serializer = new DataContractSerialization();
}
public void ZapiszRozgrywke()
{
//BinarySerialization.SerializeToFile<Gra>(gra, SAVE_FILENAME);
DataContractSerialization.SerializeToFile <Gra>(gra, SAVE_FILENAME);
}
public static void SaveToFile <TEntity, TIdentity>(this EntityContainer <TEntity, TIdentity> container, string fileName)
where TEntity : class, IEntity <TIdentity>
{
FileUtilities.WriteAllText(fileName, DataContractSerialization.Serialize <List <TEntity> >(container.Collection.ToList()));
}
public static async Task SaveToFileAsync <TEntity, TIdentity>(this EntityContainer <TEntity, TIdentity> me, string fileName)
where TEntity : class, IEntity <TIdentity>
{
await FileUtilities.WriteAllTextAsync(fileName, await DataContractSerialization.SerializeAsync(me.Collection.ToList()));
}
