Beispiel #1
0
        public void DataSetSerialization_ValidCase()
        {
            const int RowCount = ushort.MaxValue * 10;// * 20;

            //Act
            StringBuilder results = new StringBuilder();
            Ticks stopTime, startTime;

            DataSet sourceDataSet = new DataSet("source");
            DataTable table = sourceDataSet.Tables.Add("table1");

            table.Columns.Add("col0", typeof(string));
            table.Columns.Add("col1", typeof(int));
            table.Columns.Add("col2", typeof(bool));
            table.Columns.Add("col3", typeof(Guid));
            table.Columns.Add("col4", typeof(DateTime));
            table.Columns.Add("col5", typeof(TimeSpan));
            table.Columns.Add("col6", typeof(byte[]));

            startTime = DateTime.UtcNow.Ticks;

            for (int i = 0; i < RowCount; i++)
            {
                DataRow row = table.NewRow();

                if (Random.Boolean || Random.Boolean)
                    row[0] = new string((char)Random.Int16Between(32, 128), Random.Int16Between(5, 30));
                else
                    row[0] = DBNull.Value;

                row[1] = Random.Int32;
                row[2] = Random.Boolean;

                if (Random.Boolean || Random.Boolean)
                    row[3] = Guid.NewGuid();
                else
                    row[3] = DBNull.Value;

                row[4] = DateTime.UtcNow;
                row[5] = new TimeSpan(Random.Int64Between(Ticks.PerSecond, Ticks.PerHour));

                byte[] bytes = null;

                if (Random.Boolean || Random.Boolean)
                {
                    bytes = new byte[Random.Int16Between(0, 1000)];
                    Random.GetBytes(bytes);
                }

                row[6] = bytes;

                table.Rows.Add(row);
            }

            table = sourceDataSet.Tables.Add("table2");

            table.Columns.Add("col0", typeof(ulong));
            table.Columns.Add("col1", typeof(double));
            table.Columns.Add("col2", typeof(byte));
            table.Columns.Add("col3", typeof(char));
            table.Columns.Add("col4", typeof(object));

            for (int i = 0; i < Random.Int32Between(100, 500); i++)
            {
                DataRow row = table.NewRow();

                if (Random.Boolean || Random.Boolean)
                    row[0] = Random.UInt64;
                else
                    row[0] = DBNull.Value;

                row[1] = Random.Number;
                row[2] = Random.Byte;

                if (Random.Boolean || Random.Boolean)
                    row[3] = (char)Random.Int16Between(32, 1024);
                else
                    row[3] = DBNull.Value;

                row[4] = Guid.NewGuid().ToString();

                table.Rows.Add(row);
            }

            stopTime = DateTime.UtcNow.Ticks;
            results.AppendFormat("Initial random sample dataset created with {0} rows. ({1})\r\n", RowCount, (stopTime - startTime).ToElapsedTimeString(4));
            results.AppendLine();

            FileStream stream;
            string path = FilePath.GetApplicationDataFolder();

            if (!Directory.Exists(path))
                Directory.CreateDirectory(path);

            string fileName = Path.Combine(path, "DataSet.bin");

            startTime = DateTime.UtcNow.Ticks;

            stream = new FileStream(fileName, FileMode.Create);
            sourceDataSet.SerializeToStream(stream);
            stream.Flush();
            stream.Close();
            stream.Dispose();

            stopTime = DateTime.UtcNow.Ticks;
            results.AppendFormat("Dataset binary serialization time: {0}\r\n", (stopTime - startTime).ToElapsedTimeString(4));

            string xmlFileName = Path.Combine(path, "DataSet.xml");

            startTime = DateTime.UtcNow.Ticks;

            sourceDataSet.WriteXml(xmlFileName, XmlWriteMode.WriteSchema);

            stopTime = DateTime.UtcNow.Ticks;
            results.AppendFormat("Dataset XML serialization time: {0}\r\n", (stopTime - startTime).ToElapsedTimeString(4));
            results.AppendLine();

            DataSet destinationDataSet;

            startTime = DateTime.UtcNow.Ticks;

            stream = new FileStream(fileName, FileMode.Open);
            destinationDataSet = stream.DeserializeToDataSet();
            stream.Close();
            stream.Dispose();

            stopTime = DateTime.UtcNow.Ticks;
            results.AppendFormat("Dataset binary deserialization time: {0}\r\n", (stopTime - startTime).ToElapsedTimeString(4));

            DataSet tempDataSet;

            startTime = DateTime.UtcNow.Ticks;

            tempDataSet = new DataSet();
            tempDataSet.ReadXml(xmlFileName);

            stopTime = DateTime.UtcNow.Ticks;
            results.AppendFormat("Dataset XML deserialization time: {0}\r\n", (stopTime - startTime).ToElapsedTimeString(4));
            results.AppendLine();

            startTime = DateTime.UtcNow.Ticks;

            // Validate that source and destination dataset are the same
            Assert.AreEqual(sourceDataSet.DataSetName, destinationDataSet.DataSetName);
            Assert.AreEqual(sourceDataSet.Tables.Count, destinationDataSet.Tables.Count);

            foreach (DataTable sourceTable in sourceDataSet.Tables)
            {
                bool tableExists = destinationDataSet.Tables.Contains(sourceTable.TableName);
                Assert.IsTrue(tableExists);

                DataTable destinationTable = destinationDataSet.Tables[sourceTable.TableName];
                Assert.AreEqual(sourceTable.Columns.Count, destinationTable.Columns.Count);

                foreach (DataColumn sourceColumn in sourceTable.Columns)
                {
                    bool columnExists = destinationTable.Columns.Contains(sourceColumn.ColumnName);
                    Assert.IsTrue(columnExists);

                    DataColumn destinationColumn = destinationTable.Columns[sourceColumn.ColumnName];
                    Assert.IsTrue(sourceColumn.DataType == destinationColumn.DataType ||
                        (sourceColumn.DataType == typeof(object) && destinationColumn.DataType == typeof(string)));
                }

                Assert.AreEqual(sourceTable.Rows.Count, destinationTable.Rows.Count);

                for (int i = 0; i < sourceTable.Rows.Count; i++)
                {
                    DataRow sourceRow = sourceTable.Rows[i];
                    DataRow destinationRow = destinationTable.Rows[i];

                    for (int j = 0; j < sourceTable.Columns.Count; j++)
                    {
                        if (sourceRow[j] != DBNull.Value && destinationRow[j] != DBNull.Value)
                        {
                            byte[] bytes = sourceRow[j] as byte[];

                            if ((object)bytes != null)
                                Assert.IsTrue(bytes.CompareTo((byte[])destinationRow[j]) == 0);
                            else
                                Assert.AreEqual(sourceRow[j], destinationRow[j]);
                        }
                    }
                }
            }

            stopTime = DateTime.UtcNow.Ticks;
            results.AppendFormat("Dataset validation time: {0}\r\n", (stopTime - startTime).ToElapsedTimeString(4));
            results.AppendLine();

            FileInfo xmlFile = new FileInfo(xmlFileName);
            FileInfo binFile = new FileInfo(fileName);

            results.AppendFormat("Binary serialization size =  {0}\r\n", SI2.ToScaledString(binFile.Length, "B"));
            results.AppendFormat("XML serialization size =  {0}\r\n", SI2.ToScaledString(xmlFile.Length, "B"));

            results.AppendFormat("Size Improvement = {0:0.00%}\r\n", (xmlFile.Length - binFile.Length) / (double)xmlFile.Length);

            System.Console.WriteLine(results.ToString());
        }
