public void SerializingTestChar()
{
var Should = TestHelper.CreateTestChar();
var Current = CharHolderIO.Deserialize(SharedIO.Serialize(Should));
TestHelper.CompareCharHolder(Should, Current);
}
public void SerializingSTDChar()
{
var Should = CharHolderGenerator.CreateCharWithStandardContent();
var Is = CharHolderIO.Deserialize(SharedIO.Serialize(Should));
TestHelper.CompareCharHolder(Should, Is);
}
public void SerializingFileChar()
{
var FileContent = File.ReadAllText(Environment.CurrentDirectory + @"\assets\Flash.SRHChar");
var Expected = CharHolderIO.Deserialize(FileContent);
string fileContent = SharedIO.Serialize(Expected);
var Actual = CharHolderIO.Deserialize(fileContent);
TestHelper.CompareCharHolder(Expected, Actual);
}
private void ExampleChar_Clicked(object sender, EventArgs e)
{
try
{
CharHolderIO.CopyPreSavedCharToCurrentLocation(CharHolderIO.PreSavedChar.ExampleChar);
}
catch (Exception ex)
{
Log.Write("Error reading file", ex);
}
RefreshCharList();
}
public static async Task CharLoadingHandling() //todo was private
{
try
{
if ((Settings.CHARINTEMPSTORE && !FirstStart || Settings.LOAD_CHAR_ON_START && FirstStart) && Model.MainObject == null || Settings.FORCE_LOAD_CHAR_ON_START)
{
FileInfo info = Settings.LAST_SAVE_INFO;
Model.CharInProgress = info;
CharHolder TMPChar = await CharHolderIO.Load(info);
if (TMPChar.FileInfo.Directory.FullName.Contains(await SharedIO.CurrentIO.GetCompleteInternPath(Place.Temp)))
{
CharHolderIO.SaveAtCurrentPlace(TMPChar);
}
CharHolder OldChar = Model.MainObject;
Model.MainObject = TMPChar;
Settings.COUNT_LOADINGS++;
if (OldChar != null)
{
try
{
CharHolderIO.SaveAtOriginPlace(OldChar);
}
catch (Exception ex)
{
Log.Write(AppResources.Error_FileActivation, ex);
}
}
if (Settings.FORCE_LOAD_CHAR_ON_START)
{
Log.Write(AppResources.Info_Char_Loaded_File);
}
else
{
Log.Write(AppResources.Info_Char_Loaded_Start);
}
}
}
catch (Exception ex)
{ Log.Write("Could not", ex, logType: LogType.Error); }
finally
{
Model.CharInProgress = null;
Settings.FORCE_LOAD_CHAR_ON_START = false;
FirstStart = false;
Settings.LAST_SAVE_INFO = null;
Settings.CHARINTEMPSTORE = false;
Model.RequestNavigation(ProjectPages.Char);
}
}
private async Task LoadFileInBackgroundAsync(ExtendetFileInfo charfile, Action <CharHolder> afterLoad = null)
{
MainPage.Instance.EnableBusy();
try
{
CharHolder newchar = await CharHolderIO.Load(charfile);
AppModel.Instance.MainObject = (newchar);
AppModel.Instance.RequestNavigation(ProjectPages.Char);
afterLoad?.Invoke(newchar);
}
catch (Exception ex)
{
Log.Write("Error reading file", ex);
}
MainPage.Instance.DisableBusy();
}
private static void LoadFileInBackgroundSynchron(ExtendetFileInfo charfile, Action <CharHolder> afterLoad = null)
{
MainPage.Instance.EnableBusy();
BackgroundWorker b = new BackgroundWorker();
b.DoWork += async(object sender, DoWorkEventArgs e) =>
{
if (e.Argument is ExtendetFileInfo charfile)
{
System.Threading.Thread.Sleep(1000);
try
{
e.Result = await CharHolderIO.Load(charfile);
}
catch (Exception ex)
{
Log.Write("Error reading file", ex);
}
}
};
b.RunWorkerCompleted += (object sender, RunWorkerCompletedEventArgs e) =>
{
if (e.Result is CharHolder newchar)
{
AppModel.Instance.MainObject = newchar;
System.Diagnostics.Debug.WriteLine(" Admin1");
AppModel.Instance.RequestNavigation(ProjectPages.Char);
System.Diagnostics.Debug.WriteLine(" Admin2");
afterLoad?.Invoke(newchar);
System.Diagnostics.Debug.WriteLine(" Admin3");
}
MainPage.Instance.DisableBusy();
System.Diagnostics.Debug.WriteLine(" Admin4");
};
try
{
b.RunWorkerAsync(charfile);
}
catch (InvalidOperationException)
{
//TODO Report
}
}
public void TestLoadAndSave_N()
{
AppModel.Initialize();
SettingsModel.Initialize();
CharHolder Char = new CharHolder();
var H1 = new Handlung()
{
Bezeichner = "Handlung1"
};
Char.Add(H1);
Char.Add(new Item()
{
Bezeichner = "Item"
});
H1.Value.Connected.Add(Char.CTRLAttribut.Charisma.Value);
H1.Value.Connected.Add(Char.CTRLItem[0].Value);
string Ser = SharedIO.Serialize(Char);
TestNewConnections(CharHolderIO.Deserialize(Ser));
}
public static CharHolder SaveOpen(CharHolder Char)
{
return(CharHolderIO.Deserialize(SharedIO.Serialize(Char)));
}
