BinaryFormatter serialization time elapsed:  1 132, Length is: 5 041 592
Binary manual formatted serialization time elapsed:   60, Length is: 3 641 406
SoapFormatter serialization time elapsed:  3 415, Length is: 12 285 041

SoapFormatter.Length / BinaryManual.Length = 3.37
SoapFormatter.Time / BinaryManual.Time = 56.92  <-- !!! Поглядите на это 
BinaryFormatter zip time elapsed:  1 472,

BinaryManual zip time elapsed:   971,
SoapFormatter zip time elapsed:  1 182,

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
// Это ком-объект-обертка над ActiveZip сделанная на VB6. Без нее он валится. :(
// Возможно дело в том, что этот компонент хочет лежать на форме.
using TestCom;

namespace SerializeTest
{
    /// <summary>
    /// Подопытная структура. Из нее создается массив которы 
    /// нужно сериализовать.
    /// </summary>
    [Serializable]
    public struct TestData
    {
        // Данные...
        public int _i1;
        public int _i2;
        public double _f1;
        public string _s1;

        /// <summary>
        /// Ручная сериализация.
        /// Сериализует содержимое массива структур TestData в стрим.
        /// </summary>
        /// <param name="ms">Стрим куда сериализуются данные</param>
        /// <param name="ary">Массив</param>
        public static void Write(MemoryStream ms, TestData[] ary)
        {
            BinaryWriter bw = new BinaryWriter(ms);
            Int32 iLen = ary.Length;
            bw.Write(iLen);
            for(int i = 0; i < iLen; i++)
            {
                bw.Write(ary[i]._i1);
                bw.Write(ary[i]._i2);
                bw.Write(ary[i]._f1);
                bw.Write(ary[i]._s1);
            }
        }

        /// <summary>
        /// Ручная сериализация.
        /// Создает массив структур TestData и считывает в него информацию
        /// из стрима.
        /// </summary>
        /// <param name="ms">Стрим в котором находится сериализованное
        /// представление массива структур (созданное с помощю метда Write).</param>
        /// <returns></returns>
        public static TestData[] Read(MemoryStream ms)
        {
            BinaryReader br = new BinaryReader(ms);
            Int32 iLen = br.ReadInt32();
            TestData[] ary = new TestData[iLen];
            for(int i = 0; i < iLen; i++)
            {
                ary[i]._i1 = br.ReadInt32();
                ary[i]._i2 = br.ReadInt32();
                ary[i]._f1 = br.ReadDouble();
                ary[i]._s1 = br.ReadString();
            }
            return ary;
        }

        /// <summary>
        /// Создает и инициализирует массив структур TestData
        /// </summary>
        /// <param name="ArrayLen">Количество элементов в массиве</param>
        /// <returns>Заполненный массив</returns>
        public static TestData[] InitErray(int ArrayLen)
        {
            TestData[] aryTd = new TestData[ArrayLen];
            for(int i = 0; i < ArrayLen; i++)
            {
                aryTd[i]._f1 = i * 1.3;
                aryTd[i]._i1 = i;
                aryTd[i]._i2 = i * 2;
                aryTd[i]._s1 = "Стр" + i.ToString() + " " + (i * 234).ToString();
            }
            return aryTd;
        }
    }

    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            int start; // Используется для вычисления времени выполнения

            // Стрим для сериализации через BinaryFormatter
            MemoryStream msBf = new MemoryStream(10*1000*1000);
            // Стрим для ручной сериализации.
            MemoryStream msBm = new MemoryStream(10*1000*1000);
            // Стрим для сериализации через SoapFormatter
            MemoryStream msSf = new MemoryStream(10*1000*1000);
            BinaryFormatter bf = new BinaryFormatter();
            SoapFormatter sf = new SoapFormatter();

            // Массив структур который будет сериализоваться
            TestData[] aryTestData = TestData.InitErray(100*1000);

