今天要介紹的就是sql2005的xml字段類型在.net中的應用。調用過程是：先運用并行化的辦法把xml字段類型中的數據轉換成model對象，對model對象操作后，再運用串行化的方法把model對象轉變成xml格式，最后存儲到數據庫中。
       我認為如果把復雜的業務關系數據存儲在xml字段中，可簡化數據庫的設計，方便業務的處理。

       這里寫了個小demo：
     
      假如我們有很多店鋪信息，每個店鋪都有一個shopid， 所以我們就把同一店鋪的信息放在以shopid命名的文件夾下，當一臺服務器放不下時，我們就部署多臺，這樣每臺服務器存儲的店鋪是不一樣的。這些服務器就構成了一個服務器群。出于需要，我們要把這個群復制多個，部署在不同的地區（注意，各個群的信息是相同的）。為了完成這個目的，我們先設計了數據模型 mservergroup（服務器群信息），mserver（服務器群下的服務器信息），mservershop（服務器對應的店鋪）：

    /// <summary>
    /// 服務器群信息
    /// </summary>
    /// <remarks>
    /// 用于存放點播文件服務器群的信息,比如主站的,北京站的,上海站的;各個站的數據相同.
    /// 服務器群的目的是分散數據庫的壓力.
    /// 目前只有主站的.
    /// </remarks>
    [serializable()]
    public class mservergroup : basemodelentity
    {
        #region private
        private int _servergroupid;
        private string _servergroupname;
        private mservercollection _servers;
        #endregion

        #region constructor
        /// <summary>
        /// 服務器群信息
        /// </summary>
        public mservergroup()
        {
        }

        /// <summary>
        /// 服務器群信息
        /// </summary>
        /// <param name="_servergroupid">服務器群id</param>
        /// <param name="_servergroupname">服務器群名稱</param>
        public mservergroup(int _servergroupid, string _servergroupname)
        {
            this._servergroupid = _servergroupid;
            this._servergroupname = _servergroupname;
        }
        #endregion

        #region property
        /// <summary>
        /// 服務器群id
        /// </summary>
        public int servergroupid
        {
            get
            {
                return _servergroupid;
            }
            set
            {
                this._servergroupid = value;
            }
        }

        /// <summary>
        /// 服務器群名稱
        /// </summary>
        public string servergroupname
        {
            get
            {
                return _servergroupname;
            }
            set
            {
                this._servergroupname = value;
            }
        }

        /// <summary>
        /// 服務器群下的服務器集合
        /// </summary>
        public mservercollection servers
        {
            get
            {
                return _servers;
            }
            set
            {
                this._servers = value;
            }
        }
        #endregion
    }

    /// <summary>
    /// 服務器群下的服務器信息
    /// </summary>
    /// <remarks>
    /// 用于存放點播文件的服務信息
    /// </remarks>
    [serializable()]
    public class mserver : basemodelentity
    {
        #region private
        private int _serverid;
        private string _servername;
        private string _ip;
        private string _domainname;
        private string _dir;
        private string _url;
        private int _servergroupid;
        private mservershopcollection _servershops;
        #endregion

        #region constructor
        /// <summary>
        /// 服務器信息
        /// </summary>
        public mserver()
        {
        }

        /// <summary>
        /// 服務器信息
        /// </summary>
        /// <param name="_serverid">服務器id</param>
        /// <param name="_servername">服務器名稱</param>
        /// <param name="_ip">服務器ip</param>
        /// <param name="_domainname">服務器域名</param>
        /// <param name="_dir">文件存放目錄</param>
        /// <param name="_url">文件存放url</param>
        /// <param name="_servergroupid">對應的服務器群id</param>
        /// <param name="_servershops">服務器對應的店鋪信息</param>
        public mserver(int _serverid, string _servername, string _ip, string _domainname, string _dir, string _url, int _servergroupid, mservershopcollection _servershops)
        {
            this._serverid = _serverid;
            this._servername = _servername;
            this._ip = _ip;
            this._domainname = _domainname;
            this._dir = _dir;
            this._url = _url;
            this._servergroupid = _servergroupid;
            this._servershops = _servershops;
        }

        /// <summary>
        /// 服務器信息
        /// </summary>
        /// <param name="_serverid">服務器id</param>
        /// <param name="_servername">服務器名稱</param>
        /// <param name="_ip">服務器ip</param>
        /// <param name="_domainname">服務器域名</param>
        /// <param name="_dir">文件存放目錄</param>
        /// <param name="_url">文件存放url</param>
        /// <param name="_servergroupid">對應的服務器群id</param>
        /// <param name="_xmlstrservershops">服務器對應的店鋪信息的xml字符串</param>
        public mserver(int _serverid, string _servername, string _ip, string _domainname, string _dir, string _url, int _servergroupid, string _xmlstrservershops)
        {
            this._serverid = _serverid;
            this._servername = _servername;
            this._ip = _ip;
            this._domainname = _domainname;
            this._dir = _dir;
            this._url = _url;
            this._servergroupid = _servergroupid;
            this._servershops = common.utilities.serializationhelper<mservershopcollection>.fromxml(_xmlstrservershops);
        }
        #endregion

        #region property
        /// <summary>
        /// 服務器id
        /// </summary>
        public int serverid
        {
            get
            {
                return _serverid;
            }
            set
            {
                this._serverid = value;
            }
        }

        /// <summary>
        /// 服務器名稱
        /// </summary>
        public string servername
        {
            get
            {
                return _servername;
            }
            set
            {
                this._servername = value;
            }
        }

        /// <summary>
        /// 服務器ip
        /// </summary>
        public string ip
        {
            get
            {
                return _ip;
            }
            set
            {
                this._ip = value;
            }
        }

        /// <summary>
        /// 服務器域名
        /// </summary>
        public string domainname
        {
            get
            {
                return _domainname;
            }
            set
            {
                this._domainname = value;
            }
        }

        /// <summary>
        /// 文件存放目錄
        /// </summary>
        public string dir
        {
            get
            {
                return dir;
            }
            set
            {
                this.dir = value;
            }
        }

        /// <summary>
        /// 文件存放url
        /// </summary>
        public string url
        {
            get
            {
                return _url;
            }
            set
            {
                this._url = value;
            }
        }

        /// <summary>
        /// 對應的服務器群id
        /// </summary>
        public int servergroupid
        {
            get
            {
                return _servergroupid;
            }
            set
            {
                this._servergroupid = value;
            }
        }

        /// <summary>
        /// 服務器對應的店鋪信息
        /// </summary>
        public mservershopcollection servershops
        {
            get
            {
                return _servershops;
            }
            set
            {
                this._servershops = value;
            }
        }
        #endregion
    }
      

    /// <summary>
    /// 服務器對應的店鋪
    /// </summary>
    /// <remarks>
    /// 用于存放和服務器對應的店鋪
    /// </remarks>
    [serializable()]
    [xmlroot(elementname = "shop", namespace = "http://www.linkedu.com.cn/mservershop.xsd")]
    public class mservershop : basemodelentity
    {
        #region private
        private int _shopid;
        private string _shopname;
        #endregion

        #region constructor
        /// <summary>
        /// 服務器對應的店鋪信息
        /// </summary>
        public mservershop()
        {
        }

        /// <summary>
        /// 服務器對應的店鋪信息
        /// </summary>
        /// <param name="_shopid">店鋪id</param>
        /// <param name="_shopname">店鋪名稱</param>
        public mservershop(int _shopid, string _shopname)
        {
            this._shopid = _shopid;
            this._shopname = _shopname;
        }
        #endregion

        #region property
        /// <summary>
        /// 店鋪id
        /// </summary>
        [xmlattribute]
        public int shopid
        {
            get
            {
                return _shopid;
            }
            set
            {
                this._shopid = value;
            }
        }

        /// <summary>
        /// 店鋪名稱
        /// </summary>
        [xmlattribute]
        public string shopname
        {
            get
            {
                return _shopname;
            }
            set
            {
                this._shopname = value;
            }
        }
        #endregion
    }

   為了對模型的集合信息進行描述，我們有設計了mservergroupcollection（服務器群信息集合），mserver（服務器群下的服務器信息），mservershopcollection（服務器對應的店鋪集合）

    /// <summary>
    /// 服務器群信息集合
    /// </summary>
    /// <remarks>
    [serializable()]
    [xmlroot("servergroups")]
    public class mservergroupcollection : list<mservergroup>
    {
        /// <summary>
        /// 服務器群信息集合
        /// </summary>
        public mservergroupcollection()
        {
            this._mservergroups = new list<mservergroup>();
        }

        private list<mservergroup> _mservergroups;

        public list<mservergroup> mservergroups
        {
            get
            {
                return this._mservergroups;
            }
            set
            {
                this._mservergroups = value;
            }
        }
    }

    /// <summary>
    /// 服務器群下的服務器信息集合
    /// </summary>
    [xmlroot("servers")]
    [serializable()]
    public class mservercollection : list<mserver>
    {
        /// <summary>
        /// 服務器群下的服務器信息集合
        /// </summary>
        public mservercollection()
        {
            this._mservers = new list<mserver>();
        }

        private list<mserver> _mservers;

        public list<mserver> mservers
        {
            get
            {
                return this._mservers;
            }
            set
            {
                this._mservers = value;
            }
        }
    }

    /// <summary>
    /// 服務器對應的店鋪集合
    /// </summary>
    [serializable()]
    [xmlroot(elementname = "shops", namespace = "http://www.linkedu.com.cn/mservershop.xsd")]
    public class mservershopcollection
    {
        private list<mservershop> _mservershops;

        [xmlelement("shop")]
        public list<mservershop> mservershops
        {
            get
            {
                return this._mservershops;
            }
            set
            {
                this._mservershops = value;
            }
        }
        /// <summary>
        /// 服務器對應的店鋪集合類
        /// </summary>
        public mservershopcollection()
        {
            this._mservershops = new list<mservershop>();
        }

    }

