IIS操作类

添加引用 Microsoft.Web.Administration

using System;
using System.Data;
using System.DirectoryServices;
using System.Collections;

namespace IISManage
{
    /// <summary>
    /// IIS管理类，可以实现创建站点、虚拟目录，删除虚拟目录等
    /// </summary>
    public class IISManager
    {
        private string _server, _website, _AnonymousUserPass, _AnonymousUserName;
        private VirtualDirectories _virdirs;
        protected System.DirectoryServices.DirectoryEntry rootfolder;
        private bool _batchflag;

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public IISManager()
        {
            //默认情况下使用localhost，即访问本地机
            _server = "localhost";
            _website = "1";
            _batchflag = false;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="strServer">服务器</param>
        public IISManager(string strServer)
        {
            _server = strServer;
            _website = "1";
            _batchflag = false;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="strServer">服务器</param>
        /// <param name="website">站点，每一个站点为1，第二个站点为2，依此类推</param>
        public IISManager(string strServer, int website)
        {
            _server = strServer;
            _website = website.ToString();
            _batchflag = false;
        }
        #endregion

        #region 定义公共属性

        /// <summary>
        /// 匿名访问用户
        /// </summary>
        public string AnonymousUserName
        {
            get { return _AnonymousUserName; }
            set { _AnonymousUserName = value; }
        }

        /// <summary>
        /// 匿名访问用户密码
        /// </summary>
        public string AnonymousUserPass
        {
            get { return _AnonymousUserPass; }
            set { _AnonymousUserPass = value; }
        }

        /// <summary>
        /// 服务器，可以是IP或计算名
        /// </summary>
        public string Server
        {
            get { return _server; }
            set { _server = value; }
        }

        /// <summary>
        /// 站点，一般来说第一台主机为1,第二台主机为2，依次类推
        /// </summary>
        public int WebSite
        {
            get { return Convert.ToInt32(_website); }
            set { _website = Convert.ToString(value); }
        }

        /// <summary>
        /// 虚拟目录的名字
        /// </summary>
        public VirtualDirectories VirDirs
        {
            get { return _virdirs; }
            set { _virdirs = value; }
        }
        #endregion

        #region 定义公共方法
        /// <summary>
        /// 获取匿名访问用户的用户名和密码
        /// </summary>
        public void get_AnonymousUser()
        {
            _AnonymousUserPass = "IUSR_DEVE-SERVER";
            _AnonymousUserName = "IUSR_DEVE-SERVER";
            VirtualDirectory vDir;
            try
            {
                Hashtable myList = (Hashtable)_virdirs;
                IDictionaryEnumerator myEnumerator = myList.GetEnumerator();
                while (myEnumerator.MoveNext())
                {
                    vDir = (VirtualDirectory)myEnumerator.Value;
                    if (vDir.AnonymousUserName != "" && vDir.AnonymousUserPass != "")
                    {
                        _AnonymousUserName = vDir.AnonymousUserName;
                        _AnonymousUserPass = vDir.AnonymousUserPass;
                        break;
                    }
                }
            }
            catch
            {
                _AnonymousUserPass = "IUSR_DEVE-SERVER";
                _AnonymousUserName = "IUSR_DEVE-SERVER";
            }
        }

        /// <summary>
        /// 连接服务器
        /// </summary>
        public void Connect()
        {
            ConnectToServer();
        }

        /// <summary>
        /// 连接服务器
        /// </summary>
        /// <param name="strServer">服务器名称</param>
        public void Connect(string strServer)
        {
            _server = strServer;
            ConnectToServer();
        }
        /// <summary>
        /// 连接服务器
        /// </summary>
        /// <param name="strServer">服务器名称</param>
        /// <param name="strWebSite">站点，一般来说第一台主机为1,第二台主机为2，依次类推</param>
        public void Connect(string strServer, string strWebSite)
        {
            _server = strServer;
            _website = strWebSite;
            ConnectToServer();
        }

        /// <summary>
        /// 添加一个站点
        /// </summary>
        /// <param name="path">站点的路径</param>
        public void CreateWebSite(string webSiteName, string port, string path)
 {
 try
 {
 DirectoryEntry root = new DirectoryEntry("IIS://" this._server "/W3SVC");
 int siteID = 1;
 foreach(DirectoryEntry e in root.Children)
 {
 if(e.SchemaClassName == "IIsWebServer")
 {
 int ID = Convert.ToInt32(e.Name);
 if(ID >= siteID){siteID = ID 1;}
 if(e.Properties["ServerBindings"][0].ToString() == ":" port ":")
 {
 throw new Exception(port "已被占用，请选择其它端口！");
 }
 }
 }
DirectoryEntry site = (DirectoryEntry)root.Invoke("Create", "IIsWebServer", siteID);
 site.Invoke("Put", "ServerComment", webSiteName);
 site.Invoke("Put", "KeyType", "IIsWebServer");
 site.Invoke("Put", "ServerBindings", ":" port ":");
 site.Invoke("Put", "ServerState", 2);
 site.Invoke("Put", "FrontPageWeb", 1);
 site.Invoke("Put", "DefaultDoc", "index.aspx");
 site.Invoke("Put", "SecureBindings", ":443:");
 site.Invoke("Put", "ServerAutoStart", 1);
 site.Invoke("Put", "ServerSize", 1);
 site.Invoke("SetInfo");
 DirectoryEntry siteVDir = site.Children.Add("Root", "IISWebVirtualDir");
 siteVDir.Properties["AppIsolated"][0] = 2;
 siteVDir.Properties["Path"][0] = path;
 siteVDir.Properties["AccessFlags"][0] = 513;
 siteVDir.Properties["FrontPageWeb"][0] = 1;
 //siteVDir.Properties["AppRoot"][0] = "LM/W3SVC/" siteID "/Root";
 siteVDir.Properties["AppFriendlyName"][0] = "ROOT";
 siteVDir.CommitChanges();
 site.CommitChanges();
 }
 catch(Exception ex)
 {
 throw ex;
 }
 }

        /// <summary>
        /// 取得所有站点
        /// </summary>
        /// <returns></returns>
        public System.Collections.Hashtable getSites()
 {
 try
 {
 DirectoryEntry root = new DirectoryEntry("IIS://" this._server "/W3SVC");
 Hashtable sites = new Hashtable();
 foreach(DirectoryEntry e in root.Children)
 {
 if(e.SchemaClassName == "IIsWebServer")
 {
 sites.Add(e.Name,e);
 }
 }
 return sites;
 }
 catch(Exception ex)
 {
 throw ex;
 }
 }

        /// <summary>
        /// 判断是否存这个虚拟目录
        /// </summary>
        /// <param name="strVirdir">虚拟目录名称</param>
        /// <returns></returns>
        public bool Exists(string strVirdir)
        {
            return _virdirs.Contains(strVirdir);
        }

        /// <summary>
        /// 添加一个虚拟目录
        /// </summary>
        /// <param name="newdir">虚拟目录</param>
        /// <returns></returns>
        public bool CreateVirtualDirectory(VirtualDirectory newdir) 
{
 string strPath = "IIS://" _server "/W3SVC/" _website "/ROOT/" newdir.Name;
 if(!_virdirs.Contains(newdir.Name) || _batchflag )
 {
 try
 {
 //加入到ROOT的Children集合中去
DirectoryEntry newVirDir = rootfolder.Children.Add(newdir.Name,"IIsWebVirtualDir");
 newVirDir.Invoke("AppCreate",true);
 newVirDir.CommitChanges();
 rootfolder.CommitChanges();
 //然后更新数据
UpdateDirInfo(newVirDir,newdir);
 return true;
 }
 catch(Exception)
 {
 return false;
 }
 }
 else
 {
 return false;
 }
 }

        /// <summary>
        /// 得到一个虚拟目录
        /// </summary>
        /// <param name="strVirdir">虚拟目录名</param>
        /// <returns></returns>
        public VirtualDirectory GetVirDir(string strVirdir)
 {
 VirtualDirectory tmp = null;
 if(_virdirs.Contains(strVirdir))
 {
 tmp = _virdirs.Find(strVirdir);
 ((VirtualDirectory)_virdirs[strVirdir]).flag = 2;
 }
 else
 {
 throw new Exception("虚拟目录" strVirdir "不存在！");
 }
return tmp;
 }

        /// <summary>
        /// 更新一个虚拟目录
        /// </summary>
        /// <param name="dir">虚拟目录</param>
        public void Update(VirtualDirectory dir)
 {
 //判断需要更改的虚拟目录是否存在
if(_virdirs.Contains(dir.Name))
 {
 DirectoryEntry ode = rootfolder.Children.Find(dir.Name,"IIsWebVirtualDir");
 UpdateDirInfo(ode,dir);
 }
 else
 {
 System.Windows.Forms.MessageBox.Show("虚拟目录" dir.Name "不存在！");
 }
 }

        /// <summary>
        /// 删除一个虚拟目录
        /// </summary>
        /// <param name="strVirdir">虚拟目录名</param>
        public void Delete(string strVirdir)
 {
 if(_virdirs.Contains(strVirdir))
 {
 object[] paras = new object[2];
 paras[0] = "IIsWebVirtualDir"; //表示操作的是虚拟目录
paras[1] = strVirdir;
 rootfolder.Invoke("Delete",paras);
 rootfolder.CommitChanges();
 }
 else
 {
 System.Windows.Forms.MessageBox.Show("虚拟目录" strVirdir "不存在！");
 }
 }

        /// <summary>
        /// 批量更新
        /// </summary>
        public void UpdateBatch()
        {
            BatchUpdate(_virdirs);
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        /// <param name="vds">虚拟目录集合</param>
        public void UpdateBatch(VirtualDirectories vds)
        {
            BatchUpdate(vds);
        }

        /// <summary>
        /// 获取虚拟目录集合
        /// </summary>
        /// <returns></returns>
        public VirtualDirectories GetVirtualDirdctories()
        {
            VirtualDirectories vds = GetVirDirs(this.rootfolder.Children);
            return vds;
        }
        #endregion

        #region 私有方法

        /// <summary>
        /// 关闭当前对象
        /// </summary>
        public void Close()
        {
            _virdirs.Clear();
            _virdirs = null;
            rootfolder.Dispose();

        }

        /// <summary>
        /// 连接服务器
        /// </summary>
        private void ConnectToServer()
 {
 string strPath = "IIS://" _server "/W3SVC/" _website "/ROOT";
 try
 {
 this.rootfolder = new DirectoryEntry(strPath);
 _virdirs = GetVirDirs(this.rootfolder.Children);
 } 
catch(Exception)
 {
 System.Windows.Forms.MessageBox.Show("无法连接到服务器：" _server);
 }
 }

        /// <summary>
        /// 执行批量更新
        /// </summary>
        /// <param name="vds">虚拟目录集合</param>
        private void BatchUpdate(VirtualDirectories vds)
        {
            _batchflag = true;
            foreach (object item in vds.Values)
            {
                VirtualDirectory vd = (VirtualDirectory)item;
                switch (vd.flag)
                {
                    case 0:
                        break;
                    case 1:
                        CreateVirtualDirectory(vd);
                        break;
                    case 2:
                        Update(vd);
                        break;
                }
            }
            _batchflag = false;
        }
        /// <summary>
        /// 更新指定虚拟目录
        /// </summary>
        /// <param name="de"></param>
        /// <param name="vd">要执行更新的虚拟目录</param>
        private void UpdateDirInfo(DirectoryEntry de, VirtualDirectory vd)
        {
            de.Properties["AnonymousUserName"][0] = vd.AnonymousUserName;
            de.Properties["AnonymousUserPass"][0] = vd.AnonymousUserPass;

            de.Properties["AccessRead"][0] = vd.AccessRead;
            de.Properties["AccessExecute"][0] = vd.AccessExecute;
            de.Properties["AccessWrite"][0] = vd.AccessWrite;
            de.Properties["AuthBasic"][0] = vd.AuthBasic;
            de.Properties["AuthNTLM"][0] = vd.AuthNTLM;
            de.Properties["ContentIndexed"][0] = vd.ContentIndexed;
            de.Properties["EnableDefaultDoc"][0] = vd.EnableDefaultDoc;
            de.Properties["EnableDirBrowsing"][0] = vd.EnableDirBrowsing;
            de.Properties["AccessSSL"][0] = vd.AccessSSL;
            de.Properties["AccessScript"][0] = vd.AccessScript;
            de.Properties["DefaultDoc"][0] = vd.DefaultDoc;
            de.Properties["Path"][0] = vd.Path;
            de.CommitChanges();
        }

        /// <summary>
        /// 获取虚拟目录集合
        /// </summary>
        /// <param name="des"></param>
        /// <returns></returns>
        private VirtualDirectories GetVirDirs(DirectoryEntries des)
        {
            VirtualDirectories tmpdirs = new VirtualDirectories();
            foreach (DirectoryEntry de in des)
            {
                if (de.SchemaClassName == "IIsWebVirtualDir")
                {
                    VirtualDirectory vd = new VirtualDirectory();
                    vd.Name = de.Name;
                    vd.AccessRead = (bool)de.Properties["AccessRead"][0];
                    vd.AccessExecute = (bool)de.Properties["AccessExecute"][0];
                    vd.AccessWrite = (bool)de.Properties["AccessWrite"][0];
                    vd.AnonymousUserName = (string)de.Properties["AnonymousUserName"][0];
                    vd.AnonymousUserPass = (string)de.Properties["AnonymousUserName"][0];
                    vd.AuthBasic = (bool)de.Properties["AuthBasic"][0];
                    vd.AuthNTLM = (bool)de.Properties["AuthNTLM"][0];
                    vd.ContentIndexed = (bool)de.Properties["ContentIndexed"][0];
                    vd.EnableDefaultDoc = (bool)de.Properties["EnableDefaultDoc"][0];
                    vd.EnableDirBrowsing = (bool)de.Properties["EnableDirBrowsing"][0];
                    vd.AccessSSL = (bool)de.Properties["AccessSSL"][0];
                    vd.AccessScript = (bool)de.Properties["AccessScript"][0];
                    vd.Path = (string)de.Properties["Path"][0];
                    vd.flag = 0;
                    vd.DefaultDoc = (string)de.Properties["DefaultDoc"][0];
                    tmpdirs.Add(vd.Name, vd);
                }
            }
            return tmpdirs;
        }
        #endregion
    }

    /// <summary>
    /// 虚拟目录实体
    /// </summary>
    public class VirtualDirectory
    {
        private bool _read, _execute, _script, _ssl, _write, _authbasic, _authntlm, _indexed, _endirbrow, _endefaultdoc;
        private string _ausername, _auserpass, _name, _path;
        private int _flag;
        private string _defaultdoc;

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public VirtualDirectory()
        {
            SetValue();
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="sVirDirName">虚拟目录名</param>
        public VirtualDirectory(string sVirDirName)
        {
            SetValue();
            _name = sVirDirName;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="sVirDirName">虚拟目录名</param>
        /// <param name="strPhyPath">物理路径</param>
        /// <param name="AnonymousUser"></param>
        public VirtualDirectory(string sVirDirName, string strPhyPath, string[] AnonymousUser)
        {
            SetValue();
            _name = sVirDirName;
            _path = strPhyPath;
            _ausername = AnonymousUser[0];
            _auserpass = AnonymousUser[1];
        }
        #endregion

        /// <summary>
        /// 设置虚拟目录的属性
        /// </summary>
        private void SetValue()
        {
            _read = true;
            _execute = false;
            _script = true;
            _ssl = false;
            _write = false;
            _authbasic = false;
            _authntlm = true;
            _indexed = true;
            _endirbrow = false;
            _endefaultdoc = true;
            _flag = 1;
            _defaultdoc = "index.aspx";
            _path = "C:\\";
            _ausername = "IUSR_DEVE-SERVER";
            _auserpass = "IUSR_DEVE-SERVER";
            _name = "";
        }

        public override string ToString()
        {
            return this._name;
        }


        #region 定义属性
        public int flag
        {
            get { return _flag; }
            set { _flag = value; }
        }
        public bool AccessRead
        {
            get { return _read; }
            set { _read = value; }
        }
        public bool AccessWrite
        {
            get { return _write; }
            set { _write = value; }
        }
        public bool AccessExecute
        {
            get { return _execute; }
            set { _execute = value; }
        }
        public bool AccessSSL
        {
            get { return _ssl; }
            set { _ssl = value; }
        }
        public bool AccessScript
        {
            get { return _script; }
            set { _script = value; }
        }
        public bool AuthBasic
        {
            get { return _authbasic; }
            set { _authbasic = value; }
        }
        public bool AuthNTLM
        {
            get { return _authntlm; }
            set { _authntlm = value; }
        }
        public bool ContentIndexed
        {
            get { return _indexed; }
            set { _indexed = value; }
        }
        public bool EnableDirBrowsing
        {
            get { return _endirbrow; }
            set { _endirbrow = value; }
        }

        public bool EnableDefaultDoc
        {
            get { return _endefaultdoc; }
            set { _endefaultdoc = value; }
        }
        public string Name
        {
            get { return _name; }
            set { _name = value; }
        }
        public string Path
        {
            get { return _path; }
            set { _path = value; }
        }
        public string DefaultDoc
        {
            get { return _defaultdoc; }
            set { _defaultdoc = value; }
        }
        public string AnonymousUserName
        {
            get { return _ausername; }
            set { _ausername = value; }
        }
        public string AnonymousUserPass
        {
            get { return _auserpass; }
            set { _auserpass = value; }
        }
        #endregion
    }

    /// <summary>
    /// 虚拟目录集合类
    /// </summary>
    public class VirtualDirectories : System.Collections.Hashtable
    {
        public VirtualDirectories()
        {
        }

        /// <summary>
        /// 搜索指定的虚拟目录
        /// </summary>
        /// <param name="strName">虚拟目录名</param>
        /// <returns></returns>
        public VirtualDirectory Find(string strName)
        {
            return (VirtualDirectory)this[strName];
        }
    }
}