Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
76 changes: 76 additions & 0 deletions CoreRemoting.Tests/NeoBinarySerializationTests.cs
Original file line number Diff line number Diff line change
Expand Up @@ -609,6 +609,82 @@ public void NeoBinarySerializerAdapter_should_serialize_untyped_DataTable_as_Dif
deserializedRow["UserName", DataRowVersion.Current]);
}

[Fact]
public void NeoBinarySerializerAdapter_should_serialize_DataSet_larger_than_initial_buffer_as_DiffGram()
{
const int rowCount = 2000;
var serializer = new NeoBinarySerializerAdapter();

var parentTable = new DataTable("ParentTable");
parentTable.Columns.Add("Id", typeof(int));
parentTable.Columns.Add("Name", typeof(string)).DefaultValue = DBNull.Value;
parentTable.PrimaryKey = [parentTable.Columns["Id"]!];

var childTable = new DataTable("ChildTable");
childTable.Columns.Add("Id", typeof(int));
childTable.Columns.Add("ParentId", typeof(int));
childTable.Columns.Add("Amount", typeof(decimal));

var originalDataSet = new DataSet("LargeDataSet");
originalDataSet.Tables.Add(parentTable);
originalDataSet.Tables.Add(childTable);
originalDataSet.Relations.Add("ParentChild", parentTable.Columns["Id"]!, childTable.Columns["ParentId"]!);

for (var index = 0; index < rowCount; index++)
{
// Umlauts and the euro sign are multi-byte in UTF-8 and guard the text encoding of the XML.
parentTable.Rows.Add(index, index % 3 == 0 ? DBNull.Value : $"Müller € {index}");
childTable.Rows.Add(index, index, index * 1.5m);
}

originalDataSet.AcceptChanges();
parentTable.Rows[5]["Name"] = "Changed";

var serialized = serializer.Serialize(originalDataSet);
var deserializedDataSet = serializer.Deserialize<DataSet>(serialized);

var deserializedParentTable = deserializedDataSet.Tables["ParentTable"]!;
var deserializedChildTable = deserializedDataSet.Tables["ChildTable"]!;

Assert.Equal(rowCount, deserializedParentTable.Rows.Count);
Assert.Equal(rowCount, deserializedChildTable.Rows.Count);
Assert.Single(deserializedDataSet.Relations);
Assert.Equal(DataRowState.Modified, deserializedParentTable.Rows[5].RowState);
Assert.Equal("Changed", deserializedParentTable.Rows[5]["Name", DataRowVersion.Current]);
Assert.Equal("Müller € 5", deserializedParentTable.Rows[5]["Name", DataRowVersion.Original]);
Assert.Equal(DBNull.Value, deserializedParentTable.Rows[0]["Name"]);
Assert.Equal("Müller € 1999", deserializedParentTable.Rows[rowCount - 1]["Name"]);
Assert.Equal(1999 * 1.5m, deserializedChildTable.Rows[rowCount - 1]["Amount"]);
}

[Fact]
public void NeoBinarySerializerAdapter_should_serialize_DataTable_larger_than_initial_buffer_as_DiffGram()
{
const int rowCount = 2000;
var serializer = new NeoBinarySerializerAdapter();

var originalTable = new DataTable("LargeTable");
originalTable.Columns.Add("UserName", typeof(string));
originalTable.Columns.Add("Age", typeof(short));

for (var index = 0; index < rowCount; index++)
{
originalTable.Rows.Add($"Müller € {index}", (short)(index % 100));
}

originalTable.AcceptChanges();
originalTable.Rows[7]["Age"] = (short)99;

var serialized = serializer.Serialize(originalTable);
var deserializedTable = serializer.Deserialize<DataTable>(serialized);

Assert.Equal(rowCount, deserializedTable.Rows.Count);
Assert.Equal(DataRowState.Modified, deserializedTable.Rows[7].RowState);
Assert.Equal((short)7, deserializedTable.Rows[7]["Age", DataRowVersion.Original]);
Assert.Equal((short)99, deserializedTable.Rows[7]["Age", DataRowVersion.Current]);
Assert.Equal("Müller € 1999", deserializedTable.Rows[rowCount - 1]["UserName"]);
}