經分析，服務器對應的店鋪信息可用xml存儲，設計格式如下（用xsd描述，設計好后，我們把它創建到數據庫中）
create xml schema collection [dbo].[mservershop] as
n'<xsd:schema xmlns:xsd="http://www.w3.org/2001/xmlschema" xmlns:t="http://www.linkedu.com.cn/mservershop.xsd" targetnamespace="http://www.linkedu.com.cn/mservershop.xsd" elementformdefault="qualified">
<xsd:element name="shops">
  <xsd:complextype>
     <xsd:complexcontent>
       <xsd:restriction base="xsd:anytype">
          <xsd:sequence>
             <xsd:element name="shop" type="t:servershop" minoccurs="0" maxoccurs="unbounded" />
          </xsd:sequence>
       </xsd:restriction>
    </xsd:complexcontent>
  </xsd:complextype>
</xsd:element>
<xsd:complextype name="servershop">
  <xsd:complexcontent>
   <xsd:restriction base="xsd:anytype">
    <xsd:sequence />
      <xsd:attribute name="shopid" type="xsd:int" use="required" />
      <xsd:attribute name="shopname" type="xsd:string" use="required" />
    </xsd:restriction>
  </xsd:complexcontent>
</xsd:complextype>
</xsd:schema>'

最后，我設計了（服務器群信息 es_servergroup），（服務器群下的服務器信息 es_server）的數據表, 在 es_server 數據表中，我們把服務器對應的店鋪信息放在es_server數據表下用xml表示，并加入上邊設計的xsd約束。 