Beispiel #2
0
        // Executes actual serialization of current configuration
        private static void ExecuteConfigurationCache(DataSet configuration)
        {
            if ((object)configuration != null)
            {
                // Create backups of binary configurations
                BackupConfiguration(ConfigurationType.BinaryFile, s_cachedBinaryConfigurationFile);

                // Create backups of XML configurations
                BackupConfiguration(ConfigurationType.XmlFile, s_cachedXmlConfigurationFile);

                try
                {
                    // Wait a moment for write lock in case binary file is open by another process
                    if (File.Exists(s_cachedBinaryConfigurationFile))
                        FilePath.WaitForWriteLock(s_cachedBinaryConfigurationFile);

                    // Cache binary serialized version of data set
                    using (FileStream configurationFileStream = File.OpenWrite(s_cachedBinaryConfigurationFile))
                    {
                        configuration.SerializeToStream(configurationFileStream);
                    }

                    DisplayStatusMessage("Successfully cached current configuration to binary.", UpdateType.Information);
                }
                catch (Exception ex)
                {
                    DisplayStatusMessage("Failed to cache last known configuration due to exception: {0}", UpdateType.Alarm, ex.Message);
                }

                // Serialize current data set to configuration files
                try
                {

                    // Wait a moment for write lock in case XML file is open by another process
                    if (File.Exists(s_cachedXmlConfigurationFile))
                        FilePath.WaitForWriteLock(s_cachedXmlConfigurationFile);

                    // Cache XML serialized version of data set
                    configuration.WriteXml(s_cachedXmlConfigurationFile, XmlWriteMode.WriteSchema);

                    DisplayStatusMessage("Successfully cached current configuration to XML.", UpdateType.Information);
                }
                catch (Exception ex)
                {
                    DisplayStatusMessage("Failed to cache last known configuration due to exception: {0}", UpdateType.Alarm, ex.Message);
                }
            }
        }