            // Сериализация BinaryFormatter-ом
            start = Environment.TickCount;
            bf.Serialize(msBf, aryTestData);
            Console.WriteLine(
                "BinaryFormatter serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                Environment.TickCount - start, msBf.Length);

            // Сериализация врукопашную
            start = Environment.TickCount;
            TestData.Write(msBm, aryTestData);
            int BinaryManualTime = Environment.TickCount - start;
            Console.WriteLine(
                "Binary manual formatted serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                BinaryManualTime, msBm.Length);

            // Сериализация SoapFormatter-ом
            start = Environment.TickCount;
            sf.Serialize(msSf, aryTestData);
            int SoapFormatterTime = Environment.TickCount - start;
            Console.WriteLine(
                "SoapFormatter serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                SoapFormatterTime, msSf.Length);

            // Выводим разницу между бинарной и соапной сериализацией.
            Console.WriteLine("SoapFormatter.Length / BinaryManual.Length = {0:0.00}",
                msSf.Length * 1.0 / msBm.Length);
            Console.WriteLine("SoapFormatter.Time / BinaryManual.Time = {0:0.00}",
                SoapFormatterTime * 1.0 / BinaryManualTime);

            TestCom.Class1Class test = new TestCom.Class1Class();

            //////////////////////////////////////////////////////////////////////////
            // Зипуем...

            string zipName;
            string binName;
            FileStream fs;

            // Зипуем данные полученные BinaryFormatter-ом
            start = Environment.TickCount;
            zipName = Environment.CurrentDirectory + @"\testBinaryFormatter.zip";
            binName = Environment.CurrentDirectory + @"\testBinaryFormatter";
            fs = new FileStream(binName, FileMode.Create);
            msBf.WriteTo(fs);
            fs.Close();
            test.ZipData(zipName, binName);
            Console.WriteLine(
                "BinaryFormatter zip time elapsed: {0:### ### ###}, ",
                Environment.TickCount - start);

            // Зипуем данные полученные вручную.
            start = Environment.TickCount;
            zipName = Environment.CurrentDirectory + @"\testBinaryManual.zip";
            binName = Environment.CurrentDirectory + @"\testBinaryManual";
            fs = new FileStream(binName, FileMode.Create);
            msBm.WriteTo(fs);
            fs.Close();
            test.ZipData(zipName, binName);
            Console.WriteLine(
                "BinaryManual zip time elapsed: {0:### ### ###}, ",
                Environment.TickCount - start);

            // Зипуем данные полученные SoapFormatter-ом
            start = Environment.TickCount;
            zipName = Environment.CurrentDirectory + @"\testSoapFormatter.zip";
            binName = Environment.CurrentDirectory + @"\testSoapFormatter";
            fs = new FileStream(binName, FileMode.Create);
            msSf.WriteTo(fs);
            fs.Close();
            test.ZipData(zipName, binName);
            Console.WriteLine(
                "SoapFormatter zip time elapsed: {0:### ### ###}, ",
                Environment.TickCount - start);

            Console.ReadLine();
        }
    }
}

' Class1
Option Explicit
  
Public Sub ZipData(ByVal ZipFilename As String, ByVal AddFilename As String)
    Form1.ZipData ZipFilename, AddFilename
    Unload Form1
End Sub

' Form1 свойство Visible этой формы выставлено в false (шобы ее небыло вдно).
' Возможно я и перемудрил. Может быть достаточно было бросить этот кривой объект
' на WinForms-ую форму. Теперь пределываьть уже влом.
Option Explicit

Public Sub ZipData(ByVal ZipFilename As String, ByVal AddFilename As String)
    ActiveZip1.CreateZip ZipFilename, ""
    Dim iLen As Long
    ActiveZip1.AddFile AddFilename, ""
    ActiveZip1.PreservePaths = False
    ActiveZip1.Close
End Sub

BinaryFormatter serialization time elapsed:  1 752, Length is: 5 041 578
Binary manual formatted serialization time elapsed:   80, Length is: 3 641 406
SoapFormatter serialization time elapsed:  4 817, Length is: 12 285 027
XmlSerializerTime serialization time elapsed:  2 734, Length is: 13 295 651 (chars)
SoapFormatter.Length / BinaryManual.Length = 3.37
SoapFormatter.Time / BinaryManual.Time = 60.21

VD>>Все равно скорость даже у бинари никуда не годится.