[Fact]
public void NeoBinarySerializerAdapter_should_serialize_and_deserialize_inherited_objects()
{
Expand Down
Original file line number Diff line number Diff line change
@@ -1,8 +1,8 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.IO;
using System.Text;

namespace CoreRemoting.Serialization.NeoBinary;

Expand All @@ -20,26 +20,28 @@ private void SerializeDataSet(DataSet dataSet, BinaryWriter writer, HashSet<obje
{
// XML serialization (default)
writer.Write((byte)0); // XML marker
var schemaBytes = System.Buffers.ArrayPool<byte>.Shared.Rent(4096);
try
{
using var ms = new MemoryStream(schemaBytes);
dataSet.WriteXmlSchema(ms);
var schemaXml = Encoding.UTF8.GetString(schemaBytes, 0, (int)ms.Position);
writer.Write(schemaXml);

ms.SetLength(0);
dataSet.WriteXml(ms, XmlWriteMode.DiffGram);
var diffGramXml = Encoding.UTF8.GetString(schemaBytes, 0, (int)ms.Position);
writer.Write(diffGramXml);
}
finally
{
System.Buffers.ArrayPool<byte>.Shared.Return(schemaBytes);
}
WriteXmlSchemaAndDiffGram(writer,
schemaWriter => dataSet.WriteXmlSchema(schemaWriter),
diffGramWriter => dataSet.WriteXml(diffGramWriter, XmlWriteMode.DiffGram));
}
}

/// <summary>
/// Writes the XML schema and the DiffGram of a DataSet or DataTable as two strings.
/// The XML is written into growing <see cref="StringWriter"/> instances, so the size of the data is not limited.
/// </summary>
private static void WriteXmlSchemaAndDiffGram(BinaryWriter writer, Action<TextWriter> writeXmlSchema,
Action<TextWriter> writeDiffGram)
{
using var schemaWriter = new StringWriter(CultureInfo.InvariantCulture);
writeXmlSchema(schemaWriter);
writer.Write(schemaWriter.ToString());

using var diffGramWriter = new StringWriter(CultureInfo.InvariantCulture);
writeDiffGram(diffGramWriter);
writer.Write(diffGramWriter.ToString());
}

private void SerializeDataSetBinary(DataSet dataSet, BinaryWriter writer, HashSet<object> serializedObjects,
Dictionary<object, int> objectMap)
{
Expand Down Expand Up @@ -107,23 +109,9 @@ private void SerializeDataTable(DataTable dataTable, BinaryWriter writer, HashSe
// Do not add the DataTable to a temporary DataSet, as it may already belong to another DataSet
// and would throw "DataTable already belongs to another DataSet.". Instead, write schema and data
// directly from the DataTable itself.
var schemaBytes = System.Buffers.ArrayPool<byte>.Shared.Rent(4096);
try
{
using var ms = new MemoryStream(schemaBytes);
dataTable.WriteXmlSchema(ms);
var schemaXml = Encoding.UTF8.GetString(schemaBytes, 0, (int)ms.Position);
writer.Write(schemaXml);

ms.SetLength(0);
dataTable.WriteXml(ms, XmlWriteMode.DiffGram);
var diffGramXml = Encoding.UTF8.GetString(schemaBytes, 0, (int)ms.Position);
writer.Write(diffGramXml);
}
finally
{
System.Buffers.ArrayPool<byte>.Shared.Return(schemaBytes);
}
WriteXmlSchemaAndDiffGram(writer,
schemaWriter => dataTable.WriteXmlSchema(schemaWriter),
diffGramWriter => dataTable.WriteXml(diffGramWriter, XmlWriteMode.DiffGram));
}
}

Expand Down
Loading