C#自定义处理xml数据类实例

本文实例讲述了C#自定义处理xml数据类。分享给大家供大家参考。具体分析如下:

这个C#类专门用户处理xml数据,可以大大简化xml的操作,类中封装了常用的xml操作,包括打开、读取xml数据,读取、写入节点数据,通过xpath读取节点数据,导出节点数据等等,还可以根据需要自己扩充类的功能。

using System;
using System.Data;
using System.IO;
using System.Xml;
namespace DotNet.Utilities
{
  public class XMLProcess
  {
    #region 构造函数
    public XMLProcess()
    { }
    public XMLProcess(string strPath)
    {
      this._XMLPath = strPath;
    }
    #endregion
    #region 公有属性
    private string _XMLPath;
    public string XMLPath
    {
      get { return this._XMLPath; }
    }
    #endregion
    #region 私有方法
    /// <summary>
    /// 导入XML文件
    /// </summary>
    /// <param name="XMLPath">XML文件路径</param>
    private XmlDocument XMLLoad()
    {
      string XMLFile = XMLPath;
      XmlDocument xmldoc = new XmlDocument();
      try
      {
        string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + XMLFile;
        if (File.Exists(filename)) xmldoc.Load(filename);
      }
      catch (Exception e)
      { }
      return xmldoc;
    }
    /// <summary>
    /// 导入XML文件
    /// </summary>
    /// <param name="XMLPath">XML文件路径</param>
    private static XmlDocument XMLLoad(string strPath)
    {
      XmlDocument xmldoc = new XmlDocument();
      try
      {
        string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + strPath;
        if (File.Exists(filename)) xmldoc.Load(filename);
      }
      catch (Exception e)
      { }
      return xmldoc;
    }
    /// <summary>
    /// 返回完整路径
    /// </summary>
    /// <param name="strPath">Xml的路径</param>
    private static string GetXmlFullPath(string strPath)
    {
      if (strPath.IndexOf(":") > 0)
      {
        return strPath;
      }
      else
      {
        return System.Web.HttpContext.Current.Server.MapPath(strPath);
      }
    }
    #endregion
    #region 读取数据
    /// <summary>
    /// 读取指定节点的数据
    /// </summary>
    /// <param name="node">节点</param>
    /// 使用示列:
    /// XMLProsess.Read("/Node", "")
    /// XMLProsess.Read("/Node/Element[@Attribute='Name']")
    public string Read(string node)
    {
      string value = "";
      try
      {
        XmlDocument doc = XMLLoad();
        XmlNode xn = doc.SelectSingleNode(node);
        value = xn.InnerText;
      }
      catch { }
      return value;
    }
    /// <summary>
    /// 读取指定路径和节点的串联值
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="attribute">属性名,非空时返回该属性值,否则返回串联值</param>
    /// 使用示列:
    /// XMLProsess.Read(path, "/Node", "")
    /// XMLProsess.Read(path, "/Node/Element[@Attribute='Name']")
    public static string Read(string path, string node)
    {
      string value = "";
      try
      {
        XmlDocument doc = XMLLoad(path);
        XmlNode xn = doc.SelectSingleNode(node);
        value = xn.InnerText;
      }
      catch { }
      return value;
    }
    /// <summary>
    /// 读取指定路径和节点的属性值
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="attribute">属性名,非空时返回该属性值,否则返回串联值</param>
    /// 使用示列:
    /// XMLProsess.Read(path, "/Node", "")
    /// XMLProsess.Read(path, "/Node/Element[@Attribute='Name']", "Attribute")
    public static string Read(string path, string node, string attribute)
    {
      string value = "";
      try
      {
        XmlDocument doc = XMLLoad(path);
        XmlNode xn = doc.SelectSingleNode(node);
        value = (attribute.Equals("") ? xn.InnerText : xn.Attributes[attribute].Value);
      }
      catch { }
      return value;
    }
    /// <summary>
    /// 获取某一节点的所有孩子节点的值
    /// </summary>
    /// <param name="node">要查询的节点</param>
    public string[] ReadAllChildallValue(string node)
    {
      int i = 0;
      string[] str = { };
      XmlDocument doc = XMLLoad();
      XmlNode xn = doc.SelectSingleNode(node);
      XmlNodeList nodelist = xn.ChildNodes; //得到该节点的子节点
      if (nodelist.Count > 0)
      {
        str = new string[nodelist.Count];
        foreach (XmlElement el in nodelist)//读元素值
        {
          str[i] = el.Value;
          i++;
        }
      }
      return str;
    }
    /// <summary>
    /// 获取某一节点的所有孩子节点的值
    /// </summary>
    /// <param name="node">要查询的节点</param>
    public XmlNodeList ReadAllChild(string node)
    {
      XmlDocument doc = XMLLoad();
      XmlNode xn = doc.SelectSingleNode(node);
      XmlNodeList nodelist = xn.ChildNodes; //得到该节点的子节点
      return nodelist;
    }
    /// <summary>
    /// 读取XML返回经排序或筛选后的DataView
    /// </summary>
    /// <param name="strWhere">筛选条件,如:"name='kgdiwss'"</param>
    /// <param name="strSort"> 排序条件,如:"Id desc"</param>
    public DataView GetDataViewByXml(string strWhere, string strSort)
    {
      try
      {
        string XMLFile = this.XMLPath;
        string filename = AppDomain.CurrentDomain.BaseDirectory.ToString() + XMLFile;
        DataSet ds = new DataSet();
        ds.ReadXml(filename);
        DataView dv = new DataView(ds.Tables[0]); //创建DataView来完成排序或筛选操作
        if (strSort != null)
        {
          dv.Sort = strSort; //对DataView中的记录进行排序
        }
        if (strWhere != null)
        {
          dv.RowFilter = strWhere; //对DataView中的记录进行筛选,找到我们想要的记录
        }
        return dv;
      }
      catch (Exception)
      {
        return null;
      }
    }
    /// <summary>
    /// 读取XML返回DataSet
    /// </summary>
    /// <param name="strXmlPath">XML文件相对路径</param>
    public DataSet GetDataSetByXml(string strXmlPath)
    {
      try
      {
        DataSet ds = new DataSet();
        ds.ReadXml(GetXmlFullPath(strXmlPath));
        if (ds.Tables.Count > 0)
        {
          return ds;
        }
        return null;
      }
      catch (Exception)
      {
        return null;
      }
    }
    #endregion
    #region 插入数据
    /// <summary>
    /// 插入数据
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="element">元素名,非空时插入新元素,否则在该元素中插入属性</param>
    /// <param name="attribute">属性名,非空时插入该元素属性值,否则插入元素值</param>
    /// <param name="value">值</param>
    /// 使用示列:
    /// XMLProsess.Insert(path, "/Node", "Element", "", "Value")
    /// XMLProsess.Insert(path, "/Node", "Element", "Attribute", "Value")
    /// XMLProsess.Insert(path, "/Node", "", "Attribute", "Value")
    public static void Insert(string path, string node, string element, string attribute, string value)
    {
      try
      {
        XmlDocument doc = new XmlDocument();
        doc.Load(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
        XmlNode xn = doc.SelectSingleNode(node);
        if (element.Equals(""))
        {
          if (!attribute.Equals(""))
          {
            XmlElement xe = (XmlElement)xn;
            xe.SetAttribute(attribute, value);
          }
        }
        else
        {
          XmlElement xe = doc.CreateElement(element);
          if (attribute.Equals(""))
            xe.InnerText = value;
          else
            xe.SetAttribute(attribute, value);
          xn.AppendChild(xe);
        }
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
      }
      catch { }
    }
    /// <summary>
    /// 插入数据
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="element">元素名,非空时插入新元素,否则在该元素中插入属性</param>
    /// <param name="strList">由XML属性名和值组成的二维数组</param>
    public static void Insert(string path, string node, string element, string[][] strList)
    {
      try
      {
        XmlDocument doc = new XmlDocument();
        doc.Load(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
        XmlNode xn = doc.SelectSingleNode(node);
        XmlElement xe = doc.CreateElement(element);
        string strAttribute = "";
        string strValue = "";
        for (int i = 0; i < strList.Length; i++)
        {
          for (int j = 0; j < strList[i].Length; j++)
          {
            if (j == 0)
              strAttribute = strList[i][j];
            else
              strValue = strList[i][j];
          }
          if (strAttribute.Equals(""))
            xe.InnerText = strValue;
          else
            xe.SetAttribute(strAttribute, strValue);
        }
        xn.AppendChild(xe);
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
      }
      catch { }
    }
    /// <summary>
    /// 插入一行数据
    /// </summary>
    /// <param name="strXmlPath">XML文件相对路径</param>
    /// <param name="Columns">要插入行的列名数组,如:string[] Columns = {"name","IsMarried"};</param>
    /// <param name="ColumnValue">要插入行每列的值数组,如:string[] ColumnValue={"XML大全","false"};</param>
    /// <returns>成功返回true,否则返回false</returns>
    public static bool WriteXmlByDataSet(string strXmlPath, string[] Columns, string[] ColumnValue)
    {
      try
      {
        //根据传入的XML路径得到.XSD的路径,两个文件放在同一个目录下
        string strXsdPath = strXmlPath.Substring(0, strXmlPath.IndexOf(".")) + ".xsd";
        DataSet ds = new DataSet();
        ds.ReadXmlSchema(GetXmlFullPath(strXsdPath)); //读XML架构,关系到列的数据类型
        ds.ReadXml(GetXmlFullPath(strXmlPath));
        DataTable dt = ds.Tables[0];
        DataRow newRow = dt.NewRow(); //在原来的表格基础上创建新行
        for (int i = 0; i < Columns.Length; i++) //循环给一行中的各个列赋值
        {
          newRow[Columns[i]] = ColumnValue[i];
        }
        dt.Rows.Add(newRow);
        dt.AcceptChanges();
        ds.AcceptChanges();
        ds.WriteXml(GetXmlFullPath(strXmlPath));
        return true;
      }
      catch (Exception)
      {
        return false;
      }
    }
    #endregion
    #region 修改数据
    /// <summary>
    /// 修改指定节点的数据
    /// </summary>
    /// <param name="node">节点</param>
    /// <param name="value">值</param>
    public void Update(string node, string value)
    {
      try
      {
        XmlDocument doc = XMLLoad();
        XmlNode xn = doc.SelectSingleNode(node);
        xn.InnerText = value;
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + XMLPath);
      }
      catch { }
    }
    /// <summary>
    /// 修改指定节点的数据
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="value">值</param>
    /// 使用示列:
    /// XMLProsess.Insert(path, "/Node","Value")
    /// XMLProsess.Insert(path, "/Node","Value")
    public static void Update(string path, string node, string value)
    {
      try
      {
        XmlDocument doc = XMLLoad(path);
        XmlNode xn = doc.SelectSingleNode(node);
        xn.InnerText = value;
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
      }
      catch { }
    }
    /// <summary>
    /// 修改指定节点的属性值(静态)
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="attribute">属性名,非空时修改该节点属性值,否则修改节点值</param>
    /// <param name="value">值</param>
    /// 使用示列:
    /// XMLProsess.Insert(path, "/Node", "", "Value")
    /// XMLProsess.Insert(path, "/Node", "Attribute", "Value")
    public static void Update(string path, string node, string attribute, string value)
    {
      try
      {
        XmlDocument doc = XMLLoad(path);
        XmlNode xn = doc.SelectSingleNode(node);
        XmlElement xe = (XmlElement)xn;
        if (attribute.Equals(""))
          xe.InnerText = value;
        else
          xe.SetAttribute(attribute, value);
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
      }
      catch { }
    }
    /// <summary>
    /// 更改符合条件的一条记录
    /// </summary>
    /// <param name="strXmlPath">XML文件路径</param>
    /// <param name="Columns">列名数组</param>
    /// <param name="ColumnValue">列值数组</param>
    /// <param name="strWhereColumnName">条件列名</param>
    /// <param name="strWhereColumnValue">条件列值</param>
    public static bool UpdateXmlRow(string strXmlPath, string[] Columns, string[] ColumnValue, string strWhereColumnName, string strWhereColumnValue)
    {
      try
      {
        string strXsdPath = strXmlPath.Substring(0, strXmlPath.IndexOf(".")) + ".xsd";
        DataSet ds = new DataSet();
        ds.ReadXmlSchema(GetXmlFullPath(strXsdPath));//读XML架构,关系到列的数据类型
        ds.ReadXml(GetXmlFullPath(strXmlPath));
        //先判断行数
        if (ds.Tables[0].Rows.Count > 0)
        {
          for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
          {
            //如果当前记录为符合Where条件的记录
            if (ds.Tables[0].Rows[i][strWhereColumnName].ToString().Trim().Equals(strWhereColumnValue))
            {
              //循环给找到行的各列赋新值
              for (int j = 0; j < Columns.Length; j++)
              {
                ds.Tables[0].Rows[i][Columns[j]] = ColumnValue[j];
              }
              ds.AcceptChanges();           //更新DataSet
              ds.WriteXml(GetXmlFullPath(strXmlPath));//重新写入XML文件
              return true;
            }
          }
        }
        return false;
      }
      catch (Exception)
      {
        return false;
      }
    }
    #endregion
    #region 删除数据
    /// <summary>
    /// 删除节点值
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="attribute">属性名,非空时删除该节点属性值,否则删除节点值</param>
    /// <param name="value">值</param>
    /// 使用示列:
    /// XMLProsess.Delete(path, "/Node", "")
    /// XMLProsess.Delete(path, "/Node", "Attribute")
    public static void Delete(string path, string node)
    {
      try
      {
        XmlDocument doc = XMLLoad(path);
        XmlNode xn = doc.SelectSingleNode(node);
        xn.ParentNode.RemoveChild(xn);
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
      }
      catch { }
    }
    /// <summary>
    /// 删除数据
    /// </summary>
    /// <param name="path">路径</param>
    /// <param name="node">节点</param>
    /// <param name="attribute">属性名,非空时删除该节点属性值,否则删除节点值</param>
    /// <param name="value">值</param>
    /// 使用示列:
    /// XMLProsess.Delete(path, "/Node", "")
    /// XMLProsess.Delete(path, "/Node", "Attribute")
    public static void Delete(string path, string node, string attribute)
    {
      try
      {
        XmlDocument doc = XMLLoad(path);
        XmlNode xn = doc.SelectSingleNode(node);
        XmlElement xe = (XmlElement)xn;
        if (attribute.Equals(""))
          xn.ParentNode.RemoveChild(xn);
        else
          xe.RemoveAttribute(attribute);
        doc.Save(AppDomain.CurrentDomain.BaseDirectory.ToString() + path);
      }
      catch { }
    }
    /// <summary>
    /// 删除所有行
    /// </summary>
    /// <param name="strXmlPath">XML路径</param>
    public static bool DeleteXmlAllRows(string strXmlPath)
    {
      try
      {
        DataSet ds = new DataSet();
        ds.ReadXml(GetXmlFullPath(strXmlPath));
        if (ds.Tables[0].Rows.Count > 0)
        {
          ds.Tables[0].Rows.Clear();
        }
        ds.WriteXml(GetXmlFullPath(strXmlPath));
        return true;
      }
      catch (Exception)
      {
        return false;
      }
    }
    /// <summary>
    /// 通过删除DataSet中指定索引行,重写XML以实现删除指定行
    /// </summary>
    /// <param name="iDeleteRow">要删除的行在DataSet中的Index值</param>
    public static bool DeleteXmlRowByIndex(string strXmlPath, int iDeleteRow)
    {
      try
      {
        DataSet ds = new DataSet();
        ds.ReadXml(GetXmlFullPath(strXmlPath));
        if (ds.Tables[0].Rows.Count > 0)
        {
          ds.Tables[0].Rows[iDeleteRow].Delete();
        }
        ds.WriteXml(GetXmlFullPath(strXmlPath));
        return true;
      }
      catch (Exception)
      {
        return false;
      }
    }
    /// <summary>
    /// 删除指定列中指定值的行
    /// </summary>
    /// <param name="strXmlPath">XML相对路径</param>
    /// <param name="strColumn">列名</param>
    /// <param name="ColumnValue">指定值</param>
    public static bool DeleteXmlRows(string strXmlPath, string strColumn, string[] ColumnValue)
    {
      try
      {
        DataSet ds = new DataSet();
        ds.ReadXml(GetXmlFullPath(strXmlPath));
        if (ds.Tables[0].Rows.Count > 0)
        {
          //判断行多还是删除的值多,多的for循环放在里面
          if (ColumnValue.Length > ds.Tables[0].Rows.Count)
          {
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
              for (int j = 0; j < ColumnValue.Length; j++)
              {
                if (ds.Tables[0].Rows[i][strColumn].ToString().Trim().Equals(ColumnValue[j]))
                {
                  ds.Tables[0].Rows[i].Delete();
                }
              }
            }
          }
          else
          {
            for (int j = 0; j < ColumnValue.Length; j++)
            {
              for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
              {
                if (ds.Tables[0].Rows[i][strColumn].ToString().Trim().Equals(ColumnValue[j]))
                {
                  ds.Tables[0].Rows[i].Delete();
                }
              }
            }
          }
          ds.WriteXml(GetXmlFullPath(strXmlPath));
        }
        return true;
      }
      catch (Exception)
      {
        return false;
      }
    }
    #endregion
  }
}