                // Сериализация XmlSerializer-ом
                start = Environment.TickCount;
                StringWriter xmlOut=new StringWriter();
                xmlSer.Serialize(
                    xmlOut,
                    aryTestData );
                int XmlSerializerTime = Environment.TickCount - start;
                Console.WriteLine(
                    "XmlSerializerTime serialization time elapsed: {0:### ### ###}, "
                    + "Length is: {1:### ### ###} (chars)",
                    XmlSerializerTime, xmlOut.ToString().Length );

public class Row
{
}

public class Main
{
  public Table table = new Table();
  public Row row;
}

//у этого класс свой личный serializer
public class Table
{
  public Row row;
}

void Test()
{
  Main main = new Main();
  main.row = main.table.row = new Row();  

  Save(main);
  Main main2 = Load();
  
}

Могу кинуть обёрнутый в .NET zlib.

BinaryFormatter serialization time elapsed:  1 121, Length is: 5 041 593
Binary manual formatted serialization time elapsed:   70, Length is: 3 641 406
SoapFormatter serialization time elapsed:  3 245, Length is: 12 285 042
XmlSerializerTime serialization time elapsed:  2 003, Length is: 13 595 633
SoapFormatter.Length / BinaryManual.Length = 3.37
SoapFormatter.Time / BinaryManual.Time = 46.36
BinaryFormatter zip time elapsed:  1 412,
BinaryManual zip time elapsed:   921,
SoapFormatter zip time elapsed:  1 112,
XmlSerializer zip time elapsed:  1 041,

BestCompression

BinaryFormatter serialization time elapsed:  1 192, Length is: 5 041 592
Binary manual formatted serialization time elapsed:   70, Length is: 3 641 406
SoapFormatter serialization time elapsed:  3 455, Length is: 12 285 041
XmlSerializerTime serialization time elapsed:  2 053, Length is: 13 595 633
SoapFormatter.Length / BinaryManual.Length = 3.37
SoapFormatter.Time / BinaryManual.Time = 49.36
Зазиповываем. Уровень сжатия: BestCompression
BinaryFormatter zip time elapsed:  4 606, Ziped size: 1 690 067
BinaryManual zip time elapsed:  3 025, Ziped size: 1 209 452
SoapFormatter zip time elapsed:  3 535, Ziped size: 1 808 222
XmlSerializer zip time elapsed:  3 144, Ziped size: 1 551 295


BestSpeed

BinaryFormatter serialization time elapsed:  1 192, Length is: 5 041 592
Binary manual formatted serialization time elapsed:   70, Length is: 3 641 406
SoapFormatter serialization time elapsed:  3 445, Length is: 12 285 041
XmlSerializerTime serialization time elapsed:  2 033, Length is: 13 595 633
SoapFormatter.Length / BinaryManual.Length = 3.37
SoapFormatter.Time / BinaryManual.Time = 49.21
Зазиповываем. Уровень сжатия: BestSpeed
BinaryFormatter zip time elapsed:   310, Ziped size: 1 777 824
BinaryManual zip time elapsed:   231, Ziped size: 1 353 346
SoapFormatter zip time elapsed:   390, Ziped size: 2 204 262
XmlSerializer zip time elapsed:   371, Ziped size: 1 934 505

DefaultCompression

BinaryFormatter serialization time elapsed:  1 141, Length is: 5 041 592
Binary manual formatted serialization time elapsed:   61, Length is: 3 641 406
SoapFormatter serialization time elapsed:  3 354, Length is: 12 285 041
XmlSerializerTime serialization time elapsed:  1 993, Length is: 13 595 633
SoapFormatter.Length / BinaryManual.Length = 3.37
SoapFormatter.Time / BinaryManual.Time = 54.98
Зазиповываем. Уровень сжатия: DefaultCompression
BinaryFormatter zip time elapsed:  1 262, Ziped size: 1 690 669
BinaryManual zip time elapsed:   831, Ziped size: 1 209 622
SoapFormatter zip time elapsed:   852, Ziped size: 1 875 580
XmlSerializer zip time elapsed:   791, Ziped size: 1 609 710

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;
using Zlib;

namespace SerializeTest
{
    /// <summary>
    /// Подопытная структура. Из нее создается массив которы 
    /// нужно сериализовать.
    /// </summary>
    [Serializable]
    public struct TestData
    {
        // Данные...
        public int _i1;
        public int _i2;
        public double _f1;
        public string _s1;

