public override void WriteJsonValueCore(XmlWriterDelegator jsonWriter, object obj, XmlObjectSerializerWriteContextComplexJson context, RuntimeTypeHandle declaredTypeHandle)
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(Type.GetTypeFromHandle(declaredTypeHandle),
GetKnownTypesFromContext(context, (context == null) ? null : context.SerializerKnownTypeList), 1, false, false); // maxItemsInObjectGraph // ignoreExtensionDataObject // preserveObjectReferences
MemoryStream memoryStream = new MemoryStream();
dataContractSerializer.WriteObject(memoryStream, obj);
memoryStream.Position = 0;
string serialized = new StreamReader(memoryStream).ReadToEnd();
jsonWriter.WriteString(serialized);
}
/// <summary>
/// Generates vault creds file content for backup Vault
/// </summary>
/// <param name="cert">management certificate</param>
/// <param name="subscriptionId">subscription Id</param>
/// <param name="acsNamespace">acs namespace</param>
/// <returns>xml file in string format</returns>
private string GenerateVaultCredsForBackup(X509Certificate2 cert, string subscriptionId,
VaultCertificateResponse vaultCertificateResponse)
{
using (var output = new MemoryStream())
{
using (var writer = XmlWriter.Create(output, GetXmlWriterSettings()))
{
ResourceCertificateAndAadDetails aadDetails = vaultCertificateResponse.Properties as ResourceCertificateAndAadDetails;
RSBackupVaultAADCreds vaultCreds = new RSBackupVaultAADCreds()
{
SubscriptionId = subscriptionId,
ResourceName = Vault.Name,
ManagementCert = CertUtils.SerializeCert(cert, X509ContentType.Pfx),
ResourceId = aadDetails.ResourceId.Value,
AadAuthority = aadDetails.AadAuthority,
AadTenantId = aadDetails.AadTenantId,
ServicePrincipalClientId = aadDetails.ServicePrincipalClientId,
IdMgmtRestEndpoint = aadDetails.AzureManagementEndpointAudience,
ProviderNamespace = PSRecoveryServicesClient.ProductionRpNamespace,
ResourceGroup = Vault.ResourceGroupName,
Location = Vault.Location,
Version = VaultCredentialVersionAad,
ResourceType = RecoveryServicesVaultType,
AgentLinks = GetAgentLinks()
};
DataContractSerializer serializer = new DataContractSerializer(typeof(RSBackupVaultAADCreds));
serializer.WriteObject(writer, vaultCreds);
WriteDebug(string.Format(CultureInfo.InvariantCulture, Resources.BackupVaultSerialized));
}
return(Encoding.UTF8.GetString(output.ToArray()));
}
}
/// <summary>
/// Save all currently registered hot key sequences and their associated actions
/// to the user's local application data directory.
/// </summary>
public void Save()
{
var dirPath = Path.GetDirectoryName(dataPath);
if (dirPath == null)
{
MessageWindow.Show($"Cannot find save path: {dataPath}");
return;
}
if (!Directory.Exists(dirPath))
{
Directory.CreateDirectory(dirPath);
}
var map = new HotKeyCollection(keys.Values);
var settings = new XmlWriterSettings {
Indent = true
};
try
{
using (XmlWriter writer = XmlWriter.Create(dataPath, settings))
{
var serializer = new DataContractSerializer(typeof(HotKeyCollection));
serializer.WriteObject(writer, map);
writer.Flush();
writer.Close();
}
}
catch (Exception exc)
{
MessageWindow.Show(string.Format(Resx.HotKeysNotSaved, exc.Message));
}
}
public void DataContractSerializerDuplicateNameEnumTest()
{
MemoryStream ms = new MemoryStream();
var s = new DataContractSerializer(typeof(DuplicateEnumNameTestClass));
ExceptionAssert.Throws <InvalidDataContractException>(() =>
{
s.WriteObject(ms, new DuplicateEnumNameTestClass
{
Value = DuplicateNameEnum.foo_bar,
Value2 = DuplicateNameEnum2.foo_bar_NOT_USED
});
string xml = @"<DuplicateEnumNameTestClass xmlns=""http://schemas.datacontract.org/2004/07/Newtonsoft.Json.Tests.Converters"" xmlns:i=""http://www.w3.org/2001/XMLSchema-instance"">
<Value>foo_bar</Value>
<Value2>foo_bar</Value2>
</DuplicateEnumNameTestClass>";
var o = (DuplicateEnumNameTestClass)s.ReadObject(new MemoryStream(Encoding.UTF8.GetBytes(xml)));
Assert.AreEqual(DuplicateNameEnum.foo_bar, o.Value);
Assert.AreEqual(DuplicateNameEnum2.FooBar, o.Value2);
}, "Type 'Newtonsoft.Json.Tests.Converters.DuplicateNameEnum' contains two members 'foo_bar' 'and 'FooBar' with the same name 'foo_bar'. Multiple members with the same name in one type are not supported. Consider changing one of the member names using EnumMemberAttribute attribute.");
}
public void WriteXml_WithNoValidationErrors()
{
// Arrange
var problemDetails = new ValidationProblemDetails
{
Title = "Some title",
Detail = "Some detail",
Extensions =
{
["key1"] = "Test Value 1",
["[Key2]"] = "Test Value 2"
},
};
var wrapper = new ValidationProblemDetailsWrapper(problemDetails);
var outputStream = new MemoryStream();
var expectedContent = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<problem xmlns=\"urn:ietf:rfc:7807\">" +
"<detail>Some detail</detail>" +
"<title>Some title</title>" +
"<key1>Test Value 1</key1>" +
"<_x005B_Key2_x005D_>Test Value 2</_x005B_Key2_x005D_>" +
"</problem>";
// Act
using (var xmlWriter = XmlWriter.Create(outputStream))
{
var dataContractSerializer = new DataContractSerializer(wrapper.GetType());
dataContractSerializer.WriteObject(xmlWriter, wrapper);
}
outputStream.Position = 0;
var res = new StreamReader(outputStream, Encoding.UTF8).ReadToEnd();
// Assert
Assert.Equal(expectedContent, res);
}
public static void SaveProperties(IEnumerable <IConfigurable> configurables, String targetFile)
{
List <ExecutableConfiguration> configs = new List <ExecutableConfiguration>();
foreach (var configuable in configurables)
{
IEnumerable <IProperty> properties = configuable.GetProperties();
if (properties.Count() > 0)
{
var config = new ExecutableConfiguration(configuable.GetType().ToString(), properties.ToList(), ((IExecutable)configuable).Name);
configs.Add(config);
}
}
using (FileStream fileStream = new FileStream(targetFile, FileMode.Create))
{
var writer = XmlWriter.Create(fileStream, new XmlWriterSettings {
Indent = true
});
DataContractSerializer ser = new DataContractSerializer(serializedType);
ser.WriteObject(writer, configs);
writer.Close();
}
}
public void ModelBaseCollection_SerializationTest1()
{
var people = new SimplePersonCollection();
people.FirstName = "Tom";
people.LastName = "Jones";
people.Add(new SimplePerson());
people.Add(new SimplePerson());
people.Add(new SimplePerson());
var stream = new MemoryStream();
var serializer = new DataContractSerializer(typeof(SimplePersonCollection));
serializer.WriteObject(stream, people);
stream.Position = 0;
var newPeople = (SimplePersonCollection)serializer.ReadObject(stream);
//Property serialization isn't supported by the data contract serializer
//Assert.AreEqual(people.FirstName, newPeople.FirstName);
//Assert.AreEqual(people.LastName, newPeople.LastName);
//Assert.AreEqual(people.FullName, newPeople.FullName);
Assert.AreEqual(people.Count, newPeople.Count);
}
void SerializeProperties(object properties)
{
// Serialize property dictionary to local storage
// Make sure to use Internal
using var stringWriter = new StringWriter();
using var xmlWriter = XmlWriter.Create(stringWriter);
try
{
var dcs = new DataContractSerializer(typeof(Dictionary <string, object>));
dcs.WriteObject(xmlWriter, properties);
xmlWriter.Flush();
var str = stringWriter.ToString();
SaveSerialized(str);
}
catch (Exception e)
{
Debug.WriteLine("Could not serialize properties: " + e.Message);
Forms.MauiContext?.CreateLogger <Deserializer>()?.LogWarning(e, "Exception while writing Application properties");
return;
}
}
/// <summary>
/// Сохранение текущего <see cref="SessionState"/>. Любые экземпляры <see cref="Frame"/>,
/// зарегистрированные с помощью <see cref="RegisterFrame"/>, также сохранят свой текущий
/// стек навигации, который, в свою очередь, предоставляет их активной <see cref="Page"/> возможность
/// сохранения своего состояния.
/// </summary>
/// <returns>Асинхронная задача, отражающая сохранение состояния сеанса.</returns>
public static async Task SaveAsync()
{
try
{
// Сохранение состояния навигации для всех зарегистрированных фреймов
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}
// Синхронная сериализация состояния сеанса с целью запрета асинхронного доступа к общему
// состоянию
MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary <string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);
// Получение выходного потока для файла SessionState и асинхронная запись состояния
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(0, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
await fileStream.FlushAsync();
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}
/// <summary>
/// Serialize the target object to an Xml string using DataContractSerializer
/// <param name="target">object to be serialized.</param>
/// <param name="formatted">indicates whether the serialized output needs to be formatted or not.</param>
/// <returns>Serialized string.</returns>
public override string Serialize(object target, bool formatted = false)
{
if (target == null)
{
return(string.Empty);
}
using (MemoryStream memoryStream = new MemoryStream())
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.Unicode;
settings.OmitXmlDeclaration = false;
if (formatted)
{
settings.Indent = true;
}
else
{
settings.Indent = false;
}
using (XmlWriter xmlWriter = XmlWriter.Create(memoryStream, settings))
using (XmlDictionaryWriter xmlDictionaryWriter = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter))
using (StreamReader streamReader = new StreamReader(memoryStream))
{
DataContractSerializer dataContractSerializer = new DataContractSerializer(target.GetType());
dataContractSerializer.WriteObject(xmlDictionaryWriter, target);
xmlDictionaryWriter.Flush();
memoryStream.Seek(0, SeekOrigin.Begin);
memoryStream.Flush();
return(streamReader.ReadToEnd());
}
}
}
/// <summary>
/// Saves the data.
/// </summary>
public void Save()
{
if (!IsSaved)
{
// Create serializer.
var serializer = new DataContractSerializer(typeof(Storage));
// Create reader.
bool fileDoesnotExist;
using (var streamWriter = new StreamWriter(FileUtil.GetStorageFileName(out fileDoesnotExist)))
{
using (var xmlWriter = XmlWriter.Create(streamWriter))
{
if (xmlWriter != null)
{
// Serialize.
serializer.WriteObject(xmlWriter, Storage);
}
}
}
IsSaved = true;
}
}
public void SaveScopeVariables(string fileName)
{
var scopeVars = GetScopeVariables();
if (scopeVars.Count == 0)
{
return;
}
using (var fs = new FileStream(fileName, FileMode.Create)) {
using (var xmlWriter = new XmlTextWriter(fs, System.Text.Encoding.UTF8)) {
xmlWriter.Formatting = Formatting.Indented;
using (var writer = XmlDictionaryWriter.CreateDictionaryWriter(xmlWriter)) {
var serializer = new DataContractSerializer(typeof(Dictionary <string, object>));
try {
serializer.WriteObject(writer, scopeVars);
} catch (Exception ex) {
Log.Write(ex);
}
}
}
}
}
public static string ToXML(object obj)
{
var settings = new XmlWriterSettings {
Indent = true
};
using (MemoryStream memoryStream = new MemoryStream())
using (StreamReader reader = new StreamReader(memoryStream))
using (XmlWriter writer = XmlWriter.Create(memoryStream, settings))
{
DataContractSerializer serializer =
new DataContractSerializer
(obj.GetType()
, new DataContractSerializerSettings()
{
DataContractSurrogate = new ImmutableSurrogateSerializer()
}
);
serializer.WriteObject(writer, obj);
writer.Flush();
memoryStream.Position = 0;
return(reader.ReadToEnd());
}
}
public void usingDataContractSerializer()
{
PersonDataContract p = new PersonDataContract
{
Id = 1,
Name = "John Doe"
};
//You need to specify a Stream object that has the input or output
//when serializing or deserializing an object
using (Stream stream = new FileStream("data.xml", FileMode.Create))
{
DataContractSerializer ser = new DataContractSerializer(typeof(PersonDataContract));
ser.WriteObject(stream, p);
Console.WriteLine(stream);
}
using (Stream stream = new FileStream("data.xml", FileMode.Open))
{
DataContractSerializer ser = new DataContractSerializer(typeof(PersonDataContract));
PersonDataContract result = (PersonDataContract)ser.ReadObject(stream);
Console.WriteLine(result.ToString());
}
}
private static void DataContractSerializeCycles()
{
var firstNode = new Node <int> {
Value = 1
};
var secondNode = new Node <int> {
Value = 2
};
firstNode.Next = secondNode;
secondNode.Previous = firstNode;
var settings = new DataContractSerializerSettings()
{
PreserveObjectReferences = true
};
using (var stream = File.Create(path))
{
var serializer = new DataContractSerializer(typeof(Node <int>), settings);
serializer.WriteObject(stream, firstNode);
}
}
private void saveAsProjectMenuItem_Click(object sender, RoutedEventArgs e)
{
System.Windows.Forms.SaveFileDialog dlg = new System.Windows.Forms.SaveFileDialog();
dlg.Filter = "Файлы конфигурации (.cfg)|*.cfg";
if (dlg.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
try
{
using (FileStream fs = File.Open(dlg.FileName, FileMode.Create))
{
Current.Root.Name = dlg.FileName;
Current.ShortName = new FileInfo(dlg.FileName).Name;
DataContractSerializer formatter = new DataContractSerializer(typeof(Project));
formatter.WriteObject(fs, Current);
}
Current.IsChanged = false;
}
catch (Exception ex)
{
AppLogger.Log($"SaveAs Project as {dlg.FileName} Exception: {ex}{Environment.NewLine}Trace: {ex.StackTrace}");
MessageBox.Show("Ошибка сохранения проекта. Возможно, файл проекта был поврежден или изменен извне.");
}
}
}
/// <summary>
/// Emits all the testing coverage related output files.
/// </summary>
/// <param name="report">TestReport containing CoverageInfo</param>
/// <param name="directory">Output directory name, unique for this run</param>
/// <param name="file">Output file name</param>
private static void EmitTestingCoverageOutputFiles(TestReport report, string directory, string file)
{
var codeCoverageReporter = new ActivityCoverageReporter(report.CoverageInfo);
var filePath = $"{directory}{file}";
string graphFilePath = $"{filePath}.dgml";
Output.WriteLine($"..... Writing {graphFilePath}");
codeCoverageReporter.EmitVisualizationGraph(graphFilePath);
string coverageFilePath = $"{filePath}.coverage.txt";
Output.WriteLine($"..... Writing {coverageFilePath}");
codeCoverageReporter.EmitCoverageReport(coverageFilePath);
string serFilePath = $"{filePath}.sci";
Output.WriteLine($"..... Writing {serFilePath}");
using (var fs = new FileStream(serFilePath, FileMode.Create))
{
var serializer = new DataContractSerializer(typeof(CoverageInfo));
serializer.WriteObject(fs, report.CoverageInfo);
}
}
public void TradeXml()
{
var obj = TradeGenerator.NewSwap();
var serializer = new DataContractSerializer(obj.GetType());
var settings = new XmlWriterSettings();
settings.Encoding = new System.Text.UTF8Encoding(false);
var sw = new StringWriter();
using (var xw = XmlWriter.Create(sw))
{
serializer.WriteObject(xw, obj);
}
Console.WriteLine(sw.ToString());
var rw = XmlReader.Create(new StringReader(sw.ToString()));
var trade = (Trade)serializer.ReadObject(rw);
Assert.AreEqual(obj.Legs[0].Cashflows[0].PaymentDate, trade.Legs[0].Cashflows[0].PaymentDate);
Assert.AreEqual(obj.Legs[1].Cashflows[1].StartDate, trade.Legs[1].Cashflows[1].StartDate);
}
private static String ToXml(Object o)
{
if (o != null)
{
DataContractSerializer serializer = new DataContractSerializer(o.GetType());
using (StringWriter stringWriter = new StringWriter())
{
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter, new XmlWriterSettings()
{
Indent = true
}))
{
serializer.WriteObject(xmlWriter, o);
}
return(stringWriter.ToString());
}
}
else
{
return("(null)");
}
}
/// <summary>
/// 保存当前 <see cref="SessionState"/>。任何 <see cref="Frame"/> 实例
/// (已向 <see cref="RegisterFrame"/> 注册)都还将保留其当前的
/// 导航堆栈，从而使其活动 <see cref="Page"/> 可以
/// 保存其状态。
/// </summary>
/// <returns>反映会话状态保存时间的异步任务。</returns>
public static async Task SaveAsync()
{
try
{
// 保存所有已注册框架的导航状态
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}
// 以同步方式序列化会话状态以避免对共享
// 状态
MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary <string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);
// 获取 SessionState 文件的输出流并以异步方式写入状态
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(0, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
await fileStream.FlushAsync();
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}
public void SerializationXml2()
{
Vector4D v1 = new Vector4D(0.1, -0.2, 2, 40);
Vector4D v2;
string fileName = "SerializationVector4D_DataContractSerializer.xml";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
var serializer = new DataContractSerializer(typeof(Vector4D));
using (var stream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write))
using (var writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
serializer.WriteObject(writer, v1);
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (var reader = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas()))
v2 = (Vector4D)serializer.ReadObject(reader);
Assert.AreEqual(v1, v2);
}
public void XmlSerialization()
{
var serializer = new DataContractSerializer(typeof(Rule));
string text;
using (var writer = new StringWriter())
{
Rule rule = Rule.Create("Customer.LastName", mreOperator.Equal, "Doe")
& (Rule.Create("Customer.FirstName", mreOperator.Equal, "John")
| Rule.Create("Customer.FirstName", mreOperator.Equal, "Jane"));
using (var xw = XmlWriter.Create(writer))
serializer.WriteObject(xw, rule);
text = writer.ToString();
}
Rule newRule; // add breakpoint here, to view XML in text.
using (var reader = new StringReader(text))
using (var xr = XmlReader.Create(reader))
{
newRule = (Rule)serializer.ReadObject(xr);
}
var order = ExampleUsage.GetOrder();
MRE engine = new MRE();
var fakeName = engine.CompileRule <Order>(newRule);
bool passes = fakeName(order);
Assert.IsTrue(passes);
order.Customer.FirstName = "Philip";
passes = fakeName(order);
Assert.IsFalse(passes);
}
public static void SaveConversation(RosterItem item)
{
/// Save this conversation so it can be restored later... save it under the JID name
string strFilename = string.Format("{0}_conversation.item", item.JID.BareJID);
using (IsolatedStorageFile storage = IsolatedStorageFile.GetUserStoreForApplication())
{
// Load from storage
IsolatedStorageFileStream location = new IsolatedStorageFileStream(strFilename, System.IO.FileMode.Create, storage);
DataContractSerializer ser = new DataContractSerializer(typeof(System.Net.XMPP.Conversation));
try
{
ser.WriteObject(location, item.Conversation);
}
catch (Exception)
{
}
location.Close();
}
}
async public static Task SaveModelAsync()
{
//serialize the model object to a memory stream
DataContractSerializer dcs = new DataContractSerializer(Model.GetType());
//write model string to file
var file = await ApplicationData.Current
.LocalFolder
.CreateFileAsync("corralmodel.xml",
CreationCollisionOption.OpenIfExists);
var transaction = await file.OpenTransactedWriteAsync();
var opn = transaction.Stream;
var ostream = opn.GetOutputStreamAt(0);
var stream = ostream.AsStreamForWrite();
dcs.WriteObject(stream, Model);
stream.Flush();
stream.Dispose();
await transaction.CommitAsync();
transaction.Dispose();
}
/// <summary>
/// Guardar el <see cref="SessionState"/> actual. Toda instancia de <see cref="Frame"/>
/// registrada en <see cref="RegisterFrame"/> también conservará la
/// pila de navegación actual que, a su vez, ofrece a la <see cref="Page"/> activa la oportunidad
/// de guardar su estado.
/// </summary>
/// <returns>Tarea asincrónica que refleja cuándo se ha guardado el estado de la sesión.</returns>
public static async Task SaveAsync()
{
try
{
// Guardar el estado de navegación para todos los marcos registrados
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}
// Serializar el estado de la sesión de forma sincrónica para impedir el acceso asincrónico al estado
// compartido
MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary <string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);
// Obtener un flujo de salida para el archivo SessionState y escribir el estado de forma asincrónica
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(0, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
await fileStream.FlushAsync();
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}
public void SerializationXml2()
{
Matrix22D m1 = new Matrix22D(12, 23, 45, 67);
Matrix22D m2;
string fileName = "SerializationMatrix22D_DataContractSerializer.xml";
if (File.Exists(fileName))
{
File.Delete(fileName);
}
var serializer = new DataContractSerializer(typeof(Matrix22D));
using (var stream = new FileStream(fileName, FileMode.CreateNew, FileAccess.Write))
using (var writer = XmlDictionaryWriter.CreateTextWriter(stream, Encoding.UTF8))
serializer.WriteObject(writer, m1);
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
using (var reader = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas()))
m2 = (Matrix22D)serializer.ReadObject(reader);
Assert.AreEqual(m1, m2);
}
private void SaveIssuesToStorageStore()
{
var loadedIssues = m_IssuesVm.Issues.Where(i => i.IsLoaded);
if (loadedIssues.Any(i => i.IsDeleted || i.IsDirty))
{
using (var storage = m_Model.OpenStorage(STORAGE_NAME, AccessType_e.Write))
{
using (var stream = storage.TryOpenStream(ISSUES_SUMMARIES_STREAM_NAME, true))
{
var ser = new DataContractSerializer(typeof(IssueInfo[]));
ser.WriteObject(stream, m_IssuesVm.Issues
.Select(i => i.Issue.GetInfo()).ToArray());
}
using (var issuesStore = storage.TryOpenStorage(ISSUES_SUB_STORAGE_NAME, true))
{
foreach (var removedIssue in loadedIssues.Where(i => i.IsDeleted))
{
issuesStore.RemoveSubElement(removedIssue.Id.ToString());
}
foreach (var modifiedIssue in loadedIssues.Where(i => !i.IsDeleted && i.IsDirty))
{
using (var stream = issuesStore.TryOpenStream(modifiedIssue.Id.ToString(), true))
{
var ser = new DataContractSerializer(typeof(Issue));
ser.WriteObject(stream, modifiedIssue.Issue);
}
}
}
}
}
m_IssuesVm.FlushChanges();
}
private void WriteToXml(Entity entity, string folder, bool association)
{
var lateBoundSerializer = new DataContractSerializer(typeof(Entity));
var namesToUse = association ? "association" : entity.GetStringField(XrmRecordService.GetPrimaryField(entity.LogicalName).Left(15));
if (!namesToUse.IsNullOrWhiteSpace())
{
var invalidChars = Path.GetInvalidFileNameChars();
foreach (var character in invalidChars)
{
namesToUse = namesToUse.Replace(character, '_');
}
}
var fileName = string.Format(@"{0}_{1}_{2}", entity.LogicalName, entity.Id, namesToUse);
fileName = fileName.Replace('-', '_');
//ensure dont exceed max filename length
fileName = string.Format(@"{0}\{1}", folder, fileName).Left(240);
fileName = fileName + ".xml";
using (var fileStream = new FileStream(fileName, FileMode.Create))
{
lateBoundSerializer.WriteObject(fileStream, entity);
}
}
public void HandleReport(SessionInfo report)
{
string dir = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "sessionreports");
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
string filePath = Path.Combine(dir, new DateTime(report.Timestamp, DateTimeKind.Utc).ToString("yyyyMMdd_HHmmss") + "_" + report.TrackName + "_" + report.SessionName + ".xml");
DataContractSerializer serializer = new DataContractSerializer(typeof(SessionInfo));
XmlWriterSettings settings = new XmlWriterSettings()
{
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(filePath, settings))
{
serializer.WriteObject(writer, report);
}
}
public void SerializerDynamicInvoke ()
{
var a = new DingusSyncData ();
a.Aircraft = new AircraftDTO[] { new AircraftDTO () { } };
a.AircraftTypes = new AircraftTypeDTO[] { new AircraftTypeDTO () };
a.Airlines= new AirlineDTO[] { new AirlineDTO () };
a.Airports= new AirportDTO[] { new AirportDTO() };
a.Approaches= new ApproachDTO[] { new ApproachDTO() };
a.ApproachesLegs= new ApproachesLegDTO[] { new ApproachesLegDTO() };
a.Binaries= new BinaryCatalogDTO[] { new BinaryCatalogDTO() };
a.Crews= new CrewDTO[] { new CrewDTO() };
a.Days= new DayDTO[] { new DayDTO() };
a.EmploymentEvents= new EmploymentEventDTO[] { new EmploymentEventDTO() };
a.Events= new EventDTO[] { new EventDTO() };
a.FlightDataInspection = new DataInspection ();
a.GlobalSettings= new GlobalSettingDTO[] { new GlobalSettingDTO() };
a.Hotels= new HotelDTO[] { new HotelDTO() };
a.Legs= new LegDTO[] { new LegDTO() };
a.Notes= new NoteDTO[] { new NoteDTO() };
a.PayperiodEvents= new PayperiodEventDTO[] { new PayperiodEventDTO() };
a.PayrollCategories= new PayrollCategoryDTO[] { new PayrollCategoryDTO() };
a.Payrolls= new PayrollDTO[] { new PayrollDTO() };
a.Performances= new PerformanceDTO[] { new PerformanceDTO() };
a.Positions= new PositionDTO[] { new PositionDTO() };
a.ReglatoryOperationTypes= new ReglatoryOperationTypeDTO[] { new ReglatoryOperationTypeDTO() };
a.Trips= new TripDTO[] { new TripDTO() };
a.UserSettings= new UserSettingDTO[] { new UserSettingDTO() };
Console.WriteLine ("Size is: {0}", global::System.Runtime.InteropServices.Marshal.SizeOf(typeof(IntPtr)));
using (var ms = new MemoryStream ()) {
DataContractSerializer serializer = new DataContractSerializer (typeof(DingusSyncData));
serializer.WriteObject (ms, a);
ms.Position = 0;
var b = serializer.ReadObject (ms);
}
}
/// <summary>
/// Save the current <see cref="SessionState"/>. Any <see cref="Frame"/> instances
/// registered with <see cref="RegisterFrame"/> will also preserve their current
/// navigation stack, which in turn gives their active <see cref="Page"/> an opportunity
/// to save its state.
/// </summary>
/// <returns>An asynchronous task that reflects when session state has been saved.</returns>
public static async Task SaveAsync()
{
try
{
// Save the navigation state for all registered frames
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}
// Serialize the session state synchronously to avoid asynchronous access to shared
// state
MemoryStream sessionData = new MemoryStream();
DataContractSerializer serializer = new DataContractSerializer(typeof(Dictionary <string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);
// Get an output stream for the SessionState file and write the state asynchronously
StorageFile file = await ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename, CreationCollisionOption.ReplaceExisting);
using (Stream fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(0, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
await fileStream.FlushAsync();
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}
static void Main(string[] args)
{
var input = new TestDto {
Name = " with leading whitespace"
};
byte[] data;
{
var seralizer = new DataContractSerializer(typeof(TestDto));
using (var mem = new MemoryStream())
{
seralizer.WriteObject(mem, input);
data = mem.ToArray();
}
}
{
var seralizer = new DataContractSerializer(typeof(TestDto));
using (var mem = new MemoryStream(data))
{
var output = (TestDto)seralizer.ReadObject(mem);
Console.WriteLine(">{0}<", output.Name);
}
}
}
private static void Test2()
{
#if NETCORE
//ProtoBufTest.Test();
{
object exobj = null;
try
{
var b = 3;
b = 0;
var c = 2 / b;
}
catch (Exception exs)
{
exobj = exs;
}
//var ex = new Exception("test ex");
var ex = exobj;
//var ex = new ServiceTest.Contract.Product
//{
// Id = 223,
// Name = "abc book",
// Category = "Book",
// ListDate = DateTime.Now,
// Price = 34,
// Tags = new List<string>
// {
// "book",
// "tech",
// "new"
// }
//};
{
try
{
var setting = new JsonSerializerSettings
{
Formatting = Formatting.Indented,
ContractResolver = new SerializeContractResolver()
};
var json = JsonConvert.SerializeObject(ex, setting);
Console.WriteLine(json);
var dex = JsonConvert.DeserializeObject(json, ex.GetType(), setting);
}
catch (Exception)
{
throw;
}
}
var dcs = new DataContractSerializer(ex.GetType());
var ms = new MemoryStream();
dcs.WriteObject(ms, ex);
ms.Position = 0;
var dex3 = dcs.ReadObject(ms);
var xml = Encoding.UTF8.GetString(ms.ToArray());
var jss = new System.Runtime.Serialization.Json.DataContractJsonSerializer(ex.GetType());
var jsms = new MemoryStream();
jss.WriteObject(jsms, ex);
ms.Position = 0;
var dexjs = dcs.ReadObject(ms);
var jsss = Encoding.UTF8.GetString(ms.ToArray());
var product = new ServiceTest.Contract.Product
{
Id = 223,
Name = "abc book",
Category = "Book",
ListDate = DateTime.Now,
Price = 34,
Tags = new List<string>
{
"book",
"tech",
"new"
}
};
var xmlSeriaizer = new System.Xml.Serialization.XmlSerializer(product.GetType());
var stringWriter = new StringWriter();
//var xmlWriter = new XmlWriter();
xmlSeriaizer.Serialize(stringWriter, (object)product);
}
#endif
}
/// <summary>
/// Save the current <see cref="SessionState" />. Any <see cref="Frame" /> instances
/// registered with <see cref="RegisterFrame" /> will also preserve their current
/// navigation stack, which in turn gives their active <see cref="Page" /> an opportunity
/// to save its state.
/// </summary>
/// <returns>An asynchronous task that reflects when session state has been saved.</returns>
public static async Task SaveAsync()
{
try
{
// Save the navigation state for all registered frames
foreach (var weakFrameReference in _registeredFrames)
{
Frame frame;
if (weakFrameReference.TryGetTarget(out frame))
{
SaveFrameNavigationState(frame);
}
}
// Serialize the session state synchronously to avoid asynchronous access to shared
// state
var sessionData = new MemoryStream();
var serializer = new DataContractSerializer(typeof (Dictionary<string, object>), _knownTypes);
serializer.WriteObject(sessionData, _sessionState);
// Get an output stream for the SessionState file and write the state asynchronously
var file =
await
ApplicationData.Current.LocalFolder.CreateFileAsync(sessionStateFilename,
CreationCollisionOption.ReplaceExisting);
using (var fileStream = await file.OpenStreamForWriteAsync())
{
sessionData.Seek(0, SeekOrigin.Begin);
await sessionData.CopyToAsync(fileStream);
}
}
catch (Exception e)
{
throw new SuspensionManagerException(e);
}
}