希望本文所述对大家的C#程序设计有所帮助。

(0)

相关推荐

  • C#实现实体类和XML相互转换

    一.实体类转换成XML 将实体类转换成XML需要使用XmlSerializer类的Serialize方法,将实体类序列化 public static string XmlSerialize<T>(T obj) { using (StringWriter sw = new StringWriter()) { Type t= obj.GetType(); XmlSerializer serializer = new XmlSerializer(obj.GetType()); serializer.

  • C#中把任意类型的泛型集合转换成SQLXML数据格式的实例

    话不多说,跟着小编一起来看下吧 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data.SqlTypes; using System.Data; using System.Reflection; using System.IO; using System.Xml; namespace CollectionToXml { class Program

  • asp.net类序列化生成xml文件实例详解

    本文实例讲述了asp.net类序列化生成xml文件的方法.分享给大家供大家参考,具体如下: 根据设计的需求需要开发多个商品的API 原XML文件如下: <urlset> <url> <loc>http://www.xxxxx.com/todaydetials.aspx?id=143</loc> <data> <display> <website>爱购114</website> <siteurl>ht

  • Visual Studio 2013如何使XML文件转换成类

    今天给大家带来一个Visual Studio 2013中非常实用的功能,自动生成XML反序列化的类.以往想要在代码中将XML反序列化成对象,我们要么手动创建这些对象(很容易出错),要么借助于第三方的工具来生成Class.而现在,Visual Studio 2013可以自动帮我们完成这个工作.当然,如果你对XML反序列化并不感兴趣,而热衷于使用XElement或者XMLDocument来加载和解析XML,那么你可以忽略本文的内容. 来看看在Visual Sutdio 2013中如何使用这个功能!

  • C#实现XML与实体类之间相互转换的方法(序列化与反序列化)

    本文实例讲述了C#实现XML与实体类之间相互转换的方法.分享给大家供大家参考,具体如下: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using System.Data; using System.Xml; using System.Xml.Serialization; /// <summary> /// Xml序列化与反序列化 //

  • Asp.Net+XML操作基类(修改,删除,新增,创建)第1/2页

    /**********************************************************************************  *   * 功能说明:XML处理基类  * 作者: 刘功勋;  * 版本:V0.1(C#2.0);时间:2006-12-13  *   * *******************************************************************************/ using System;

  • C#自定义处理xml数据类实例

    本文实例讲述了C#自定义处理xml数据类.分享给大家供大家参考.具体分析如下: 这个C#类专门用户处理xml数据,可以大大简化xml的操作,类中封装了常用的xml操作,包括打开.读取xml数据,读取.写入节点数据,通过xpath读取节点数据,导出节点数据等等,还可以根据需要自己扩充类的功能. using System; using System.Data; using System.IO; using System.Xml; namespace DotNet.Utilities { public

  • C#实现的XML操作类实例

    本文实例讲述了C#实现的XML操作类.分享给大家供大家参考.具体如下: 这里讲述了C#写的一个XML操作类,包括读取/插入/修改/删除. 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.W

  • Angular2管道Pipe及自定义管道格式数据用法实例分析

    本文实例讲述了Angular2管道Pipe及自定义管道格式数据用法.分享给大家供大家参考,具体如下: 管道(Pipe)可以根据开发者的意愿将数据格式化,还可以多个管道串联. 纯管道(Pure Pipe)与非纯管道(Impure Pipe) 管道分纯管道(Pure Pipe)和非纯管道(Impure Pipe).默认情况下,管道都是纯的,在自定义管道声明时把pure标志置为false,就是非纯管道.如: @Pipe({ name: 'sexReform', pure:false }) 纯管道和非纯

  • jquery实现可拖动DIV自定义保存到数据的实例

    看到一个不错的jquery插件,可拖动DIV,顺序可保存到数据库的一个实例:这里就以其中PHP实例简单说明一下: 复制代码 代码如下: <?php  //post到后台的数据      if ($_POST) {          $ids = $_POST["ids"];          for ($idx = 0; $idx < count($ids); $idx+=1) {              $id = $ids[$idx];              $o

  • 使用javascript访问XML数据的实例

    在网络浏览器软件中,可以Internet Explorer (IE)现在是一种标准的软件.可以看到,运行不同版本的Windows操作系统(和很多其他的操作系统)的每一台机器几乎都使用IE.微软已经通过ActiveX控件将IE的功能包含在执行成熟的XML处理技术中. 在本篇文章中,我们将讲述如何在IE中使用ActiveX功能来访问并解析XML文档,由此允许网络冲浪者操纵它们. 网上冲浪 我们以一个标准的顺序文档而开始,如表A所示.这一文档包含简单的顺序数据以提供网络冲浪者浏览之用.不仅仅为了显示这

  • PHP读取配置文件类实例(可读取ini,yaml,xml等)

    本文实例讲述了PHP读取配置文件类实例.分享给大家供大家参考.具体如下: <?php class Settings { var $_settings = array (); function get($var) { $var = explode ( '.', $var ); $result = $this->_settings; foreach ( $var as $key ) { if (! isset ( $result [$key] )) { return false; } $resul

  • C#实现的xml操作类完整实例

    本文实例讲述了C#实现的xml操作类,分享给大家供大家参考,具体如下: 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

  • C#程序中使用LINQ to XML来查询XML格式数据的实例

    关于LINQ to XML LINQ to XML 是一种启用了 LINQ 的内存 XML 编程接口,使用它,可以在 .NET Framework 编程语言中处理 XML. 它将 XML 文档置于内存中,这一点很像文档对象模型 (DOM). 您可以查询和修改 XML 文档,修改之后,可以将其另存为文件,也可以将其序列化然后通过网络发送. 但是,LINQ to XML 与 DOM 不同: 它提供一种新的对象模型,这是一种更轻量的模型,使用也更方便,这种模型利用了 VisualC# 2008 在语言

  • java常用工具类 XML工具类、数据验证工具类

    本文实例为大家分享了java常用工具类的具体代码,供大家参考,具体内容如下 package com.jarvis.base.util; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.StringReader; import java.io.StringWriter; import java.net.URL; import java.util.Properties

  • java自定义Scanner类似功能类的实例讲解

    读取键盘输入 package com.zjx.io; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; /** * 面试题 * 读取键盘各个数据类型 * */ public class TestFaceIo { public static void main(String[] args) { System.out.print("请输入姓名: "); S

随机推荐