        /// <summary>
        /// Ручная сериализация.
        /// Сериализует содержимое массива структур TestData в стрим.
        /// </summary>
        /// <param name="ms">Стрим куда сериализуются данные</param>
        /// <param name="ary">Массив</param>
        public static void Write(MemoryStream ms, TestData[] ary)
        {
            BinaryWriter bw = new BinaryWriter(ms);
            Int32 iLen = ary.Length;
            bw.Write(iLen);
            for(int i = 0; i < iLen; i++)
            {
                bw.Write(ary[i]._i1);
                bw.Write(ary[i]._i2);
                bw.Write(ary[i]._f1);
                bw.Write(ary[i]._s1);
            }
        }

        /// <summary>
        /// Ручная сериализация.
        /// Создает массив структур TestData и считывает в него информацию
        /// из стрима.
        /// </summary>
        /// <param name="ms">Стрим в котором находится сериализованное
        /// представление массива структур (созданное с помощю метда Write).</param>
        /// <returns></returns>
        public static TestData[] Read(MemoryStream ms)
        {
            BinaryReader br = new BinaryReader(ms);
            Int32 iLen = br.ReadInt32();
            TestData[] ary = new TestData[iLen];
            for(int i = 0; i < iLen; i++)
            {
                ary[i]._i1 = br.ReadInt32();
                ary[i]._i2 = br.ReadInt32();
                ary[i]._f1 = br.ReadDouble();
                ary[i]._s1 = br.ReadString();
            }
            return ary;
        }

        /// <summary>
        /// Создает и инициализирует массив структур TestData
        /// </summary>
        /// <param name="ArrayLen">Количество элементов в массиве</param>
        /// <returns>Заполненный массив</returns>
        public static TestData[] InitErray(int ArrayLen)
        {
            TestData[] aryTd = new TestData[ArrayLen];
            for(int i = 0; i < ArrayLen; i++)
            {
                aryTd[i]._f1 = i * 1.3;
                aryTd[i]._i1 = i;
                aryTd[i]._i2 = i * 2;
                aryTd[i]._s1 = "Стр" + i.ToString() + " " + (i * 234).ToString();
            }
            return aryTd;
        }
    }

    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
            int start; // Используется для вычисления времени выполнения

            // Стрим для сериализации через BinaryFormatter
            MemoryStream msBf = new MemoryStream(10*1000*1000);
            // Стрим для ручной сериализации.
            MemoryStream msBm = new MemoryStream(10*1000*1000);
            // Стрим для сериализации через SoapFormatter
            MemoryStream msSf = new MemoryStream(10*1000*1000);
            // Стрим для сериализации через XmlSerializer
            MemoryStream msXs = new MemoryStream(10*1000*1000);

            // Массив структур который будет сериализоваться
            TestData[] aryTestData = TestData.InitErray(100*1000);

