AAA

最新推荐文章于 2024-09-08 22:51:42 发布
最新推荐文章于 2024-09-08 22:51:42 发布
阅读量308 收藏
点赞数 1
文章标签： exception stream session xml string properties
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaajedll/article/details/5181997
版权

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}

 

 

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
    /// <summary>
    /// 序列化DataTable,将datatable序列化为xml保存在session中，这样做占用服务器资源
    /// </summary>
    /// <param name="pDt">包含数据的DataTable</param>
    /// <returns>序列化的DataTable</returns>
    public string SerializeDataTableXml(DataTable pDt)
    {
        // 序列化DataTable
        StringBuilder sb = new StringBuilder();
        XmlWriter writer = XmlWriter.Create(sb);
        XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
        serializer.Serialize(writer, pDt);
        writer.Close();
        return sb.ToString();
    }
    /// <summary>
    /// 反序列化DataTable
    /// </summary>
    /// <param name="pXml">序列化的DataTable</param>
    /// <returns>DataTable</returns>
    public DataTable DeserializeDataTable(string pXml)
    {
        try
        {
            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;
            return dt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }

    /// <summary>
    /// 可以序列化为xml文件保存起来
    /// </summary>
    /// <param name="mydt">datatable(必须指定TableName,否则转换失败)</param>
    /// <param name="Filename">指定XML文件名</param>
    public void SerializeDataTableXmlFile(DataTable mydt,string Filename)
    {
        // Insert code to set properties and fields of the object.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To write to a file, create a StreamWriter object.
        StreamWriter myWriter = new StreamWriter(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/"+Filename+"_" + Session["UserName"] + ".xml");
        try
        {
            mySerializer.Serialize(myWriter, mydt);
            myWriter.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// xml反序列化成datatable
    /// </summary>
    /// <param name="Filename">XML文件名</param>
    /// <returns>datatable</returns>
    public DataTable DeserializeXmlFileDataTable(string Filename)
    {
        DataTable mydt;
        // Constructs an instance of the XmlSerializer with the type
        // of object that is being deserialized.
        XmlSerializer mySerializer = new XmlSerializer(typeof(DataTable));
        // To read the file, creates a FileStream.
        FileStream myFileStream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("~/") + @"/Serialize/" + Filename + "_" + Session["UserName"] + ".xml", FileMode.Open);
        // Calls the Deserialize method and casts to the object type.
        try
        {
            mydt = (DataTable)mySerializer.Deserialize(myFileStream);
            myFileStream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    /// <summary>
    /// 将datatable学列话为二进制文件，并反序列化为datatable
    /// 序列化为二进制和xml在需要传输的数据量以及处理该数据所需的 CPU、内存和带宽资源方面降低了一个数量级
    /// 这一改进在使用远程处理时有重大意义，但在使用 Web 服务时没有意义，
    /// 这是因为 Web 服务按照定义必须传递 XML。这意味着，
    /// 只能在通信两端都基于 .NET 并且不是与非 .NET 平台进行通信时，才能利用该增强功能。
    ///----------------------------------------------------
    /// 发现序列化为二进制后，不能編輯和删除，可能二进制文件读写有点问题，此问题待查，咱用xml序列化
    /// </summary>
    /// <param name="pdt"></param>
    public void SerializeDataTableBinary(DataTable mydt)
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile_" + Session["UserName"] + ".bin", FileMode.Create, FileAccess.Write, FileShare.None);
        try
        {
            formatter.Serialize(stream, mydt);
            stream.Close();
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
    public DataTable DeserializeBinaryDataTable()
    {
        IFormatter formatter = new BinaryFormatter();
        Stream stream = new FileStream(System.Web.HttpContext.Current.Server.MapPath("") + @"/Binary/MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.Read);
        try
        {
            DataTable mydt = (DataTable)formatter.Deserialize(stream);
            stream.Close();
            return mydt;
        }
        catch (Exception ex)
        {
            throw new Exception(ex.Message, ex); //拋出異常，在調用處去處理
        }
    }
}

 

 

 

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Text;
using System.Xml.Serialization;
using System.Xml;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

/// <summary>
/// SerializeDataTable 的摘要描述
/// </summary>
public class SerializeDataTable:System.Web.UI.Page
{
    public SerializeDataTable()
    {
        //
        // TODO: 在此加入建構函式的程式碼
        //
    }
 %2

aaajedll
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
配置AAA认证和授权
青红造了个大白之成长记
04-02 1万+
一、 目的 1、掌握AAA认证的工作原理。 2、掌握使用Cisco Secure ACS服务器实现AAA认证授权的方法。 二、网络拓扑 三、认证部分实验要求 配置和测试本地和基于认证服务器的AAA认证。 1、在R1上创建本地帐号，配置本地AAA认证登录console和VTY。 2、配置和测试本地和基于认证服务器的AAA认证。 1、在R1上创建本地帐号（用户名：A...
电信运营商aaa服务器,AAA
weixin_34405769的博客
07-31 2130
Authentication, Authorization and Accounting -- 验证、授权和帐户认证(Authentication)：验证用户的身份与可使用的网络服务；授权(Authorization)：依据认证结果开放网络服务给用户；计帐(Accounting)：记录用户对各种网络服务的用量，并提供给计费系统。AAA-----身份验证 (Authentication)、授权 ...
华为aaa
qq_47529104的博客
12-09 3196
aaa是认证、授权和计费三个的缩写。 总的来说就是为了对用户身份，用户行为，用户计费相关所推出的一些机制。 用户通过NAS网络接入点去访问网络，或是访问设备。这些需要aaa进行用户的身份认证，当用户进行一些上网行为的时候，还需要对其访问的资源进行记录，并依据这些资源的访问记录进行计费。 aaa的认证方式有三种，第一种是不认证，第二种是本地认证，本地认证很好理解，将用户的信息存储在本地设备，当认证成功后就为其提供服务，但是本地认证是不提供用户计费的功能的，第三种是远端认证，远端认证采用额外的aaa服务器
aaa
05-23 834
bbb
思科AAA配置
2301_79021209的博客
04-20 894
R1(config-line)#login authentication yuancheng #调用认证模式yuancheng。R1(config)#enable secret 1234 #配置本地认证密码1234（用户模式到特权模式密码为1234）R1(config)#aaa authentication login default local #登录模式为默认。R1(config)#aaa new-model #开启AAA认证。R1(config)#do wr # 保存。
AAA认证
weixin_46840928的博客
05-27 940
AAA：认证、授权、计费的作用 1、认证模式为AAA [Huawei]user-interface vty 0 4 [Huawei-ui-vty0-4]authentication-mode ? aaa AAA authentication password Authentication through the password of a user terminal interface [Huawei-ui-vty0-4]authentication-mode aaa --将t.
daa和aaa
qq_43776408的博客
12-10 1856
mov bl,15h mov al,56h add al,bl daa 问al=?,bl=?,cf=?,af=? ADD指令： 56H + 15H ＝ 6BH（CF=0, AF=0）－－>存AL中。 DAA对AL调整－－>71H 因为AL低4位超过9，所以低4位加6，并将AF置1。 高4位不超过9，且CF＝0，所以高4位不加6，也不将CF置1。 结果： AL=71H, BL=15...
华为AAA配置实验
2301_78115896的博客
06-16 3350
授权所要保障的是用户行为是合法的，也就是说用户的行为是在被允许范围内的行为;在配置AAA本地认证之前，可以先使用命令display aaa configuration 来确认设备上是否有足够的资源。在AAA方案中，我们需要配置认证方案和援权方案，本实验要求两者都使用本地方案。配置完成后，我们可以使用命令display authentication-scheme来查看配置中的AAA认证方案。在使用AAA本地认证的环境中，我们需要在基于域的配置中设置AAA方案和本地用户。（2）查看系统中的认证方案。
aaa服务器型号,AAA服务器安装调试及配置验证
weixin_27180827的博客
07-31 3826
本次实验主要完成AAA服务器(Server)的安装与调试，客户端(Client)配置，验证以及AAA排错的过程，包括现场完成对SPOTOTM设备中心Rack机架终端服务器的配置。实验1：AAA服务器安装调试，客户端配置验证实验环境一台CISCO2501路由器，作为AAA服务器的客服端，一台内网的PC机作为AAA服务器端，PC机上面安装又Ciscosectuer ASC软件。实验要求：安装服务器(A...
0基础学RS（九）思科AAA认证的本地AAA认证
weixin_45816894的博客
04-11 7883
AAA概述 AAA是认证（Authentication）、授权（Authorization）和计费（Accounting）的简称，是网络安全中进行访问控制的一种安全管理机制，提供认证、授权和计费三种安全服务。 AAA认证模式 本地AAA认证 基于服务器的AAA认证 本地AAA认证 本地AAA会在网络设备（如思科路由器）本地保存用户名和密码。用户向本地数据库认证自己的身份，如图所示。本地 AAA 是小型网络的理想选择。 使用CLI配置本地AAA认证 配置本地AAA认证步骤 配置用户名和密码 在路由器上全
aaa.rar_593aaa. com_ecshop_www .aaa709.com_www.aaa 647.com_商城
09-24
标题中的"aaa.rar_593aaa.com_ecshop_www.aaa709.com_www.aaa647.com_商城"暗示了我们正在探讨的是一个经过个性化修改的ECSHOP商城项目，其中涉及到的域名可能与多个站点相关联，如593aaa.com、aaa709.com和aaa647....
AAA.zip_3344aaa在线观看_aaa8x8x
09-24
【标题】"AAA.zip_3344aaa在线观看_aaa8x8x" 提供的信息主要涉及到一个基于VHDL语言设计的16x8 ROM（只读存储器）项目，而“3344aaa在线观看_aaa8x8x”这部分看起来像是无关的标签，可能是某种错误或者误输入，因此...
AAA飞机设计软件.pdf
10-20
AAA飞机设计软件.pdf AAA飞机设计软件是一个功能强大且专业的飞机设计分析软件，旨在帮助飞机设计师、学生和研究人员快速、准确地进行飞机设计、分析和优化。下面是AAA飞机设计软件的详细知识点： 1.飞机设计分析...
aaa.rar_播放器aaa
09-14
本文将深入探讨"aaa.rar_播放器aaa"这一主题，主要关注JMF播放器的源代码及其运行机制，帮助开发者更好地理解和运用这个平台。 JMF，全称为Java Media Framework，是Sun Microsystems公司开发的一个用于处理音频、...
MyBatis 源码解析：XMLScriptBuilder 工作机制
最新发布
qq_40254606的博客
09-08 862
MyBatis 提供了强大的动态 SQL 功能，它通过解析 XML 配置文件中的动态 SQL 标签（如 、、 等），来实现灵活的 SQL 生成。而 XMLScriptBuilder 类则负责解析这些 XML 配置并生成最终的 SQL 语句。本文将详细解析 XMLScriptBuilder 的工作机制，并通过自定义实现来帮助您深入理解该类的功能。
[杂项]pugi::xml获取xml中的注释节点
qq_47500842的博客
09-08 216
pugixml 获取xml中的注释节点
Java XML
m0_46977298的博客
09-08 524
配置文件：用来保存设置的一些东西。拿IDEA来举例，比如设置的背景图片，字体信息，字号信息和主题信息等等。（1）以前是用txt保存的，没有任何优点，而且不利于阅读，因为只保存了值，值所代表的含义却不清楚。（2）后面又提出了properties文件，是以键值对的形式存储数据的，但是对于多个用户的同一个信息来说的话，只能以一个键值对来进行存储，无法为同一个信息配置多个键值对。（3）所以现在来学习xml文件。xml文件可解决这个问题。xml是可扩展的标记语言，那什么是可扩展？什么是标记语言？
xml转txt，适应各种图片格式，如jpg，png，jpeg，PNG，JPEG等
weixin_45734021的博客
09-03 444
xml转txt，适应各种图片格式，如jpg，png，jpeg，PNG，JPEG等。
Cisco ACS AAA认证深度解析
"Cisco ACS AAA认证详解" Cisco ACS（Cisco Secure Access Control Server）是一种强大的网络访问控制解决方案，主要用于实现网络中的认证、授权和记账（AAA）功能。AAA是网络安全管理的核心，确保只有合法用户能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值