create table [dbo].[es_servergroup](
 [servergroupid] [int] not null,
 [servergroupname] [nvarchar](20) collate chinese_prc_ci_as not null,
 constraint [pk_es_servergroup] primary key clustered
(
 [servergroupid] asc
)with (ignore_dup_key = off) on [primary]
) on [primary]

create table [dbo].[es_server](
 [serverid] [int] not null,
 [servergroupid] [int] null,
 [servername] [nvarchar](20) collate chinese_prc_ci_as not null,
 [ip] [nvarchar](15) collate chinese_prc_ci_as null,
 [domainname] [nvarchar](20) collate chinese_prc_ci_as null,
 [dir] [nvarchar](255) collate chinese_prc_ci_as null,
 [url] [nvarchar](255) collate chinese_prc_ci_as null,
 [servershops] [xml](content [dbo].[mservershop]) null,
 constraint [pk_es_server] primary key clustered
(
 [serverid] asc
)with (ignore_dup_key = off) on [primary]
) on [primary]

下一步，我開始設計數據訪問接口，然后設計數據訪問層和業務層，最后設計表現層。
為了演示方便，demo中我省去了接口的書寫和業務層，我在表現層直接調用了數據訪問層

數據訪問層代碼如下：

    /// <summary>
    /// 服務器群下的服務器信息數據訪問層
    /// </summary>
    public class dserver
    {
        #region constructor
        public dserver()
        {
        }
        #endregion

        #region public method

        #region 得到當前

        #region 得到某服務器信息 mserver getmserver(int _serverid)
        /// <summary>
        /// 得到某服務器信息
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <returns>得到某服務器信息</returns>
        public mserver getmserver(int _serverid)
        {
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.addsql("select * from es_server where ");
                m.addsql(" serverid=");
                m.addsql("serverid", _serverid);
                using (idatareader idr = m.executereader(conn))
                {
                    if (idr.read())
                    {
                        return new mserver(_serverid, idr["servername"].tostring(), idr["ip"].tostring(), idr["domainname"].tostring(), idr["dir"].tostring(), idr["url"].tostring(), (int)idr["servergroupid"], idr["servershops"].tostring());
                    }
                }
                return null;
            }
        }
        #endregion

        #region 關于mservershop的操作

        #region 得到服務器對應的店鋪集合 mservershopcollection getmservershop(int _serverid)
        /// <summary>
        /// 得到服務器對應的店鋪集合
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <returns>得到服務器對應的店鋪數組</returns>
        public mservershopcollection getmservershop(int _serverid)
        {
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.addsql("select servershops from es_server where ");
                m.addsql(" serverid=");
                m.addsql("serverid", _serverid);
                string xmlstr = m.executescalar(conn).tostring();
                return common.utilities.serializationhelper<mservershopcollection>.fromxml(xmlstr);
            }
        }
        #endregion

        #region 保存服務器對應的店鋪信息 void savemservershops(int _serverid, mservershopcollection _servershops)
        /// <summary>
        /// 保存服務器對應的店鋪信息
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <param name="_servershops">服務器對應的店鋪信息集合</param>
        public void savemservershops(int _serverid, mservershopcollection _servershops)
        {
            string xmlstr = common.utilities.serializationhelper<mservershopcollection>.toxml(_servershops);
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.addsql("update es_server set servershops=n'");
                m.addsql(xmlstr);
                m.addsql("' where serverid=");
                m.addsql(_serverid.tostring());
                m.executenonquery(conn);
            }
        }
        #endregion

        #region 添加服務器對應的店鋪信息 void addmservershop(int _serverid, mservershop _servershop)
        /// <summary>
        /// 添加服務器對應的店鋪信息
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <param name="_servershop">服務器對應的店鋪信息</param>
        public void addmservershop(int _serverid, mservershop _servershop)
        {
            //update es_server set servershops.modify('declare namespace mi="http://www.linkedu.com.cn/mservershop.xsd";  insert (<mi:shop shopid="3" shopname="hopname3" />) as first into (//mi:shops)[1]') where serverid=1
            //select serverid from es_server where serverid=1  and servershops.exist('declare namespace mi="http://www.linkedu.com.cn/mservershop.xsd"; //mi:shops/mi:shop[@shopid=4]')=1
            //select servershops.value('declare namespace mi="http://www.linkedu.com.cn/mservershop.xsd"; (//mi:shops/mi:shop/@shopid)[1]=4', 'bit') as shopid from es_server where serverid=1 if @@rowcount > 0 begin select 1 end
             string xmlstr = common.utilities.serializationhelper<mservershop>.toxml(_servershop, "mi");
             dataprovider dp = sqltools.helpwww.dataprovideruse;
             using (idbconnection conn = dp.getconnection())
             {
                 common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                 common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                 m.addsql("select serverid from es_server where serverid=" + _serverid.tostring());
                 m.addsql(" and servershops.exist('declare namespace mi=/"http://www.linkedu.com.cn/mservershop.xsd/"; //mi:shops/mi:shop[@shopid=" + _servershop.shopid.tostring() + "]')=1");
                 m.addsql(" if @@rowcount = 0 begin ");
                 m.addsql("update es_server set servershops.modify('declare namespace mi=/"http://www.linkedu.com.cn/mservershop.xsd/";  insert (");
                 m.addsql(xmlstr);
                 m.addsql(") as first into (//mi:shops)[1]') where serverid=" + _serverid.tostring() + " end");
                 m.executenonquery(conn);
             }
        }
        #endregion

        #region 刪除服務器對應的店鋪信息 void deletemservershop(int _serverid, int _shopid)
        /// <summary>
        /// 刪除服務器對應的店鋪信息
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <param name="_shopid">店鋪id</param>
        public void deletemservershop(int _serverid, int _shopid)
        {
            /*
             update es_server
                set servershops.modify('declare namespace mi="http://www.linkedu.com.cn/mservershop.xsd";
                    delete /mi:shops/mi:shop[@shopid=1]') where serverid=1
             */
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.addsql("update es_server set servershops.modify('declare namespace mi=/"http://www.linkedu.com.cn/mservershop.xsd/";delete /mi:shops/mi:shop[@shopid=" + _shopid + "]') where serverid=" + _serverid);
                m.executenonquery(conn);
            }
        }
        #endregion

        #region 修改服務器對應的店鋪信息 void modifymservershop(int _serverid, mservershop _servershop)
        /// <summary>
        /// 修改服務器對應的店鋪信息
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <param name="_servershop">服務器對應的店鋪信息,其中以_servershop的shopid屬性為主鍵</param>
        public void modifymservershop(int _serverid, mservershop _servershop)
        {
            //update es_server set servershops.modify('declare namespace mi="http://www.linkedu.com.cn/mservershop.xsd";replace value of (/mi:shops/mi:shop[@shopid=128780281]/@shopname)[1] with "shopnamex"') where serverid=1
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.addsql("update es_server set servershops.modify('declare namespace mi=/"http://www.linkedu.com.cn/mservershop.xsd/";replace value of (/mi:shops/mi:shop[@shopid=" + _servershop.shopid + "]/@shopname)[1] with /"" + _servershop.shopname + "/"') where serverid=" + _serverid);
                m.executenonquery(conn);
            }
        }
        #endregion

        #endregion

        #endregion

        #region 增刪改
        #region 添加服務器信息 int add(int _serverid, string _servername, string _ip, string _domainname, string _dir, string _url, int _servergroupid)
        /// <summary>
        /// 添加服務器信息
        /// </summary>
        /// <param name="_serverid">服務器id</param>
        /// <param name="_servername">服務器名稱</param>
        /// <param name="_ip">服務器ip</param>
        /// <param name="_domainname">服務器域名</param>
        /// <param name="_dir">文件存放目錄</param>
        /// <param name="_url">文件存放url</param>
        /// <param name="_servergroupid">對應的服務器群id</param>
        /// <param name="_servershops">服務器對應的店鋪信息</param>
        /// <returns>新加服務器是否成功</returns>
        public bool add(int _serverid, string _servername, string _ip, string _domainname, string _dir, string _url, int _servergroupid)
        {
             dataprovider dp = sqltools.helpwww.dataprovideruse;
             using (idbconnection conn = dp.getconnection())
             {
                 common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                 common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                 common.utilities.listdic<string, object> ld = new common.utilities.listdic<string, object>();
                 ld.add("serverid", _serverid);
                 ld.add("servername", _servername);
                 ld.add("ip", _ip);
                 ld.add("domainname", _domainname);
                 ld.add("dir", _dir);
                 ld.add("url", _url);
                 ld.add("servergroupid", _servergroupid);
                 m.insert(ld, "es_server");
                 return m.executenonquery(conn) > 0;
             }
        }
        #endregion

        #region 修改服務器信息 bool modify(int _serverid, string _servername, string _ip, string _domainname, string _dir, string _url, int _servergroupid)
        /// <summary>
        /// 修改服務器信息
        /// </summary>
        /// <param name="_serverid">服務器id</param>
        /// <param name="_servername">服務器名稱</param>
        /// <param name="_ip">服務器ip</param>
        /// <param name="_domainname">服務器域名</param>
        /// <param name="_dir">文件存放目錄</param>
        /// <param name="_url">文件存放url</param>
        /// <param name="_servergroupid">對應的服務器群id</param>
        /// <param name="_servershops">服務器對應的店鋪信息</param>
        /// <returns>是否成功</returns>
        public bool modify(int _serverid, string _servername, string _ip, string _domainname, string _dir, string _url, int _servergroupid)
        {
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                common.utilities.listdic<string, object> ld = new common.utilities.listdic<string, object>();
                ld.add("servername", _servername);
                ld.add("ip", _ip);
                ld.add("domainname", _domainname);
                ld.add("dir", _dir);
                ld.add("url", _url);
                ld.add("servergroupid", _servergroupid);
                m.update(ld, "es_server");
                m.addsql(" where serverid=");
                m.addsql("serverid", _serverid);

                return m.executenonquery(conn) > 0;
            }
        }
        #endregion

        #region 刪除服務器信息 bool delete(int _serverid)
        /// <summary>
        /// 刪除服務器信息
        /// </summary>
        /// <param name="_serverid">服務器的serverid</param>
        /// <returns>是否成功</returns>
        public bool delete(int _serverid)
        {
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.delete("es_server");
                m.addsql(" where serverid=");
                m.addsql("serverid", _serverid);

                return m.executenonquery(conn) > 0;
            }
        }
        #endregion
        #endregion

        #region 得到其它
        #region 得到此服務器所屬服務器群信息 mservergroup getservergroup(int _serverid)
        /// <summary>
        /// 得到此服務器所屬服務器群信息
        /// </summary>
        /// <param name="_serverid">服務器id</param>
        /// <returns>得到此服務器所屬服務器群信息</returns>
        public mservergroup getservergroup(int _serverid)
        {
            dataprovider dp = sqltools.helpwww.dataprovideruse;
            using (idbconnection conn = dp.getconnection())
            {
                common.dataaccess.ormapping.iconvert ic = dp.geticonvert();
                common.dataaccess.ormapping.mapping m = ic.getnewmapping();
                m.addsql("select * from es_servergroup where servergroupid = (select servergroupid from es_server where serverid=");
                m.addsql("serverid", _serverid);
                m.addsql(")");
                using (idatareader idr = m.executereader(conn))
                {
                    return common.entity.modelentityhelp<mservergroup>.get_ilist(idr)[0];
                }
            }
        }
        #endregion
        #endregion

        #endregion

        #region static
        /// <summary>
        /// 工廠方法得到dserver對象
        /// </summary>
        /// <returns>dserver對象</returns>
        public static dserver factory()
        {
            return common.singleton.provider<dserver>.instance;
        }
        #endregion

    }

    /// <summary>
    /// 服務器群信息數據訪問層
    /// </summary>
    public class dservergroup
    {
        #region constructor
        public dservergroup()
        {
        }
        #endregion

        #r