            // Сериализация BinaryFormatter-ом
            start = Environment.TickCount;
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(msBf, aryTestData);
            Console.WriteLine(
                "BinaryFormatter serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                Environment.TickCount - start, msBf.Length);

            // Сериализация врукопашную
            start = Environment.TickCount;
            TestData.Write(msBm, aryTestData);
            int BinaryManualTime = Environment.TickCount - start;
            Console.WriteLine(
                "Binary manual formatted serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                BinaryManualTime, msBm.Length);

            // Сериализация SoapFormatter-ом
            start = Environment.TickCount;
            SoapFormatter sf = new SoapFormatter();
            sf.Serialize(msSf, aryTestData);
            int SoapFormatterTime = Environment.TickCount - start;
            Console.WriteLine(
                "SoapFormatter serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                SoapFormatterTime, msSf.Length);

            // Сериализация XmlSerializer-ом
            start = Environment.TickCount;
            XmlSerializer xmlSer = new XmlSerializer(aryTestData.GetType());
            //StringWriter xmlOut = new StringWriter();
            xmlSer.Serialize(msXs, aryTestData);
            int XmlSerializerTime = Environment.TickCount - start;
            Console.WriteLine(
                "XmlSerializerTime serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                XmlSerializerTime, msXs.Length );



            // Выводим разницу между бинарной и соапной сериализацией.
            Console.WriteLine("SoapFormatter.Length / BinaryManual.Length = {0:0.00}",
                msSf.Length * 1.0 / msBm.Length);
            Console.WriteLine("SoapFormatter.Time / BinaryManual.Time = {0:0.00}",
                SoapFormatterTime * 1.0 / BinaryManualTime);

            //////////////////////////////////////////////////////////////////////////
            // Зипуем...

            ZipBase.Level leve = ZipBase.Level.BestSpeed;
            byte[] aryZip; // Массив в который происходит сжатие.
            
            Console.WriteLine("Зазиповываем. Уровень сжатия: {0}", leve);


            // Зипуем данные полученные BinaryFormatter-ом
            start = Environment.TickCount;
            aryZip = ZipBase.Compress(msBf.ToArray(), leve);
            Console.WriteLine(
                "BinaryFormatter zip time elapsed: {0:### ### ###}, "
                + "Ziped size: {1:### ### ###}",
                Environment.TickCount - start, aryZip.Length);

            // Зипуем данные полученные вручную.
            start = Environment.TickCount;
            aryZip = ZipBase.Compress(msBm.ToArray(), leve);
            Console.WriteLine(
                "BinaryManual zip time elapsed: {0:### ### ###}, "
                + "Ziped size: {1:### ### ###}",
                Environment.TickCount - start, aryZip.Length);

            // Зипуем данные полученные SoapFormatter-ом
            start = Environment.TickCount;
            aryZip = ZipBase.Compress(msSf.ToArray(), leve);
            Console.WriteLine(
                "SoapFormatter zip time elapsed: {0:### ### ###}, "
                + "Ziped size: {1:### ### ###}",
                Environment.TickCount - start, aryZip.Length);

            // Зипуем данные полученные XmlSerializer-ом
            start = Environment.TickCount;
            aryZip = ZipBase.Compress(msXs.ToArray(), leve);
            Console.WriteLine(
                "XmlSerializer zip time elapsed: {0:### ### ###}, "
                + "Ziped size: {1:### ### ###}",
                Environment.TickCount - start, aryZip.Length);

            Console.ReadLine();
        }
    }
}

AVK>То есть ты BinarySerializer уже написал?

XmlSerializer    - 2 734
BinaryFormatter  - 1 752
SoapFormatter    - 4 817

VD>XmlSerializer    - 2 734
VD>BinaryFormatter  - 1 752
VD>SoapFormatter    - 4 817
VD>

VD>Я бы не назвал разницу на секунду при менее чем трех секундах двенадцатью процентами.

Total 100 iterations ...
Simple xml parsing : 15993ms (чтение при помощи XmlTextReader и полностью ручная десериализация, по сути теоретический предел для десериализации из xml на дотнете)
Simple xml parsing into DOМ : 20019ms (просто загрузка документа из xml DOM парсером) (1.6М (220К упак.) семпл)
Parsing with XmlSerializer : 19538ms (полностью автоматическая десериализация XmlSerializer) (1.6М (220К упак.) семпл)
Parsing with BinaryFormatter : 19157ms (полностью автоматическая десериализация BinaryFormatter) (800К (340К упак.) семпл)
Parsing with BinaryFormatter with custom serialization : 39517ms (А вот здесь я реализовал ISerializable, вот так вот (а полей там всего два + подчиненная коллекция)) (1.05М (380К упак.) семпл)
Parsing with XmlSerializer : 20800ms (здесь полуавтоматическиая десериализация XmlSerialize, реализован IXmlSerializable) (2.0М (220К упак.)семпл)

VD>Попробуй бинарным форматером считать данные записанные другой версией.

        [Serializable]
    public class Root:
        ISerializable
    {
        public Root()
        {
        }

        public Root (SerializationInfo info, StreamingContext context) 
        {
            Type type = this.GetType();
            foreach (SerializationEntry entry in info)
            {
                FieldInfo field = type.GetField(entry.Name, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                if (field != null)
                    field.SetValue(this, entry.Value);
            }
        }
        public void GetObjectData(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
        {
            Type type = this.GetType();
            foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                if (!field.IsNotSerialized)
                    info.AddValue(field.Name, field.GetValue(this));
            }
        }
}

DataSetHandsSerializate serialization time elapsed:  63, Length is: 147 846
BinaryFormatter serialization time elapsed:  2 843, Length is: 1 306 610
XmlSerializer serialization time elapsed:  5 250, Length is: 1 666 490
SoapFormatter serialization time elapsed:  3 641, Length is: 3 334 068

using System;
using System.Data;
using System.Xml;
using System.Xml.Serialization;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;

namespace TestSerialize
{

    class DataSetHandsSerializate
    {
        public static void Serialize( Stream stream, DataSet ds)
        {
            BinaryWriter bw = new BinaryWriter(stream);
            //dataset name
            bw.Write(ds.DataSetName);
            //count tables
            bw.Write(ds.Tables.Count);
            foreach (DataTable dt in ds.Tables)
            {    
                //table name
                bw.Write(dt.TableName);
                //count columns
                bw.Write(dt.Columns.Count);
                foreach (DataColumn dc in dt.Columns)
                {
                    //column name
                    bw.Write(dc.ColumnName);
                    //column type
                    bw.Write(dc.DataType.ToString());
                }

                //add data
                //count rows
                bw.Write(dt.Rows.Count);
                foreach (DataRow dr in dt.Rows)
                {
                    for (int i=0;i<dt.Columns.Count;i++)
                    {
                        //data
                        bw.Write(dr[i].ToString());
                    }

                }

            }
        }

        public static DataSet Deserialize( Stream stream )
        {
            DataSet ds = new DataSet();
            BinaryReader br = new BinaryReader(stream);
            ds.DataSetName = br.ReadString();
            int counTables = br.ReadInt32();
            DataTable dt;
            DataColumn dc;
            DataRow dr;
            for (int t=0;t<counTables;t++)
            {
                dt = new DataTable(br.ReadString());
                int counColums = br.ReadInt32();
                for (int c=0;c<counColums;c++)
                {
                    string colName = br.ReadString();
                    string sType = br.ReadString();
                    System.Type type = Type.GetType(sType);
                    dc = new DataColumn(colName,type);
                    dt.Columns.Add(dc);
                }

                int counRows = br.ReadInt32();
                for (int i=0;i<counRows;i++)
                {
                    //data
                    dr = dt.NewRow();
                    for (int c=0;c<counColums;c++)
                    {
                        string data = br.ReadString();            
                        dr[c] = String2Type( dt.Columns[c].DataType, data);
                        
                    }
                    dt.Rows.Add(dr);
                }

                ds.Tables.Add(dt);
            }
            return ds;
        }

        private static object String2Type( Type type,string data)
        {
            switch (type.ToString())
            {
                case "System.Boolean":
                    return Convert.ToBoolean(data);
                case "System.Byte":
                    return Convert.ToByte(data);
                case "System.Char":
                    return Convert.ToChar(data);
                case "System.DateTime":
                    return Convert.ToDateTime(data);
                case "System.Decimal":
                    return Convert.ToDecimal(data);
                case "System.Double":
                    return Convert.ToDouble(data);
                case "System.Int16":
                    return Convert.ToInt16(data);
                case "System.Int32":
                    return Convert.ToInt32(data);
                case "System.Int64":
                    return Convert.ToInt64(data);
                case "System.SByte":
                    return Convert.ToSByte(data);
                case "System.Single":
                    return Convert.ToSingle(data);
                case "System.String":
                    return Convert.ToString(data);
                case "System.UInt16":
                    return Convert.ToUInt16(data);
                case "System.UInt32":
                    return Convert.ToUInt32(data);
                case "System.UInt64":
                    return Convert.ToUInt64(data);
                
            }
            return null;
        }
    }
    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {

            int start; // Используется для вычисления времени выполнения

            DataSet ds = new DataSet("myDataSet");
            DataTable dt = new DataTable("Table1");
            DataColumn dc1 = new DataColumn("col1", System.Type.GetType("System.Int32"));
            DataColumn dc2 = new DataColumn("col2", System.Type.GetType("System.String"));
            dt.Columns.Add(dc1);
            dt.Columns.Add(dc2);

            DataRow dr;

            for (int i=0;i<10000;i++)
            {
                dr = dt.NewRow();
                dr["col1"] = i;
                dr["col2"] = "2test"+i.ToString();
                dt.Rows.Add(dr);        
            }

            ds.Tables.Add(dt);


            // Стрим для сериализации через BinaryFormatter
            MemoryStream msBf = new MemoryStream();
            // Стрим для ручной сериализации.
            MemoryStream msBm = new MemoryStream();
            // Стрим для сериализации через SoapFormatter
            MemoryStream msSf = new MemoryStream();
            // Стрим для сериализации через XmlSerializer
            MemoryStream msXml = new MemoryStream();


            
            BinaryFormatter bf = new BinaryFormatter();
            SoapFormatter sf = new SoapFormatter();


            start = Environment.TickCount;
            DataSetHandsSerializate.Serialize(msBm, ds);
            Console.WriteLine(
                "DataSetHandsSerializate serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                Environment.TickCount - start,msBm.Length);

            start = Environment.TickCount;
            bf.Serialize(msBf, ds);
            Console.WriteLine(
                "BinaryFormatter serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                Environment.TickCount - start,msBf.Length);

            start = Environment.TickCount;
            XmlSerializer serializer = 
                new XmlSerializer(typeof(DataSet));
            serializer.Serialize(msXml, ds);
            Console.WriteLine(
                "XmlSerializer serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                Environment.TickCount - start,msXml.Length);

            start = Environment.TickCount;
            sf.Serialize(msBf, ds);
            Console.WriteLine(
                "SoapFormatter serialization time elapsed: {0:### ### ###}, "
                + "Length is: {1:### ### ###}",
                Environment.TickCount - start,msBf.Length);

            
            Console.ReadLine();
        }
    }
}

T>                //add data
T>                //count rows
T>                bw.Write(dt.Rows.Count);
T>                foreach (DataRow dr in dt.Rows)
T>                {
T>                    for (int i=0;i<dt.Columns.Count;i++)
T>                    {
T>                        //data
T>                        bw.Write(dr[i].ToString());
T>                    }

T>                }

[WebMethod]
public void GetDataSet()
{
    SoapContext sc = HttpSoapContext.ResponseContext;
    if (null == sc)
        throw new ApplicationException("Only SOAP requests allowed");

    SqlConnection conn = new SqlConnection(
        @"data source=MyServer;initial catalog=Northwind;integrated security=SSPI");

    SqlDataAdapter da = new SqlDataAdapter("SELECT * FROM customers", conn);
    DataSet ds = new DataSet("CustomerDS");
    da.Fill(ds, "Customers");
    
    conn.Close();

    MemoryStream ms = new MemoryStream(1000000);

    DataSetHandsSerializate.Serialize(ms, ds);

    byte[] aryZip = ZipBase.Compress(ms.ToArray(), leve);
    ms.Seek(0, SeekOrigin.Begin);

    DimeAttachment dimeAttachment = new DimeAttachment("application/x-zip",
        TypeFormatEnum.MediaType, ms);

    sc.Attachments.Add(dimeAttachment);
}

localhost.Service1 svc = new localhost.Service1();
svc.GetDataSet();
SoapContext sc = svc.ResponseSoapContext;
MemoryStream msSrc = new MemoryStream(1000000);
ZipBase.Uncompress(sc.Attachments[0].Stream.ToArray(), msSrc);
DataSet ds = DataSetHandsSerializate.Deserialize(msSrc);

if (dt.Columns[i].DataType.ToString() == "System.Int32")
 bw.Write( (System.Int32)dr[i]);
else
 bw.Write( dr[i].ToString());

T>if (dt.Columns[i].DataType.ToString() == "System.Int32")
T>

if (dt.Columns[i].DataType==typeof(int))

T> в принципе время стало одинаковым, но вот даст ли сохранение числовых типов в бинари, всегда выигрыш по объему: ВОПРОС

byte i8=0xff;
ushort i16=0;
uint i32=0xffffffff;
ulong i64=0;

wr.Write(i8);
wr.Write(i16);
wr.Write(i32);
wr.Write(i64);

T>if (dt.Columns[i].DataType.ToString() == "System.Int32")
T> bw.Write( (System.Int32)dr[i]);
T>else
T> bw.Write( dr[i].ToString());
T>

if (types[i] == MyTypess.Int32)
  bw.Write((System.Int32)dr[i]);
else
  bw.Write( dr[i].ToString());

  GC.Collect();
  GC.WaitForPendingFinalizers();

Type t = typeof(int);

  .locals init (class [mscorlib]System.Type V_0)
  IL_0000:  ldtoken    [mscorlib]System.Int32
  IL_0005:  call       class [mscorlib]System.Type [mscorlib]System.Type::GetTypeFromHandle(valuetype [mscorlib]System.RuntimeTypeHandle)
  IL_000a:  stloc.0

Int32Type   0.220 с
typeof(int) 1.232 с